1 use crate::vk::aliases::*;
2 use crate::vk::bitflags::*;
3 use crate::vk::constants::*;
4 use crate::vk::enums::*;
5 use crate::vk::native::*;
6 use crate::vk::platform_types::*;
7 use crate::vk::prelude::*;
8 use crate::vk::{ptr_chain_iter, Handle};
9 use std::fmt;
10 use std::os::raw::*;
11 #[deprecated = "This define is deprecated. VK_MAKE_API_VERSION should be used instead."]
12 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_MAKE_VERSION.html>"]
make_version(major: u32, minor: u32, patch: u32) -> u3213 pub const fn make_version(major: u32, minor: u32, patch: u32) -> u32 {
14     ((major) << 22) | ((minor) << 12) | (patch)
15 }
16 #[deprecated = "This define is deprecated. VK_API_VERSION_MAJOR should be used instead."]
17 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_MAJOR.html>"]
version_major(version: u32) -> u3218 pub const fn version_major(version: u32) -> u32 {
19     (version) >> 22
20 }
21 #[deprecated = "This define is deprecated. VK_API_VERSION_MINOR should be used instead."]
22 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_MINOR.html>"]
version_minor(version: u32) -> u3223 pub const fn version_minor(version: u32) -> u32 {
24     ((version) >> 12) & 0x3ffu32
25 }
26 #[deprecated = "This define is deprecated. VK_API_VERSION_PATCH should be used instead."]
27 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_PATCH.html>"]
version_patch(version: u32) -> u3228 pub const fn version_patch(version: u32) -> u32 {
29     (version) & 0xfffu32
30 }
31 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_MAKE_API_VERSION.html>"]
make_api_version(variant: u32, major: u32, minor: u32, patch: u32) -> u3232 pub const fn make_api_version(variant: u32, major: u32, minor: u32, patch: u32) -> u32 {
33     ((variant) << 29) | ((major) << 22) | ((minor) << 12) | (patch)
34 }
35 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_VARIANT.html>"]
api_version_variant(version: u32) -> u3236 pub const fn api_version_variant(version: u32) -> u32 {
37     (version) >> 29
38 }
39 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_MAJOR.html>"]
api_version_major(version: u32) -> u3240 pub const fn api_version_major(version: u32) -> u32 {
41     ((version) >> 22) & 0x7fu32
42 }
43 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_MINOR.html>"]
api_version_minor(version: u32) -> u3244 pub const fn api_version_minor(version: u32) -> u32 {
45     ((version) >> 12) & 0x3ffu32
46 }
47 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_PATCH.html>"]
api_version_patch(version: u32) -> u3248 pub const fn api_version_patch(version: u32) -> u32 {
49     (version) & 0xfffu32
50 }
51 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_1_0.html>"]
52 pub const API_VERSION_1_0: u32 = make_api_version(0, 1, 0, 0);
53 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_1_1.html>"]
54 pub const API_VERSION_1_1: u32 = make_api_version(0, 1, 1, 0);
55 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_1_2.html>"]
56 pub const API_VERSION_1_2: u32 = make_api_version(0, 1, 2, 0);
57 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_1_3.html>"]
58 pub const API_VERSION_1_3: u32 = make_api_version(0, 1, 3, 0);
59 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_HEADER_VERSION.html>"]
60 pub const HEADER_VERSION: u32 = 251;
61 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_HEADER_VERSION_COMPLETE.html>"]
62 pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 3, HEADER_VERSION);
63 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSampleMask.html>"]
64 pub type SampleMask = u32;
65 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBool32.html>"]
66 pub type Bool32 = u32;
67 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFlags.html>"]
68 pub type Flags = u32;
69 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFlags64.html>"]
70 pub type Flags64 = u64;
71 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceSize.html>"]
72 pub type DeviceSize = u64;
73 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceAddress.html>"]
74 pub type DeviceAddress = u64;
75 #[repr(transparent)]
76 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
77 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPoolCreateFlags.html>"]
78 pub struct QueryPoolCreateFlags(pub(crate) Flags);
79 vk_bitflags_wrapped!(QueryPoolCreateFlags, Flags);
80 #[repr(transparent)]
81 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
82 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDynamicStateCreateFlags.html>"]
83 pub struct PipelineDynamicStateCreateFlags(pub(crate) Flags);
84 vk_bitflags_wrapped!(PipelineDynamicStateCreateFlags, Flags);
85 #[repr(transparent)]
86 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
87 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineMultisampleStateCreateFlags.html>"]
88 pub struct PipelineMultisampleStateCreateFlags(pub(crate) Flags);
89 vk_bitflags_wrapped!(PipelineMultisampleStateCreateFlags, Flags);
90 #[repr(transparent)]
91 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
92 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationStateCreateFlags.html>"]
93 pub struct PipelineRasterizationStateCreateFlags(pub(crate) Flags);
94 vk_bitflags_wrapped!(PipelineRasterizationStateCreateFlags, Flags);
95 #[repr(transparent)]
96 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
97 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportStateCreateFlags.html>"]
98 pub struct PipelineViewportStateCreateFlags(pub(crate) Flags);
99 vk_bitflags_wrapped!(PipelineViewportStateCreateFlags, Flags);
100 #[repr(transparent)]
101 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
102 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineTessellationStateCreateFlags.html>"]
103 pub struct PipelineTessellationStateCreateFlags(pub(crate) Flags);
104 vk_bitflags_wrapped!(PipelineTessellationStateCreateFlags, Flags);
105 #[repr(transparent)]
106 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
107 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineInputAssemblyStateCreateFlags.html>"]
108 pub struct PipelineInputAssemblyStateCreateFlags(pub(crate) Flags);
109 vk_bitflags_wrapped!(PipelineInputAssemblyStateCreateFlags, Flags);
110 #[repr(transparent)]
111 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
112 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineVertexInputStateCreateFlags.html>"]
113 pub struct PipelineVertexInputStateCreateFlags(pub(crate) Flags);
114 vk_bitflags_wrapped!(PipelineVertexInputStateCreateFlags, Flags);
115 #[repr(transparent)]
116 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
117 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferViewCreateFlags.html>"]
118 pub struct BufferViewCreateFlags(pub(crate) Flags);
119 vk_bitflags_wrapped!(BufferViewCreateFlags, Flags);
120 #[repr(transparent)]
121 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
122 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceCreateFlags.html>"]
123 pub struct DeviceCreateFlags(pub(crate) Flags);
124 vk_bitflags_wrapped!(DeviceCreateFlags, Flags);
125 #[repr(transparent)]
126 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
127 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryMapFlags.html>"]
128 pub struct MemoryMapFlags(pub(crate) Flags);
129 vk_bitflags_wrapped!(MemoryMapFlags, Flags);
130 #[repr(transparent)]
131 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
132 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPoolResetFlags.html>"]
133 pub struct DescriptorPoolResetFlags(pub(crate) Flags);
134 vk_bitflags_wrapped!(DescriptorPoolResetFlags, Flags);
135 #[repr(transparent)]
136 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
137 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorUpdateTemplateCreateFlags.html>"]
138 pub struct DescriptorUpdateTemplateCreateFlags(pub(crate) Flags);
139 vk_bitflags_wrapped!(DescriptorUpdateTemplateCreateFlags, Flags);
140 #[repr(transparent)]
141 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
142 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMotionInfoFlagsNV.html>"]
143 pub struct AccelerationStructureMotionInfoFlagsNV(pub(crate) Flags);
144 vk_bitflags_wrapped!(AccelerationStructureMotionInfoFlagsNV, Flags);
145 #[repr(transparent)]
146 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
147 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMotionInstanceFlagsNV.html>"]
148 pub struct AccelerationStructureMotionInstanceFlagsNV(pub(crate) Flags);
149 vk_bitflags_wrapped!(AccelerationStructureMotionInstanceFlagsNV, Flags);
150 #[repr(transparent)]
151 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
152 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDirectDriverLoadingFlagsLUNARG.html>"]
153 pub struct DirectDriverLoadingFlagsLUNARG(pub(crate) Flags);
154 vk_bitflags_wrapped!(DirectDriverLoadingFlagsLUNARG, Flags);
155 #[repr(transparent)]
156 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
157 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModeCreateFlagsKHR.html>"]
158 pub struct DisplayModeCreateFlagsKHR(pub(crate) Flags);
159 vk_bitflags_wrapped!(DisplayModeCreateFlagsKHR, Flags);
160 #[repr(transparent)]
161 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
162 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplaySurfaceCreateFlagsKHR.html>"]
163 pub struct DisplaySurfaceCreateFlagsKHR(pub(crate) Flags);
164 vk_bitflags_wrapped!(DisplaySurfaceCreateFlagsKHR, Flags);
165 #[repr(transparent)]
166 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
167 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAndroidSurfaceCreateFlagsKHR.html>"]
168 pub struct AndroidSurfaceCreateFlagsKHR(pub(crate) Flags);
169 vk_bitflags_wrapped!(AndroidSurfaceCreateFlagsKHR, Flags);
170 #[repr(transparent)]
171 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
172 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkViSurfaceCreateFlagsNN.html>"]
173 pub struct ViSurfaceCreateFlagsNN(pub(crate) Flags);
174 vk_bitflags_wrapped!(ViSurfaceCreateFlagsNN, Flags);
175 #[repr(transparent)]
176 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
177 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWaylandSurfaceCreateFlagsKHR.html>"]
178 pub struct WaylandSurfaceCreateFlagsKHR(pub(crate) Flags);
179 vk_bitflags_wrapped!(WaylandSurfaceCreateFlagsKHR, Flags);
180 #[repr(transparent)]
181 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
182 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWin32SurfaceCreateFlagsKHR.html>"]
183 pub struct Win32SurfaceCreateFlagsKHR(pub(crate) Flags);
184 vk_bitflags_wrapped!(Win32SurfaceCreateFlagsKHR, Flags);
185 #[repr(transparent)]
186 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
187 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkXlibSurfaceCreateFlagsKHR.html>"]
188 pub struct XlibSurfaceCreateFlagsKHR(pub(crate) Flags);
189 vk_bitflags_wrapped!(XlibSurfaceCreateFlagsKHR, Flags);
190 #[repr(transparent)]
191 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
192 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkXcbSurfaceCreateFlagsKHR.html>"]
193 pub struct XcbSurfaceCreateFlagsKHR(pub(crate) Flags);
194 vk_bitflags_wrapped!(XcbSurfaceCreateFlagsKHR, Flags);
195 #[repr(transparent)]
196 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
197 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDirectFBSurfaceCreateFlagsEXT.html>"]
198 pub struct DirectFBSurfaceCreateFlagsEXT(pub(crate) Flags);
199 vk_bitflags_wrapped!(DirectFBSurfaceCreateFlagsEXT, Flags);
200 #[repr(transparent)]
201 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
202 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIOSSurfaceCreateFlagsMVK.html>"]
203 pub struct IOSSurfaceCreateFlagsMVK(pub(crate) Flags);
204 vk_bitflags_wrapped!(IOSSurfaceCreateFlagsMVK, Flags);
205 #[repr(transparent)]
206 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
207 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMacOSSurfaceCreateFlagsMVK.html>"]
208 pub struct MacOSSurfaceCreateFlagsMVK(pub(crate) Flags);
209 vk_bitflags_wrapped!(MacOSSurfaceCreateFlagsMVK, Flags);
210 #[repr(transparent)]
211 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
212 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMetalSurfaceCreateFlagsEXT.html>"]
213 pub struct MetalSurfaceCreateFlagsEXT(pub(crate) Flags);
214 vk_bitflags_wrapped!(MetalSurfaceCreateFlagsEXT, Flags);
215 #[repr(transparent)]
216 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
217 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImagePipeSurfaceCreateFlagsFUCHSIA.html>"]
218 pub struct ImagePipeSurfaceCreateFlagsFUCHSIA(pub(crate) Flags);
219 vk_bitflags_wrapped!(ImagePipeSurfaceCreateFlagsFUCHSIA, Flags);
220 #[repr(transparent)]
221 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
222 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkStreamDescriptorSurfaceCreateFlagsGGP.html>"]
223 pub struct StreamDescriptorSurfaceCreateFlagsGGP(pub(crate) Flags);
224 vk_bitflags_wrapped!(StreamDescriptorSurfaceCreateFlagsGGP, Flags);
225 #[repr(transparent)]
226 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
227 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkHeadlessSurfaceCreateFlagsEXT.html>"]
228 pub struct HeadlessSurfaceCreateFlagsEXT(pub(crate) Flags);
229 vk_bitflags_wrapped!(HeadlessSurfaceCreateFlagsEXT, Flags);
230 #[repr(transparent)]
231 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
232 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkScreenSurfaceCreateFlagsQNX.html>"]
233 pub struct ScreenSurfaceCreateFlagsQNX(pub(crate) Flags);
234 vk_bitflags_wrapped!(ScreenSurfaceCreateFlagsQNX, Flags);
235 #[repr(transparent)]
236 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
237 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandPoolTrimFlags.html>"]
238 pub struct CommandPoolTrimFlags(pub(crate) Flags);
239 vk_bitflags_wrapped!(CommandPoolTrimFlags, Flags);
240 #[repr(transparent)]
241 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
242 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportSwizzleStateCreateFlagsNV.html>"]
243 pub struct PipelineViewportSwizzleStateCreateFlagsNV(pub(crate) Flags);
244 vk_bitflags_wrapped!(PipelineViewportSwizzleStateCreateFlagsNV, Flags);
245 #[repr(transparent)]
246 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
247 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDiscardRectangleStateCreateFlagsEXT.html>"]
248 pub struct PipelineDiscardRectangleStateCreateFlagsEXT(pub(crate) Flags);
249 vk_bitflags_wrapped!(PipelineDiscardRectangleStateCreateFlagsEXT, Flags);
250 #[repr(transparent)]
251 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
252 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageToColorStateCreateFlagsNV.html>"]
253 pub struct PipelineCoverageToColorStateCreateFlagsNV(pub(crate) Flags);
254 vk_bitflags_wrapped!(PipelineCoverageToColorStateCreateFlagsNV, Flags);
255 #[repr(transparent)]
256 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
257 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageModulationStateCreateFlagsNV.html>"]
258 pub struct PipelineCoverageModulationStateCreateFlagsNV(pub(crate) Flags);
259 vk_bitflags_wrapped!(PipelineCoverageModulationStateCreateFlagsNV, Flags);
260 #[repr(transparent)]
261 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
262 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageReductionStateCreateFlagsNV.html>"]
263 pub struct PipelineCoverageReductionStateCreateFlagsNV(pub(crate) Flags);
264 vk_bitflags_wrapped!(PipelineCoverageReductionStateCreateFlagsNV, Flags);
265 #[repr(transparent)]
266 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
267 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationCacheCreateFlagsEXT.html>"]
268 pub struct ValidationCacheCreateFlagsEXT(pub(crate) Flags);
269 vk_bitflags_wrapped!(ValidationCacheCreateFlagsEXT, Flags);
270 #[repr(transparent)]
271 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
272 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessengerCreateFlagsEXT.html>"]
273 pub struct DebugUtilsMessengerCreateFlagsEXT(pub(crate) Flags);
274 vk_bitflags_wrapped!(DebugUtilsMessengerCreateFlagsEXT, Flags);
275 #[repr(transparent)]
276 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
277 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessengerCallbackDataFlagsEXT.html>"]
278 pub struct DebugUtilsMessengerCallbackDataFlagsEXT(pub(crate) Flags);
279 vk_bitflags_wrapped!(DebugUtilsMessengerCallbackDataFlagsEXT, Flags);
280 #[repr(transparent)]
281 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
282 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceMemoryReportFlagsEXT.html>"]
283 pub struct DeviceMemoryReportFlagsEXT(pub(crate) Flags);
284 vk_bitflags_wrapped!(DeviceMemoryReportFlagsEXT, Flags);
285 #[repr(transparent)]
286 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
287 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationConservativeStateCreateFlagsEXT.html>"]
288 pub struct PipelineRasterizationConservativeStateCreateFlagsEXT(pub(crate) Flags);
289 vk_bitflags_wrapped!(PipelineRasterizationConservativeStateCreateFlagsEXT, Flags);
290 #[repr(transparent)]
291 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
292 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationStateStreamCreateFlagsEXT.html>"]
293 pub struct PipelineRasterizationStateStreamCreateFlagsEXT(pub(crate) Flags);
294 vk_bitflags_wrapped!(PipelineRasterizationStateStreamCreateFlagsEXT, Flags);
295 #[repr(transparent)]
296 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
297 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationDepthClipStateCreateFlagsEXT.html>"]
298 pub struct PipelineRasterizationDepthClipStateCreateFlagsEXT(pub(crate) Flags);
299 vk_bitflags_wrapped!(PipelineRasterizationDepthClipStateCreateFlagsEXT, Flags);
300 #[repr(transparent)]
301 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
302 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionParametersCreateFlagsKHR.html>"]
303 pub struct VideoSessionParametersCreateFlagsKHR(pub(crate) Flags);
304 vk_bitflags_wrapped!(VideoSessionParametersCreateFlagsKHR, Flags);
305 #[repr(transparent)]
306 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
307 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoBeginCodingFlagsKHR.html>"]
308 pub struct VideoBeginCodingFlagsKHR(pub(crate) Flags);
309 vk_bitflags_wrapped!(VideoBeginCodingFlagsKHR, Flags);
310 #[repr(transparent)]
311 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
312 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEndCodingFlagsKHR.html>"]
313 pub struct VideoEndCodingFlagsKHR(pub(crate) Flags);
314 vk_bitflags_wrapped!(VideoEndCodingFlagsKHR, Flags);
315 #[repr(transparent)]
316 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
317 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeFlagsKHR.html>"]
318 pub struct VideoDecodeFlagsKHR(pub(crate) Flags);
319 vk_bitflags_wrapped!(VideoDecodeFlagsKHR, Flags);
320 #[repr(transparent)]
321 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
322 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeFlagsKHR.html>"]
323 pub struct VideoEncodeFlagsKHR(pub(crate) Flags);
324 vk_bitflags_wrapped!(VideoEncodeFlagsKHR, Flags);
325 #[repr(transparent)]
326 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
327 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeRateControlFlagsKHR.html>"]
328 pub struct VideoEncodeRateControlFlagsKHR(pub(crate) Flags);
329 vk_bitflags_wrapped!(VideoEncodeRateControlFlagsKHR, Flags);
330 #[repr(transparent)]
331 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
332 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryUnmapFlagsKHR.html>"]
333 pub struct MemoryUnmapFlagsKHR(pub(crate) Flags);
334 vk_bitflags_wrapped!(MemoryUnmapFlagsKHR, Flags);
335 define_handle!(
336     Instance,
337     INSTANCE,
338     doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkInstance.html>"
339 );
340 define_handle ! (PhysicalDevice , PHYSICAL_DEVICE , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevice.html>") ;
341 define_handle!(
342     Device,
343     DEVICE,
344     doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDevice.html>"
345 );
346 define_handle!(
347     Queue,
348     QUEUE,
349     doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueue.html>"
350 );
351 define_handle ! (CommandBuffer , COMMAND_BUFFER , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBuffer.html>") ;
352 handle_nondispatchable ! (DeviceMemory , DEVICE_MEMORY , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceMemory.html>") ;
353 handle_nondispatchable ! (CommandPool , COMMAND_POOL , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandPool.html>") ;
354 handle_nondispatchable!(
355     Buffer,
356     BUFFER,
357     doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBuffer.html>"
358 );
359 handle_nondispatchable!(
360     BufferView,
361     BUFFER_VIEW,
362     doc =
363         "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferView.html>"
364 );
365 handle_nondispatchable!(
366     Image,
367     IMAGE,
368     doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImage.html>"
369 );
370 handle_nondispatchable!(
371     ImageView,
372     IMAGE_VIEW,
373     doc =
374         "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageView.html>"
375 );
376 handle_nondispatchable ! (ShaderModule , SHADER_MODULE , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderModule.html>") ;
377 handle_nondispatchable!(
378     Pipeline,
379     PIPELINE,
380     doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipeline.html>"
381 );
382 handle_nondispatchable ! (PipelineLayout , PIPELINE_LAYOUT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineLayout.html>") ;
383 handle_nondispatchable!(
384     Sampler,
385     SAMPLER,
386     doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSampler.html>"
387 );
388 handle_nondispatchable ! (DescriptorSet , DESCRIPTOR_SET , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSet.html>") ;
389 handle_nondispatchable ! (DescriptorSetLayout , DESCRIPTOR_SET_LAYOUT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayout.html>") ;
390 handle_nondispatchable ! (DescriptorPool , DESCRIPTOR_POOL , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPool.html>") ;
391 handle_nondispatchable!(
392     Fence,
393     FENCE,
394     doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFence.html>"
395 );
396 handle_nondispatchable!(
397     Semaphore,
398     SEMAPHORE,
399     doc =
400         "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphore.html>"
401 );
402 handle_nondispatchable!(
403     Event,
404     EVENT,
405     doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkEvent.html>"
406 );
407 handle_nondispatchable!(
408     QueryPool,
409     QUERY_POOL,
410     doc =
411         "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPool.html>"
412 );
413 handle_nondispatchable ! (Framebuffer , FRAMEBUFFER , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebuffer.html>") ;
414 handle_nondispatchable!(
415     RenderPass,
416     RENDER_PASS,
417     doc =
418         "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPass.html>"
419 );
420 handle_nondispatchable ! (PipelineCache , PIPELINE_CACHE , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCache.html>") ;
421 handle_nondispatchable ! (IndirectCommandsLayoutNV , INDIRECT_COMMANDS_LAYOUT_NV , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIndirectCommandsLayoutNV.html>") ;
422 handle_nondispatchable ! (DescriptorUpdateTemplate , DESCRIPTOR_UPDATE_TEMPLATE , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorUpdateTemplate.html>") ;
423 handle_nondispatchable ! (SamplerYcbcrConversion , SAMPLER_YCBCR_CONVERSION , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerYcbcrConversion.html>") ;
424 handle_nondispatchable ! (ValidationCacheEXT , VALIDATION_CACHE_EXT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationCacheEXT.html>") ;
425 handle_nondispatchable ! (AccelerationStructureKHR , ACCELERATION_STRUCTURE_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureKHR.html>") ;
426 handle_nondispatchable ! (AccelerationStructureNV , ACCELERATION_STRUCTURE_NV , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureNV.html>") ;
427 handle_nondispatchable ! (PerformanceConfigurationINTEL , PERFORMANCE_CONFIGURATION_INTEL , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceConfigurationINTEL.html>") ;
428 handle_nondispatchable ! (BufferCollectionFUCHSIA , BUFFER_COLLECTION_FUCHSIA , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCollectionFUCHSIA.html>") ;
429 handle_nondispatchable ! (DeferredOperationKHR , DEFERRED_OPERATION_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeferredOperationKHR.html>") ;
430 handle_nondispatchable ! (PrivateDataSlot , PRIVATE_DATA_SLOT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPrivateDataSlot.html>") ;
431 handle_nondispatchable ! (CuModuleNVX , CU_MODULE_NVX , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCuModuleNVX.html>") ;
432 handle_nondispatchable ! (CuFunctionNVX , CU_FUNCTION_NVX , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCuFunctionNVX.html>") ;
433 handle_nondispatchable ! (OpticalFlowSessionNV , OPTICAL_FLOW_SESSION_NV , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowSessionNV.html>") ;
434 handle_nondispatchable ! (MicromapEXT , MICROMAP_EXT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMicromapEXT.html>") ;
435 handle_nondispatchable!(
436     ShaderEXT,
437     SHADER_EXT,
438     doc =
439         "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderEXT.html>"
440 );
441 handle_nondispatchable!(
442     DisplayKHR,
443     DISPLAY_KHR,
444     doc =
445         "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayKHR.html>"
446 );
447 handle_nondispatchable ! (DisplayModeKHR , DISPLAY_MODE_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModeKHR.html>") ;
448 handle_nondispatchable!(
449     SurfaceKHR,
450     SURFACE_KHR,
451     doc =
452         "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceKHR.html>"
453 );
454 handle_nondispatchable ! (SwapchainKHR , SWAPCHAIN_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainKHR.html>") ;
455 handle_nondispatchable ! (DebugReportCallbackEXT , DEBUG_REPORT_CALLBACK_EXT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugReportCallbackEXT.html>") ;
456 handle_nondispatchable ! (DebugUtilsMessengerEXT , DEBUG_UTILS_MESSENGER_EXT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessengerEXT.html>") ;
457 handle_nondispatchable ! (VideoSessionKHR , VIDEO_SESSION_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionKHR.html>") ;
458 handle_nondispatchable ! (VideoSessionParametersKHR , VIDEO_SESSION_PARAMETERS_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionParametersKHR.html>") ;
459 #[allow(non_camel_case_types)]
460 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkInternalAllocationNotification.html>"]
461 pub type PFN_vkInternalAllocationNotification = Option<
462     unsafe extern "system" fn(
463         p_user_data: *mut c_void,
464         size: usize,
465         allocation_type: InternalAllocationType,
466         allocation_scope: SystemAllocationScope,
467     ),
468 >;
469 #[allow(non_camel_case_types)]
470 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkInternalFreeNotification.html>"]
471 pub type PFN_vkInternalFreeNotification = Option<
472     unsafe extern "system" fn(
473         p_user_data: *mut c_void,
474         size: usize,
475         allocation_type: InternalAllocationType,
476         allocation_scope: SystemAllocationScope,
477     ),
478 >;
479 #[allow(non_camel_case_types)]
480 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkReallocationFunction.html>"]
481 pub type PFN_vkReallocationFunction = Option<
482     unsafe extern "system" fn(
483         p_user_data: *mut c_void,
484         p_original: *mut c_void,
485         size: usize,
486         alignment: usize,
487         allocation_scope: SystemAllocationScope,
488     ) -> *mut c_void,
489 >;
490 #[allow(non_camel_case_types)]
491 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkAllocationFunction.html>"]
492 pub type PFN_vkAllocationFunction = Option<
493     unsafe extern "system" fn(
494         p_user_data: *mut c_void,
495         size: usize,
496         alignment: usize,
497         allocation_scope: SystemAllocationScope,
498     ) -> *mut c_void,
499 >;
500 #[allow(non_camel_case_types)]
501 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkFreeFunction.html>"]
502 pub type PFN_vkFreeFunction =
503     Option<unsafe extern "system" fn(p_user_data: *mut c_void, p_memory: *mut c_void)>;
504 #[allow(non_camel_case_types)]
505 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkVoidFunction.html>"]
506 pub type PFN_vkVoidFunction = Option<unsafe extern "system" fn()>;
507 #[allow(non_camel_case_types)]
508 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkDebugReportCallbackEXT.html>"]
509 pub type PFN_vkDebugReportCallbackEXT = Option<
510     unsafe extern "system" fn(
511         flags: DebugReportFlagsEXT,
512         object_type: DebugReportObjectTypeEXT,
513         object: u64,
514         location: usize,
515         message_code: i32,
516         p_layer_prefix: *const c_char,
517         p_message: *const c_char,
518         p_user_data: *mut c_void,
519     ) -> Bool32,
520 >;
521 #[allow(non_camel_case_types)]
522 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkDebugUtilsMessengerCallbackEXT.html>"]
523 pub type PFN_vkDebugUtilsMessengerCallbackEXT = Option<
524     unsafe extern "system" fn(
525         message_severity: DebugUtilsMessageSeverityFlagsEXT,
526         message_types: DebugUtilsMessageTypeFlagsEXT,
527         p_callback_data: *const DebugUtilsMessengerCallbackDataEXT,
528         p_user_data: *mut c_void,
529     ) -> Bool32,
530 >;
531 #[allow(non_camel_case_types)]
532 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkDeviceMemoryReportCallbackEXT.html>"]
533 pub type PFN_vkDeviceMemoryReportCallbackEXT = Option<
534     unsafe extern "system" fn(
535         p_callback_data: *const DeviceMemoryReportCallbackDataEXT,
536         p_user_data: *mut c_void,
537     ),
538 >;
539 #[allow(non_camel_case_types)]
540 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkGetInstanceProcAddrLUNARG.html>"]
541 pub type PFN_vkGetInstanceProcAddrLUNARG = Option<
542     unsafe extern "system" fn(instance: Instance, p_name: *const c_char) -> PFN_vkVoidFunction,
543 >;
544 #[repr(C)]
545 #[cfg_attr(feature = "debug", derive(Debug))]
546 #[derive(Copy, Clone)]
547 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBaseOutStructure.html>"]
548 pub struct BaseOutStructure {
549     pub s_type: StructureType,
550     pub p_next: *mut Self,
551 }
552 impl ::std::default::Default for BaseOutStructure {
553     #[inline]
default() -> Self554     fn default() -> Self {
555         Self {
556             s_type: unsafe { ::std::mem::zeroed() },
557             p_next: ::std::ptr::null_mut(),
558         }
559     }
560 }
561 #[repr(C)]
562 #[cfg_attr(feature = "debug", derive(Debug))]
563 #[derive(Copy, Clone)]
564 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBaseInStructure.html>"]
565 pub struct BaseInStructure {
566     pub s_type: StructureType,
567     pub p_next: *const Self,
568 }
569 impl ::std::default::Default for BaseInStructure {
570     #[inline]
default() -> Self571     fn default() -> Self {
572         Self {
573             s_type: unsafe { ::std::mem::zeroed() },
574             p_next: ::std::ptr::null(),
575         }
576     }
577 }
578 #[repr(C)]
579 #[cfg_attr(feature = "debug", derive(Debug))]
580 #[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
581 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOffset2D.html>"]
582 pub struct Offset2D {
583     pub x: i32,
584     pub y: i32,
585 }
586 impl Offset2D {
builder<'a>() -> Offset2DBuilder<'a>587     pub fn builder<'a>() -> Offset2DBuilder<'a> {
588         Offset2DBuilder {
589             inner: Self::default(),
590             marker: ::std::marker::PhantomData,
591         }
592     }
593 }
594 #[repr(transparent)]
595 pub struct Offset2DBuilder<'a> {
596     inner: Offset2D,
597     marker: ::std::marker::PhantomData<&'a ()>,
598 }
599 impl<'a> ::std::ops::Deref for Offset2DBuilder<'a> {
600     type Target = Offset2D;
deref(&self) -> &Self::Target601     fn deref(&self) -> &Self::Target {
602         &self.inner
603     }
604 }
605 impl<'a> ::std::ops::DerefMut for Offset2DBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target606     fn deref_mut(&mut self) -> &mut Self::Target {
607         &mut self.inner
608     }
609 }
610 impl<'a> Offset2DBuilder<'a> {
611     #[inline]
x(mut self, x: i32) -> Self612     pub fn x(mut self, x: i32) -> Self {
613         self.inner.x = x;
614         self
615     }
616     #[inline]
y(mut self, y: i32) -> Self617     pub fn y(mut self, y: i32) -> Self {
618         self.inner.y = y;
619         self
620     }
621     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
622     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
623     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> Offset2D624     pub fn build(self) -> Offset2D {
625         self.inner
626     }
627 }
628 #[repr(C)]
629 #[cfg_attr(feature = "debug", derive(Debug))]
630 #[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
631 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOffset3D.html>"]
632 pub struct Offset3D {
633     pub x: i32,
634     pub y: i32,
635     pub z: i32,
636 }
637 impl Offset3D {
builder<'a>() -> Offset3DBuilder<'a>638     pub fn builder<'a>() -> Offset3DBuilder<'a> {
639         Offset3DBuilder {
640             inner: Self::default(),
641             marker: ::std::marker::PhantomData,
642         }
643     }
644 }
645 #[repr(transparent)]
646 pub struct Offset3DBuilder<'a> {
647     inner: Offset3D,
648     marker: ::std::marker::PhantomData<&'a ()>,
649 }
650 impl<'a> ::std::ops::Deref for Offset3DBuilder<'a> {
651     type Target = Offset3D;
deref(&self) -> &Self::Target652     fn deref(&self) -> &Self::Target {
653         &self.inner
654     }
655 }
656 impl<'a> ::std::ops::DerefMut for Offset3DBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target657     fn deref_mut(&mut self) -> &mut Self::Target {
658         &mut self.inner
659     }
660 }
661 impl<'a> Offset3DBuilder<'a> {
662     #[inline]
x(mut self, x: i32) -> Self663     pub fn x(mut self, x: i32) -> Self {
664         self.inner.x = x;
665         self
666     }
667     #[inline]
y(mut self, y: i32) -> Self668     pub fn y(mut self, y: i32) -> Self {
669         self.inner.y = y;
670         self
671     }
672     #[inline]
z(mut self, z: i32) -> Self673     pub fn z(mut self, z: i32) -> Self {
674         self.inner.z = z;
675         self
676     }
677     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
678     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
679     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> Offset3D680     pub fn build(self) -> Offset3D {
681         self.inner
682     }
683 }
684 #[repr(C)]
685 #[cfg_attr(feature = "debug", derive(Debug))]
686 #[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
687 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExtent2D.html>"]
688 pub struct Extent2D {
689     pub width: u32,
690     pub height: u32,
691 }
692 impl Extent2D {
builder<'a>() -> Extent2DBuilder<'a>693     pub fn builder<'a>() -> Extent2DBuilder<'a> {
694         Extent2DBuilder {
695             inner: Self::default(),
696             marker: ::std::marker::PhantomData,
697         }
698     }
699 }
700 #[repr(transparent)]
701 pub struct Extent2DBuilder<'a> {
702     inner: Extent2D,
703     marker: ::std::marker::PhantomData<&'a ()>,
704 }
705 impl<'a> ::std::ops::Deref for Extent2DBuilder<'a> {
706     type Target = Extent2D;
deref(&self) -> &Self::Target707     fn deref(&self) -> &Self::Target {
708         &self.inner
709     }
710 }
711 impl<'a> ::std::ops::DerefMut for Extent2DBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target712     fn deref_mut(&mut self) -> &mut Self::Target {
713         &mut self.inner
714     }
715 }
716 impl<'a> Extent2DBuilder<'a> {
717     #[inline]
width(mut self, width: u32) -> Self718     pub fn width(mut self, width: u32) -> Self {
719         self.inner.width = width;
720         self
721     }
722     #[inline]
height(mut self, height: u32) -> Self723     pub fn height(mut self, height: u32) -> Self {
724         self.inner.height = height;
725         self
726     }
727     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
728     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
729     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> Extent2D730     pub fn build(self) -> Extent2D {
731         self.inner
732     }
733 }
734 #[repr(C)]
735 #[cfg_attr(feature = "debug", derive(Debug))]
736 #[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
737 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExtent3D.html>"]
738 pub struct Extent3D {
739     pub width: u32,
740     pub height: u32,
741     pub depth: u32,
742 }
743 impl Extent3D {
builder<'a>() -> Extent3DBuilder<'a>744     pub fn builder<'a>() -> Extent3DBuilder<'a> {
745         Extent3DBuilder {
746             inner: Self::default(),
747             marker: ::std::marker::PhantomData,
748         }
749     }
750 }
751 #[repr(transparent)]
752 pub struct Extent3DBuilder<'a> {
753     inner: Extent3D,
754     marker: ::std::marker::PhantomData<&'a ()>,
755 }
756 impl<'a> ::std::ops::Deref for Extent3DBuilder<'a> {
757     type Target = Extent3D;
deref(&self) -> &Self::Target758     fn deref(&self) -> &Self::Target {
759         &self.inner
760     }
761 }
762 impl<'a> ::std::ops::DerefMut for Extent3DBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target763     fn deref_mut(&mut self) -> &mut Self::Target {
764         &mut self.inner
765     }
766 }
767 impl<'a> Extent3DBuilder<'a> {
768     #[inline]
width(mut self, width: u32) -> Self769     pub fn width(mut self, width: u32) -> Self {
770         self.inner.width = width;
771         self
772     }
773     #[inline]
height(mut self, height: u32) -> Self774     pub fn height(mut self, height: u32) -> Self {
775         self.inner.height = height;
776         self
777     }
778     #[inline]
depth(mut self, depth: u32) -> Self779     pub fn depth(mut self, depth: u32) -> Self {
780         self.inner.depth = depth;
781         self
782     }
783     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
784     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
785     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> Extent3D786     pub fn build(self) -> Extent3D {
787         self.inner
788     }
789 }
790 #[repr(C)]
791 #[cfg_attr(feature = "debug", derive(Debug))]
792 #[derive(Copy, Clone, Default)]
793 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkViewport.html>"]
794 pub struct Viewport {
795     pub x: f32,
796     pub y: f32,
797     pub width: f32,
798     pub height: f32,
799     pub min_depth: f32,
800     pub max_depth: f32,
801 }
802 impl Viewport {
builder<'a>() -> ViewportBuilder<'a>803     pub fn builder<'a>() -> ViewportBuilder<'a> {
804         ViewportBuilder {
805             inner: Self::default(),
806             marker: ::std::marker::PhantomData,
807         }
808     }
809 }
810 #[repr(transparent)]
811 pub struct ViewportBuilder<'a> {
812     inner: Viewport,
813     marker: ::std::marker::PhantomData<&'a ()>,
814 }
815 impl<'a> ::std::ops::Deref for ViewportBuilder<'a> {
816     type Target = Viewport;
deref(&self) -> &Self::Target817     fn deref(&self) -> &Self::Target {
818         &self.inner
819     }
820 }
821 impl<'a> ::std::ops::DerefMut for ViewportBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target822     fn deref_mut(&mut self) -> &mut Self::Target {
823         &mut self.inner
824     }
825 }
826 impl<'a> ViewportBuilder<'a> {
827     #[inline]
x(mut self, x: f32) -> Self828     pub fn x(mut self, x: f32) -> Self {
829         self.inner.x = x;
830         self
831     }
832     #[inline]
y(mut self, y: f32) -> Self833     pub fn y(mut self, y: f32) -> Self {
834         self.inner.y = y;
835         self
836     }
837     #[inline]
width(mut self, width: f32) -> Self838     pub fn width(mut self, width: f32) -> Self {
839         self.inner.width = width;
840         self
841     }
842     #[inline]
height(mut self, height: f32) -> Self843     pub fn height(mut self, height: f32) -> Self {
844         self.inner.height = height;
845         self
846     }
847     #[inline]
min_depth(mut self, min_depth: f32) -> Self848     pub fn min_depth(mut self, min_depth: f32) -> Self {
849         self.inner.min_depth = min_depth;
850         self
851     }
852     #[inline]
max_depth(mut self, max_depth: f32) -> Self853     pub fn max_depth(mut self, max_depth: f32) -> Self {
854         self.inner.max_depth = max_depth;
855         self
856     }
857     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
858     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
859     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> Viewport860     pub fn build(self) -> Viewport {
861         self.inner
862     }
863 }
864 #[repr(C)]
865 #[cfg_attr(feature = "debug", derive(Debug))]
866 #[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
867 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRect2D.html>"]
868 pub struct Rect2D {
869     pub offset: Offset2D,
870     pub extent: Extent2D,
871 }
872 impl Rect2D {
builder<'a>() -> Rect2DBuilder<'a>873     pub fn builder<'a>() -> Rect2DBuilder<'a> {
874         Rect2DBuilder {
875             inner: Self::default(),
876             marker: ::std::marker::PhantomData,
877         }
878     }
879 }
880 #[repr(transparent)]
881 pub struct Rect2DBuilder<'a> {
882     inner: Rect2D,
883     marker: ::std::marker::PhantomData<&'a ()>,
884 }
885 impl<'a> ::std::ops::Deref for Rect2DBuilder<'a> {
886     type Target = Rect2D;
deref(&self) -> &Self::Target887     fn deref(&self) -> &Self::Target {
888         &self.inner
889     }
890 }
891 impl<'a> ::std::ops::DerefMut for Rect2DBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target892     fn deref_mut(&mut self) -> &mut Self::Target {
893         &mut self.inner
894     }
895 }
896 impl<'a> Rect2DBuilder<'a> {
897     #[inline]
offset(mut self, offset: Offset2D) -> Self898     pub fn offset(mut self, offset: Offset2D) -> Self {
899         self.inner.offset = offset;
900         self
901     }
902     #[inline]
extent(mut self, extent: Extent2D) -> Self903     pub fn extent(mut self, extent: Extent2D) -> Self {
904         self.inner.extent = extent;
905         self
906     }
907     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
908     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
909     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> Rect2D910     pub fn build(self) -> Rect2D {
911         self.inner
912     }
913 }
914 #[repr(C)]
915 #[cfg_attr(feature = "debug", derive(Debug))]
916 #[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
917 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkClearRect.html>"]
918 pub struct ClearRect {
919     pub rect: Rect2D,
920     pub base_array_layer: u32,
921     pub layer_count: u32,
922 }
923 impl ClearRect {
builder<'a>() -> ClearRectBuilder<'a>924     pub fn builder<'a>() -> ClearRectBuilder<'a> {
925         ClearRectBuilder {
926             inner: Self::default(),
927             marker: ::std::marker::PhantomData,
928         }
929     }
930 }
931 #[repr(transparent)]
932 pub struct ClearRectBuilder<'a> {
933     inner: ClearRect,
934     marker: ::std::marker::PhantomData<&'a ()>,
935 }
936 impl<'a> ::std::ops::Deref for ClearRectBuilder<'a> {
937     type Target = ClearRect;
deref(&self) -> &Self::Target938     fn deref(&self) -> &Self::Target {
939         &self.inner
940     }
941 }
942 impl<'a> ::std::ops::DerefMut for ClearRectBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target943     fn deref_mut(&mut self) -> &mut Self::Target {
944         &mut self.inner
945     }
946 }
947 impl<'a> ClearRectBuilder<'a> {
948     #[inline]
rect(mut self, rect: Rect2D) -> Self949     pub fn rect(mut self, rect: Rect2D) -> Self {
950         self.inner.rect = rect;
951         self
952     }
953     #[inline]
base_array_layer(mut self, base_array_layer: u32) -> Self954     pub fn base_array_layer(mut self, base_array_layer: u32) -> Self {
955         self.inner.base_array_layer = base_array_layer;
956         self
957     }
958     #[inline]
layer_count(mut self, layer_count: u32) -> Self959     pub fn layer_count(mut self, layer_count: u32) -> Self {
960         self.inner.layer_count = layer_count;
961         self
962     }
963     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
964     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
965     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ClearRect966     pub fn build(self) -> ClearRect {
967         self.inner
968     }
969 }
970 #[repr(C)]
971 #[cfg_attr(feature = "debug", derive(Debug))]
972 #[derive(Copy, Clone, Default)]
973 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkComponentMapping.html>"]
974 pub struct ComponentMapping {
975     pub r: ComponentSwizzle,
976     pub g: ComponentSwizzle,
977     pub b: ComponentSwizzle,
978     pub a: ComponentSwizzle,
979 }
980 impl ComponentMapping {
builder<'a>() -> ComponentMappingBuilder<'a>981     pub fn builder<'a>() -> ComponentMappingBuilder<'a> {
982         ComponentMappingBuilder {
983             inner: Self::default(),
984             marker: ::std::marker::PhantomData,
985         }
986     }
987 }
988 #[repr(transparent)]
989 pub struct ComponentMappingBuilder<'a> {
990     inner: ComponentMapping,
991     marker: ::std::marker::PhantomData<&'a ()>,
992 }
993 impl<'a> ::std::ops::Deref for ComponentMappingBuilder<'a> {
994     type Target = ComponentMapping;
deref(&self) -> &Self::Target995     fn deref(&self) -> &Self::Target {
996         &self.inner
997     }
998 }
999 impl<'a> ::std::ops::DerefMut for ComponentMappingBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target1000     fn deref_mut(&mut self) -> &mut Self::Target {
1001         &mut self.inner
1002     }
1003 }
1004 impl<'a> ComponentMappingBuilder<'a> {
1005     #[inline]
r(mut self, r: ComponentSwizzle) -> Self1006     pub fn r(mut self, r: ComponentSwizzle) -> Self {
1007         self.inner.r = r;
1008         self
1009     }
1010     #[inline]
g(mut self, g: ComponentSwizzle) -> Self1011     pub fn g(mut self, g: ComponentSwizzle) -> Self {
1012         self.inner.g = g;
1013         self
1014     }
1015     #[inline]
b(mut self, b: ComponentSwizzle) -> Self1016     pub fn b(mut self, b: ComponentSwizzle) -> Self {
1017         self.inner.b = b;
1018         self
1019     }
1020     #[inline]
a(mut self, a: ComponentSwizzle) -> Self1021     pub fn a(mut self, a: ComponentSwizzle) -> Self {
1022         self.inner.a = a;
1023         self
1024     }
1025     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1026     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1027     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ComponentMapping1028     pub fn build(self) -> ComponentMapping {
1029         self.inner
1030     }
1031 }
1032 #[repr(C)]
1033 #[derive(Copy, Clone)]
1034 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProperties.html>"]
1035 pub struct PhysicalDeviceProperties {
1036     pub api_version: u32,
1037     pub driver_version: u32,
1038     pub vendor_id: u32,
1039     pub device_id: u32,
1040     pub device_type: PhysicalDeviceType,
1041     pub device_name: [c_char; MAX_PHYSICAL_DEVICE_NAME_SIZE],
1042     pub pipeline_cache_uuid: [u8; UUID_SIZE],
1043     pub limits: PhysicalDeviceLimits,
1044     pub sparse_properties: PhysicalDeviceSparseProperties,
1045 }
1046 #[cfg(feature = "debug")]
1047 impl fmt::Debug for PhysicalDeviceProperties {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result1048     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
1049         fmt.debug_struct("PhysicalDeviceProperties")
1050             .field("api_version", &self.api_version)
1051             .field("driver_version", &self.driver_version)
1052             .field("vendor_id", &self.vendor_id)
1053             .field("device_id", &self.device_id)
1054             .field("device_type", &self.device_type)
1055             .field("device_name", &unsafe {
1056                 ::std::ffi::CStr::from_ptr(self.device_name.as_ptr())
1057             })
1058             .field("pipeline_cache_uuid", &self.pipeline_cache_uuid)
1059             .field("limits", &self.limits)
1060             .field("sparse_properties", &self.sparse_properties)
1061             .finish()
1062     }
1063 }
1064 impl ::std::default::Default for PhysicalDeviceProperties {
1065     #[inline]
default() -> Self1066     fn default() -> Self {
1067         Self {
1068             api_version: u32::default(),
1069             driver_version: u32::default(),
1070             vendor_id: u32::default(),
1071             device_id: u32::default(),
1072             device_type: PhysicalDeviceType::default(),
1073             device_name: unsafe { ::std::mem::zeroed() },
1074             pipeline_cache_uuid: unsafe { ::std::mem::zeroed() },
1075             limits: PhysicalDeviceLimits::default(),
1076             sparse_properties: PhysicalDeviceSparseProperties::default(),
1077         }
1078     }
1079 }
1080 impl PhysicalDeviceProperties {
builder<'a>() -> PhysicalDevicePropertiesBuilder<'a>1081     pub fn builder<'a>() -> PhysicalDevicePropertiesBuilder<'a> {
1082         PhysicalDevicePropertiesBuilder {
1083             inner: Self::default(),
1084             marker: ::std::marker::PhantomData,
1085         }
1086     }
1087 }
1088 #[repr(transparent)]
1089 pub struct PhysicalDevicePropertiesBuilder<'a> {
1090     inner: PhysicalDeviceProperties,
1091     marker: ::std::marker::PhantomData<&'a ()>,
1092 }
1093 impl<'a> ::std::ops::Deref for PhysicalDevicePropertiesBuilder<'a> {
1094     type Target = PhysicalDeviceProperties;
deref(&self) -> &Self::Target1095     fn deref(&self) -> &Self::Target {
1096         &self.inner
1097     }
1098 }
1099 impl<'a> ::std::ops::DerefMut for PhysicalDevicePropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target1100     fn deref_mut(&mut self) -> &mut Self::Target {
1101         &mut self.inner
1102     }
1103 }
1104 impl<'a> PhysicalDevicePropertiesBuilder<'a> {
1105     #[inline]
api_version(mut self, api_version: u32) -> Self1106     pub fn api_version(mut self, api_version: u32) -> Self {
1107         self.inner.api_version = api_version;
1108         self
1109     }
1110     #[inline]
driver_version(mut self, driver_version: u32) -> Self1111     pub fn driver_version(mut self, driver_version: u32) -> Self {
1112         self.inner.driver_version = driver_version;
1113         self
1114     }
1115     #[inline]
vendor_id(mut self, vendor_id: u32) -> Self1116     pub fn vendor_id(mut self, vendor_id: u32) -> Self {
1117         self.inner.vendor_id = vendor_id;
1118         self
1119     }
1120     #[inline]
device_id(mut self, device_id: u32) -> Self1121     pub fn device_id(mut self, device_id: u32) -> Self {
1122         self.inner.device_id = device_id;
1123         self
1124     }
1125     #[inline]
device_type(mut self, device_type: PhysicalDeviceType) -> Self1126     pub fn device_type(mut self, device_type: PhysicalDeviceType) -> Self {
1127         self.inner.device_type = device_type;
1128         self
1129     }
1130     #[inline]
device_name(mut self, device_name: [c_char; MAX_PHYSICAL_DEVICE_NAME_SIZE]) -> Self1131     pub fn device_name(mut self, device_name: [c_char; MAX_PHYSICAL_DEVICE_NAME_SIZE]) -> Self {
1132         self.inner.device_name = device_name;
1133         self
1134     }
1135     #[inline]
pipeline_cache_uuid(mut self, pipeline_cache_uuid: [u8; UUID_SIZE]) -> Self1136     pub fn pipeline_cache_uuid(mut self, pipeline_cache_uuid: [u8; UUID_SIZE]) -> Self {
1137         self.inner.pipeline_cache_uuid = pipeline_cache_uuid;
1138         self
1139     }
1140     #[inline]
limits(mut self, limits: PhysicalDeviceLimits) -> Self1141     pub fn limits(mut self, limits: PhysicalDeviceLimits) -> Self {
1142         self.inner.limits = limits;
1143         self
1144     }
1145     #[inline]
sparse_properties(mut self, sparse_properties: PhysicalDeviceSparseProperties) -> Self1146     pub fn sparse_properties(mut self, sparse_properties: PhysicalDeviceSparseProperties) -> Self {
1147         self.inner.sparse_properties = sparse_properties;
1148         self
1149     }
1150     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1151     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1152     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceProperties1153     pub fn build(self) -> PhysicalDeviceProperties {
1154         self.inner
1155     }
1156 }
1157 #[repr(C)]
1158 #[derive(Copy, Clone)]
1159 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExtensionProperties.html>"]
1160 pub struct ExtensionProperties {
1161     pub extension_name: [c_char; MAX_EXTENSION_NAME_SIZE],
1162     pub spec_version: u32,
1163 }
1164 #[cfg(feature = "debug")]
1165 impl fmt::Debug for ExtensionProperties {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result1166     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
1167         fmt.debug_struct("ExtensionProperties")
1168             .field("extension_name", &unsafe {
1169                 ::std::ffi::CStr::from_ptr(self.extension_name.as_ptr())
1170             })
1171             .field("spec_version", &self.spec_version)
1172             .finish()
1173     }
1174 }
1175 impl ::std::default::Default for ExtensionProperties {
1176     #[inline]
default() -> Self1177     fn default() -> Self {
1178         Self {
1179             extension_name: unsafe { ::std::mem::zeroed() },
1180             spec_version: u32::default(),
1181         }
1182     }
1183 }
1184 impl ExtensionProperties {
builder<'a>() -> ExtensionPropertiesBuilder<'a>1185     pub fn builder<'a>() -> ExtensionPropertiesBuilder<'a> {
1186         ExtensionPropertiesBuilder {
1187             inner: Self::default(),
1188             marker: ::std::marker::PhantomData,
1189         }
1190     }
1191 }
1192 #[repr(transparent)]
1193 pub struct ExtensionPropertiesBuilder<'a> {
1194     inner: ExtensionProperties,
1195     marker: ::std::marker::PhantomData<&'a ()>,
1196 }
1197 impl<'a> ::std::ops::Deref for ExtensionPropertiesBuilder<'a> {
1198     type Target = ExtensionProperties;
deref(&self) -> &Self::Target1199     fn deref(&self) -> &Self::Target {
1200         &self.inner
1201     }
1202 }
1203 impl<'a> ::std::ops::DerefMut for ExtensionPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target1204     fn deref_mut(&mut self) -> &mut Self::Target {
1205         &mut self.inner
1206     }
1207 }
1208 impl<'a> ExtensionPropertiesBuilder<'a> {
1209     #[inline]
extension_name(mut self, extension_name: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self1210     pub fn extension_name(mut self, extension_name: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self {
1211         self.inner.extension_name = extension_name;
1212         self
1213     }
1214     #[inline]
spec_version(mut self, spec_version: u32) -> Self1215     pub fn spec_version(mut self, spec_version: u32) -> Self {
1216         self.inner.spec_version = spec_version;
1217         self
1218     }
1219     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1220     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1221     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExtensionProperties1222     pub fn build(self) -> ExtensionProperties {
1223         self.inner
1224     }
1225 }
1226 #[repr(C)]
1227 #[derive(Copy, Clone)]
1228 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkLayerProperties.html>"]
1229 pub struct LayerProperties {
1230     pub layer_name: [c_char; MAX_EXTENSION_NAME_SIZE],
1231     pub spec_version: u32,
1232     pub implementation_version: u32,
1233     pub description: [c_char; MAX_DESCRIPTION_SIZE],
1234 }
1235 #[cfg(feature = "debug")]
1236 impl fmt::Debug for LayerProperties {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result1237     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
1238         fmt.debug_struct("LayerProperties")
1239             .field("layer_name", &unsafe {
1240                 ::std::ffi::CStr::from_ptr(self.layer_name.as_ptr())
1241             })
1242             .field("spec_version", &self.spec_version)
1243             .field("implementation_version", &self.implementation_version)
1244             .field("description", &unsafe {
1245                 ::std::ffi::CStr::from_ptr(self.description.as_ptr())
1246             })
1247             .finish()
1248     }
1249 }
1250 impl ::std::default::Default for LayerProperties {
1251     #[inline]
default() -> Self1252     fn default() -> Self {
1253         Self {
1254             layer_name: unsafe { ::std::mem::zeroed() },
1255             spec_version: u32::default(),
1256             implementation_version: u32::default(),
1257             description: unsafe { ::std::mem::zeroed() },
1258         }
1259     }
1260 }
1261 impl LayerProperties {
builder<'a>() -> LayerPropertiesBuilder<'a>1262     pub fn builder<'a>() -> LayerPropertiesBuilder<'a> {
1263         LayerPropertiesBuilder {
1264             inner: Self::default(),
1265             marker: ::std::marker::PhantomData,
1266         }
1267     }
1268 }
1269 #[repr(transparent)]
1270 pub struct LayerPropertiesBuilder<'a> {
1271     inner: LayerProperties,
1272     marker: ::std::marker::PhantomData<&'a ()>,
1273 }
1274 impl<'a> ::std::ops::Deref for LayerPropertiesBuilder<'a> {
1275     type Target = LayerProperties;
deref(&self) -> &Self::Target1276     fn deref(&self) -> &Self::Target {
1277         &self.inner
1278     }
1279 }
1280 impl<'a> ::std::ops::DerefMut for LayerPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target1281     fn deref_mut(&mut self) -> &mut Self::Target {
1282         &mut self.inner
1283     }
1284 }
1285 impl<'a> LayerPropertiesBuilder<'a> {
1286     #[inline]
layer_name(mut self, layer_name: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self1287     pub fn layer_name(mut self, layer_name: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self {
1288         self.inner.layer_name = layer_name;
1289         self
1290     }
1291     #[inline]
spec_version(mut self, spec_version: u32) -> Self1292     pub fn spec_version(mut self, spec_version: u32) -> Self {
1293         self.inner.spec_version = spec_version;
1294         self
1295     }
1296     #[inline]
implementation_version(mut self, implementation_version: u32) -> Self1297     pub fn implementation_version(mut self, implementation_version: u32) -> Self {
1298         self.inner.implementation_version = implementation_version;
1299         self
1300     }
1301     #[inline]
description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self1302     pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
1303         self.inner.description = description;
1304         self
1305     }
1306     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1307     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1308     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> LayerProperties1309     pub fn build(self) -> LayerProperties {
1310         self.inner
1311     }
1312 }
1313 #[repr(C)]
1314 #[cfg_attr(feature = "debug", derive(Debug))]
1315 #[derive(Copy, Clone)]
1316 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkApplicationInfo.html>"]
1317 pub struct ApplicationInfo {
1318     pub s_type: StructureType,
1319     pub p_next: *const c_void,
1320     pub p_application_name: *const c_char,
1321     pub application_version: u32,
1322     pub p_engine_name: *const c_char,
1323     pub engine_version: u32,
1324     pub api_version: u32,
1325 }
1326 impl ::std::default::Default for ApplicationInfo {
1327     #[inline]
default() -> Self1328     fn default() -> Self {
1329         Self {
1330             s_type: Self::STRUCTURE_TYPE,
1331             p_next: ::std::ptr::null(),
1332             p_application_name: ::std::ptr::null(),
1333             application_version: u32::default(),
1334             p_engine_name: ::std::ptr::null(),
1335             engine_version: u32::default(),
1336             api_version: u32::default(),
1337         }
1338     }
1339 }
1340 unsafe impl TaggedStructure for ApplicationInfo {
1341     const STRUCTURE_TYPE: StructureType = StructureType::APPLICATION_INFO;
1342 }
1343 impl ApplicationInfo {
builder<'a>() -> ApplicationInfoBuilder<'a>1344     pub fn builder<'a>() -> ApplicationInfoBuilder<'a> {
1345         ApplicationInfoBuilder {
1346             inner: Self::default(),
1347             marker: ::std::marker::PhantomData,
1348         }
1349     }
1350 }
1351 #[repr(transparent)]
1352 pub struct ApplicationInfoBuilder<'a> {
1353     inner: ApplicationInfo,
1354     marker: ::std::marker::PhantomData<&'a ()>,
1355 }
1356 impl<'a> ::std::ops::Deref for ApplicationInfoBuilder<'a> {
1357     type Target = ApplicationInfo;
deref(&self) -> &Self::Target1358     fn deref(&self) -> &Self::Target {
1359         &self.inner
1360     }
1361 }
1362 impl<'a> ::std::ops::DerefMut for ApplicationInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target1363     fn deref_mut(&mut self) -> &mut Self::Target {
1364         &mut self.inner
1365     }
1366 }
1367 impl<'a> ApplicationInfoBuilder<'a> {
1368     #[inline]
application_name(mut self, application_name: &'a ::std::ffi::CStr) -> Self1369     pub fn application_name(mut self, application_name: &'a ::std::ffi::CStr) -> Self {
1370         self.inner.p_application_name = application_name.as_ptr();
1371         self
1372     }
1373     #[inline]
application_version(mut self, application_version: u32) -> Self1374     pub fn application_version(mut self, application_version: u32) -> Self {
1375         self.inner.application_version = application_version;
1376         self
1377     }
1378     #[inline]
engine_name(mut self, engine_name: &'a ::std::ffi::CStr) -> Self1379     pub fn engine_name(mut self, engine_name: &'a ::std::ffi::CStr) -> Self {
1380         self.inner.p_engine_name = engine_name.as_ptr();
1381         self
1382     }
1383     #[inline]
engine_version(mut self, engine_version: u32) -> Self1384     pub fn engine_version(mut self, engine_version: u32) -> Self {
1385         self.inner.engine_version = engine_version;
1386         self
1387     }
1388     #[inline]
api_version(mut self, api_version: u32) -> Self1389     pub fn api_version(mut self, api_version: u32) -> Self {
1390         self.inner.api_version = api_version;
1391         self
1392     }
1393     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1394     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1395     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ApplicationInfo1396     pub fn build(self) -> ApplicationInfo {
1397         self.inner
1398     }
1399 }
1400 #[repr(C)]
1401 #[derive(Copy, Clone)]
1402 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAllocationCallbacks.html>"]
1403 pub struct AllocationCallbacks {
1404     pub p_user_data: *mut c_void,
1405     pub pfn_allocation: PFN_vkAllocationFunction,
1406     pub pfn_reallocation: PFN_vkReallocationFunction,
1407     pub pfn_free: PFN_vkFreeFunction,
1408     pub pfn_internal_allocation: PFN_vkInternalAllocationNotification,
1409     pub pfn_internal_free: PFN_vkInternalFreeNotification,
1410 }
1411 #[cfg(feature = "debug")]
1412 impl fmt::Debug for AllocationCallbacks {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result1413     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
1414         fmt.debug_struct("AllocationCallbacks")
1415             .field("p_user_data", &self.p_user_data)
1416             .field(
1417                 "pfn_allocation",
1418                 &(self.pfn_allocation.map(|x| x as *const ())),
1419             )
1420             .field(
1421                 "pfn_reallocation",
1422                 &(self.pfn_reallocation.map(|x| x as *const ())),
1423             )
1424             .field("pfn_free", &(self.pfn_free.map(|x| x as *const ())))
1425             .field(
1426                 "pfn_internal_allocation",
1427                 &(self.pfn_internal_allocation.map(|x| x as *const ())),
1428             )
1429             .field(
1430                 "pfn_internal_free",
1431                 &(self.pfn_internal_free.map(|x| x as *const ())),
1432             )
1433             .finish()
1434     }
1435 }
1436 impl ::std::default::Default for AllocationCallbacks {
1437     #[inline]
default() -> Self1438     fn default() -> Self {
1439         Self {
1440             p_user_data: ::std::ptr::null_mut(),
1441             pfn_allocation: PFN_vkAllocationFunction::default(),
1442             pfn_reallocation: PFN_vkReallocationFunction::default(),
1443             pfn_free: PFN_vkFreeFunction::default(),
1444             pfn_internal_allocation: PFN_vkInternalAllocationNotification::default(),
1445             pfn_internal_free: PFN_vkInternalFreeNotification::default(),
1446         }
1447     }
1448 }
1449 impl AllocationCallbacks {
builder<'a>() -> AllocationCallbacksBuilder<'a>1450     pub fn builder<'a>() -> AllocationCallbacksBuilder<'a> {
1451         AllocationCallbacksBuilder {
1452             inner: Self::default(),
1453             marker: ::std::marker::PhantomData,
1454         }
1455     }
1456 }
1457 #[repr(transparent)]
1458 pub struct AllocationCallbacksBuilder<'a> {
1459     inner: AllocationCallbacks,
1460     marker: ::std::marker::PhantomData<&'a ()>,
1461 }
1462 impl<'a> ::std::ops::Deref for AllocationCallbacksBuilder<'a> {
1463     type Target = AllocationCallbacks;
deref(&self) -> &Self::Target1464     fn deref(&self) -> &Self::Target {
1465         &self.inner
1466     }
1467 }
1468 impl<'a> ::std::ops::DerefMut for AllocationCallbacksBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target1469     fn deref_mut(&mut self) -> &mut Self::Target {
1470         &mut self.inner
1471     }
1472 }
1473 impl<'a> AllocationCallbacksBuilder<'a> {
1474     #[inline]
user_data(mut self, user_data: *mut c_void) -> Self1475     pub fn user_data(mut self, user_data: *mut c_void) -> Self {
1476         self.inner.p_user_data = user_data;
1477         self
1478     }
1479     #[inline]
pfn_allocation(mut self, pfn_allocation: PFN_vkAllocationFunction) -> Self1480     pub fn pfn_allocation(mut self, pfn_allocation: PFN_vkAllocationFunction) -> Self {
1481         self.inner.pfn_allocation = pfn_allocation;
1482         self
1483     }
1484     #[inline]
pfn_reallocation(mut self, pfn_reallocation: PFN_vkReallocationFunction) -> Self1485     pub fn pfn_reallocation(mut self, pfn_reallocation: PFN_vkReallocationFunction) -> Self {
1486         self.inner.pfn_reallocation = pfn_reallocation;
1487         self
1488     }
1489     #[inline]
pfn_free(mut self, pfn_free: PFN_vkFreeFunction) -> Self1490     pub fn pfn_free(mut self, pfn_free: PFN_vkFreeFunction) -> Self {
1491         self.inner.pfn_free = pfn_free;
1492         self
1493     }
1494     #[inline]
pfn_internal_allocation( mut self, pfn_internal_allocation: PFN_vkInternalAllocationNotification, ) -> Self1495     pub fn pfn_internal_allocation(
1496         mut self,
1497         pfn_internal_allocation: PFN_vkInternalAllocationNotification,
1498     ) -> Self {
1499         self.inner.pfn_internal_allocation = pfn_internal_allocation;
1500         self
1501     }
1502     #[inline]
pfn_internal_free(mut self, pfn_internal_free: PFN_vkInternalFreeNotification) -> Self1503     pub fn pfn_internal_free(mut self, pfn_internal_free: PFN_vkInternalFreeNotification) -> Self {
1504         self.inner.pfn_internal_free = pfn_internal_free;
1505         self
1506     }
1507     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1508     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1509     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AllocationCallbacks1510     pub fn build(self) -> AllocationCallbacks {
1511         self.inner
1512     }
1513 }
1514 #[repr(C)]
1515 #[cfg_attr(feature = "debug", derive(Debug))]
1516 #[derive(Copy, Clone)]
1517 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceQueueCreateInfo.html>"]
1518 pub struct DeviceQueueCreateInfo {
1519     pub s_type: StructureType,
1520     pub p_next: *const c_void,
1521     pub flags: DeviceQueueCreateFlags,
1522     pub queue_family_index: u32,
1523     pub queue_count: u32,
1524     pub p_queue_priorities: *const f32,
1525 }
1526 impl ::std::default::Default for DeviceQueueCreateInfo {
1527     #[inline]
default() -> Self1528     fn default() -> Self {
1529         Self {
1530             s_type: Self::STRUCTURE_TYPE,
1531             p_next: ::std::ptr::null(),
1532             flags: DeviceQueueCreateFlags::default(),
1533             queue_family_index: u32::default(),
1534             queue_count: u32::default(),
1535             p_queue_priorities: ::std::ptr::null(),
1536         }
1537     }
1538 }
1539 unsafe impl TaggedStructure for DeviceQueueCreateInfo {
1540     const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_QUEUE_CREATE_INFO;
1541 }
1542 impl DeviceQueueCreateInfo {
builder<'a>() -> DeviceQueueCreateInfoBuilder<'a>1543     pub fn builder<'a>() -> DeviceQueueCreateInfoBuilder<'a> {
1544         DeviceQueueCreateInfoBuilder {
1545             inner: Self::default(),
1546             marker: ::std::marker::PhantomData,
1547         }
1548     }
1549 }
1550 #[repr(transparent)]
1551 pub struct DeviceQueueCreateInfoBuilder<'a> {
1552     inner: DeviceQueueCreateInfo,
1553     marker: ::std::marker::PhantomData<&'a ()>,
1554 }
1555 pub unsafe trait ExtendsDeviceQueueCreateInfo {}
1556 impl<'a> ::std::ops::Deref for DeviceQueueCreateInfoBuilder<'a> {
1557     type Target = DeviceQueueCreateInfo;
deref(&self) -> &Self::Target1558     fn deref(&self) -> &Self::Target {
1559         &self.inner
1560     }
1561 }
1562 impl<'a> ::std::ops::DerefMut for DeviceQueueCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target1563     fn deref_mut(&mut self) -> &mut Self::Target {
1564         &mut self.inner
1565     }
1566 }
1567 impl<'a> DeviceQueueCreateInfoBuilder<'a> {
1568     #[inline]
flags(mut self, flags: DeviceQueueCreateFlags) -> Self1569     pub fn flags(mut self, flags: DeviceQueueCreateFlags) -> Self {
1570         self.inner.flags = flags;
1571         self
1572     }
1573     #[inline]
queue_family_index(mut self, queue_family_index: u32) -> Self1574     pub fn queue_family_index(mut self, queue_family_index: u32) -> Self {
1575         self.inner.queue_family_index = queue_family_index;
1576         self
1577     }
1578     #[inline]
queue_priorities(mut self, queue_priorities: &'a [f32]) -> Self1579     pub fn queue_priorities(mut self, queue_priorities: &'a [f32]) -> Self {
1580         self.inner.queue_count = queue_priorities.len() as _;
1581         self.inner.p_queue_priorities = queue_priorities.as_ptr();
1582         self
1583     }
1584     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
1585     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
1586     #[doc = r" valid extension structs can be pushed into the chain."]
1587     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
1588     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDeviceQueueCreateInfo>(mut self, next: &'a mut T) -> Self1589     pub fn push_next<T: ExtendsDeviceQueueCreateInfo>(mut self, next: &'a mut T) -> Self {
1590         unsafe {
1591             let next_ptr = <*const T>::cast(next);
1592             let last_next = ptr_chain_iter(next).last().unwrap();
1593             (*last_next).p_next = self.inner.p_next as _;
1594             self.inner.p_next = next_ptr;
1595         }
1596         self
1597     }
1598     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1599     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1600     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceQueueCreateInfo1601     pub fn build(self) -> DeviceQueueCreateInfo {
1602         self.inner
1603     }
1604 }
1605 #[repr(C)]
1606 #[cfg_attr(feature = "debug", derive(Debug))]
1607 #[derive(Copy, Clone)]
1608 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceCreateInfo.html>"]
1609 pub struct DeviceCreateInfo {
1610     pub s_type: StructureType,
1611     pub p_next: *const c_void,
1612     pub flags: DeviceCreateFlags,
1613     pub queue_create_info_count: u32,
1614     pub p_queue_create_infos: *const DeviceQueueCreateInfo,
1615     #[deprecated = "functionality described by this member no longer operates"]
1616     pub enabled_layer_count: u32,
1617     #[deprecated = "functionality described by this member no longer operates"]
1618     pub pp_enabled_layer_names: *const *const c_char,
1619     pub enabled_extension_count: u32,
1620     pub pp_enabled_extension_names: *const *const c_char,
1621     pub p_enabled_features: *const PhysicalDeviceFeatures,
1622 }
1623 impl ::std::default::Default for DeviceCreateInfo {
1624     #[inline]
default() -> Self1625     fn default() -> Self {
1626         #[allow(deprecated)]
1627         Self {
1628             s_type: Self::STRUCTURE_TYPE,
1629             p_next: ::std::ptr::null(),
1630             flags: DeviceCreateFlags::default(),
1631             queue_create_info_count: u32::default(),
1632             p_queue_create_infos: ::std::ptr::null(),
1633             enabled_layer_count: u32::default(),
1634             pp_enabled_layer_names: ::std::ptr::null(),
1635             enabled_extension_count: u32::default(),
1636             pp_enabled_extension_names: ::std::ptr::null(),
1637             p_enabled_features: ::std::ptr::null(),
1638         }
1639     }
1640 }
1641 unsafe impl TaggedStructure for DeviceCreateInfo {
1642     const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_CREATE_INFO;
1643 }
1644 impl DeviceCreateInfo {
builder<'a>() -> DeviceCreateInfoBuilder<'a>1645     pub fn builder<'a>() -> DeviceCreateInfoBuilder<'a> {
1646         DeviceCreateInfoBuilder {
1647             inner: Self::default(),
1648             marker: ::std::marker::PhantomData,
1649         }
1650     }
1651 }
1652 #[repr(transparent)]
1653 pub struct DeviceCreateInfoBuilder<'a> {
1654     inner: DeviceCreateInfo,
1655     marker: ::std::marker::PhantomData<&'a ()>,
1656 }
1657 pub unsafe trait ExtendsDeviceCreateInfo {}
1658 impl<'a> ::std::ops::Deref for DeviceCreateInfoBuilder<'a> {
1659     type Target = DeviceCreateInfo;
deref(&self) -> &Self::Target1660     fn deref(&self) -> &Self::Target {
1661         &self.inner
1662     }
1663 }
1664 impl<'a> ::std::ops::DerefMut for DeviceCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target1665     fn deref_mut(&mut self) -> &mut Self::Target {
1666         &mut self.inner
1667     }
1668 }
1669 impl<'a> DeviceCreateInfoBuilder<'a> {
1670     #[inline]
flags(mut self, flags: DeviceCreateFlags) -> Self1671     pub fn flags(mut self, flags: DeviceCreateFlags) -> Self {
1672         self.inner.flags = flags;
1673         self
1674     }
1675     #[inline]
queue_create_infos(mut self, queue_create_infos: &'a [DeviceQueueCreateInfo]) -> Self1676     pub fn queue_create_infos(mut self, queue_create_infos: &'a [DeviceQueueCreateInfo]) -> Self {
1677         self.inner.queue_create_info_count = queue_create_infos.len() as _;
1678         self.inner.p_queue_create_infos = queue_create_infos.as_ptr();
1679         self
1680     }
1681     #[inline]
1682     #[deprecated = "functionality described by this member no longer operates"]
1683     #[allow(deprecated)]
enabled_layer_names(mut self, enabled_layer_names: &'a [*const c_char]) -> Self1684     pub fn enabled_layer_names(mut self, enabled_layer_names: &'a [*const c_char]) -> Self {
1685         self.inner.enabled_layer_count = enabled_layer_names.len() as _;
1686         self.inner.pp_enabled_layer_names = enabled_layer_names.as_ptr();
1687         self
1688     }
1689     #[inline]
enabled_extension_names(mut self, enabled_extension_names: &'a [*const c_char]) -> Self1690     pub fn enabled_extension_names(mut self, enabled_extension_names: &'a [*const c_char]) -> Self {
1691         self.inner.enabled_extension_count = enabled_extension_names.len() as _;
1692         self.inner.pp_enabled_extension_names = enabled_extension_names.as_ptr();
1693         self
1694     }
1695     #[inline]
enabled_features(mut self, enabled_features: &'a PhysicalDeviceFeatures) -> Self1696     pub fn enabled_features(mut self, enabled_features: &'a PhysicalDeviceFeatures) -> Self {
1697         self.inner.p_enabled_features = enabled_features;
1698         self
1699     }
1700     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
1701     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
1702     #[doc = r" valid extension structs can be pushed into the chain."]
1703     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
1704     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDeviceCreateInfo>(mut self, next: &'a mut T) -> Self1705     pub fn push_next<T: ExtendsDeviceCreateInfo>(mut self, next: &'a mut T) -> Self {
1706         unsafe {
1707             let next_ptr = <*const T>::cast(next);
1708             let last_next = ptr_chain_iter(next).last().unwrap();
1709             (*last_next).p_next = self.inner.p_next as _;
1710             self.inner.p_next = next_ptr;
1711         }
1712         self
1713     }
1714     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1715     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1716     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceCreateInfo1717     pub fn build(self) -> DeviceCreateInfo {
1718         self.inner
1719     }
1720 }
1721 #[repr(C)]
1722 #[cfg_attr(feature = "debug", derive(Debug))]
1723 #[derive(Copy, Clone)]
1724 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkInstanceCreateInfo.html>"]
1725 pub struct InstanceCreateInfo {
1726     pub s_type: StructureType,
1727     pub p_next: *const c_void,
1728     pub flags: InstanceCreateFlags,
1729     pub p_application_info: *const ApplicationInfo,
1730     pub enabled_layer_count: u32,
1731     pub pp_enabled_layer_names: *const *const c_char,
1732     pub enabled_extension_count: u32,
1733     pub pp_enabled_extension_names: *const *const c_char,
1734 }
1735 impl ::std::default::Default for InstanceCreateInfo {
1736     #[inline]
default() -> Self1737     fn default() -> Self {
1738         Self {
1739             s_type: Self::STRUCTURE_TYPE,
1740             p_next: ::std::ptr::null(),
1741             flags: InstanceCreateFlags::default(),
1742             p_application_info: ::std::ptr::null(),
1743             enabled_layer_count: u32::default(),
1744             pp_enabled_layer_names: ::std::ptr::null(),
1745             enabled_extension_count: u32::default(),
1746             pp_enabled_extension_names: ::std::ptr::null(),
1747         }
1748     }
1749 }
1750 unsafe impl TaggedStructure for InstanceCreateInfo {
1751     const STRUCTURE_TYPE: StructureType = StructureType::INSTANCE_CREATE_INFO;
1752 }
1753 impl InstanceCreateInfo {
builder<'a>() -> InstanceCreateInfoBuilder<'a>1754     pub fn builder<'a>() -> InstanceCreateInfoBuilder<'a> {
1755         InstanceCreateInfoBuilder {
1756             inner: Self::default(),
1757             marker: ::std::marker::PhantomData,
1758         }
1759     }
1760 }
1761 #[repr(transparent)]
1762 pub struct InstanceCreateInfoBuilder<'a> {
1763     inner: InstanceCreateInfo,
1764     marker: ::std::marker::PhantomData<&'a ()>,
1765 }
1766 pub unsafe trait ExtendsInstanceCreateInfo {}
1767 impl<'a> ::std::ops::Deref for InstanceCreateInfoBuilder<'a> {
1768     type Target = InstanceCreateInfo;
deref(&self) -> &Self::Target1769     fn deref(&self) -> &Self::Target {
1770         &self.inner
1771     }
1772 }
1773 impl<'a> ::std::ops::DerefMut for InstanceCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target1774     fn deref_mut(&mut self) -> &mut Self::Target {
1775         &mut self.inner
1776     }
1777 }
1778 impl<'a> InstanceCreateInfoBuilder<'a> {
1779     #[inline]
flags(mut self, flags: InstanceCreateFlags) -> Self1780     pub fn flags(mut self, flags: InstanceCreateFlags) -> Self {
1781         self.inner.flags = flags;
1782         self
1783     }
1784     #[inline]
application_info(mut self, application_info: &'a ApplicationInfo) -> Self1785     pub fn application_info(mut self, application_info: &'a ApplicationInfo) -> Self {
1786         self.inner.p_application_info = application_info;
1787         self
1788     }
1789     #[inline]
enabled_layer_names(mut self, enabled_layer_names: &'a [*const c_char]) -> Self1790     pub fn enabled_layer_names(mut self, enabled_layer_names: &'a [*const c_char]) -> Self {
1791         self.inner.enabled_layer_count = enabled_layer_names.len() as _;
1792         self.inner.pp_enabled_layer_names = enabled_layer_names.as_ptr();
1793         self
1794     }
1795     #[inline]
enabled_extension_names(mut self, enabled_extension_names: &'a [*const c_char]) -> Self1796     pub fn enabled_extension_names(mut self, enabled_extension_names: &'a [*const c_char]) -> Self {
1797         self.inner.enabled_extension_count = enabled_extension_names.len() as _;
1798         self.inner.pp_enabled_extension_names = enabled_extension_names.as_ptr();
1799         self
1800     }
1801     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
1802     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
1803     #[doc = r" valid extension structs can be pushed into the chain."]
1804     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
1805     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsInstanceCreateInfo>(mut self, next: &'a mut T) -> Self1806     pub fn push_next<T: ExtendsInstanceCreateInfo>(mut self, next: &'a mut T) -> Self {
1807         unsafe {
1808             let next_ptr = <*const T>::cast(next);
1809             let last_next = ptr_chain_iter(next).last().unwrap();
1810             (*last_next).p_next = self.inner.p_next as _;
1811             self.inner.p_next = next_ptr;
1812         }
1813         self
1814     }
1815     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1816     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1817     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> InstanceCreateInfo1818     pub fn build(self) -> InstanceCreateInfo {
1819         self.inner
1820     }
1821 }
1822 #[repr(C)]
1823 #[cfg_attr(feature = "debug", derive(Debug))]
1824 #[derive(Copy, Clone, Default)]
1825 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyProperties.html>"]
1826 pub struct QueueFamilyProperties {
1827     pub queue_flags: QueueFlags,
1828     pub queue_count: u32,
1829     pub timestamp_valid_bits: u32,
1830     pub min_image_transfer_granularity: Extent3D,
1831 }
1832 impl QueueFamilyProperties {
builder<'a>() -> QueueFamilyPropertiesBuilder<'a>1833     pub fn builder<'a>() -> QueueFamilyPropertiesBuilder<'a> {
1834         QueueFamilyPropertiesBuilder {
1835             inner: Self::default(),
1836             marker: ::std::marker::PhantomData,
1837         }
1838     }
1839 }
1840 #[repr(transparent)]
1841 pub struct QueueFamilyPropertiesBuilder<'a> {
1842     inner: QueueFamilyProperties,
1843     marker: ::std::marker::PhantomData<&'a ()>,
1844 }
1845 impl<'a> ::std::ops::Deref for QueueFamilyPropertiesBuilder<'a> {
1846     type Target = QueueFamilyProperties;
deref(&self) -> &Self::Target1847     fn deref(&self) -> &Self::Target {
1848         &self.inner
1849     }
1850 }
1851 impl<'a> ::std::ops::DerefMut for QueueFamilyPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target1852     fn deref_mut(&mut self) -> &mut Self::Target {
1853         &mut self.inner
1854     }
1855 }
1856 impl<'a> QueueFamilyPropertiesBuilder<'a> {
1857     #[inline]
queue_flags(mut self, queue_flags: QueueFlags) -> Self1858     pub fn queue_flags(mut self, queue_flags: QueueFlags) -> Self {
1859         self.inner.queue_flags = queue_flags;
1860         self
1861     }
1862     #[inline]
queue_count(mut self, queue_count: u32) -> Self1863     pub fn queue_count(mut self, queue_count: u32) -> Self {
1864         self.inner.queue_count = queue_count;
1865         self
1866     }
1867     #[inline]
timestamp_valid_bits(mut self, timestamp_valid_bits: u32) -> Self1868     pub fn timestamp_valid_bits(mut self, timestamp_valid_bits: u32) -> Self {
1869         self.inner.timestamp_valid_bits = timestamp_valid_bits;
1870         self
1871     }
1872     #[inline]
min_image_transfer_granularity( mut self, min_image_transfer_granularity: Extent3D, ) -> Self1873     pub fn min_image_transfer_granularity(
1874         mut self,
1875         min_image_transfer_granularity: Extent3D,
1876     ) -> Self {
1877         self.inner.min_image_transfer_granularity = min_image_transfer_granularity;
1878         self
1879     }
1880     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1881     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1882     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> QueueFamilyProperties1883     pub fn build(self) -> QueueFamilyProperties {
1884         self.inner
1885     }
1886 }
1887 #[repr(C)]
1888 #[cfg_attr(feature = "debug", derive(Debug))]
1889 #[derive(Copy, Clone)]
1890 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMemoryProperties.html>"]
1891 pub struct PhysicalDeviceMemoryProperties {
1892     pub memory_type_count: u32,
1893     pub memory_types: [MemoryType; MAX_MEMORY_TYPES],
1894     pub memory_heap_count: u32,
1895     pub memory_heaps: [MemoryHeap; MAX_MEMORY_HEAPS],
1896 }
1897 impl ::std::default::Default for PhysicalDeviceMemoryProperties {
1898     #[inline]
default() -> Self1899     fn default() -> Self {
1900         Self {
1901             memory_type_count: u32::default(),
1902             memory_types: unsafe { ::std::mem::zeroed() },
1903             memory_heap_count: u32::default(),
1904             memory_heaps: unsafe { ::std::mem::zeroed() },
1905         }
1906     }
1907 }
1908 impl PhysicalDeviceMemoryProperties {
builder<'a>() -> PhysicalDeviceMemoryPropertiesBuilder<'a>1909     pub fn builder<'a>() -> PhysicalDeviceMemoryPropertiesBuilder<'a> {
1910         PhysicalDeviceMemoryPropertiesBuilder {
1911             inner: Self::default(),
1912             marker: ::std::marker::PhantomData,
1913         }
1914     }
1915 }
1916 #[repr(transparent)]
1917 pub struct PhysicalDeviceMemoryPropertiesBuilder<'a> {
1918     inner: PhysicalDeviceMemoryProperties,
1919     marker: ::std::marker::PhantomData<&'a ()>,
1920 }
1921 impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryPropertiesBuilder<'a> {
1922     type Target = PhysicalDeviceMemoryProperties;
deref(&self) -> &Self::Target1923     fn deref(&self) -> &Self::Target {
1924         &self.inner
1925     }
1926 }
1927 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target1928     fn deref_mut(&mut self) -> &mut Self::Target {
1929         &mut self.inner
1930     }
1931 }
1932 impl<'a> PhysicalDeviceMemoryPropertiesBuilder<'a> {
1933     #[inline]
memory_type_count(mut self, memory_type_count: u32) -> Self1934     pub fn memory_type_count(mut self, memory_type_count: u32) -> Self {
1935         self.inner.memory_type_count = memory_type_count;
1936         self
1937     }
1938     #[inline]
memory_types(mut self, memory_types: [MemoryType; MAX_MEMORY_TYPES]) -> Self1939     pub fn memory_types(mut self, memory_types: [MemoryType; MAX_MEMORY_TYPES]) -> Self {
1940         self.inner.memory_types = memory_types;
1941         self
1942     }
1943     #[inline]
memory_heap_count(mut self, memory_heap_count: u32) -> Self1944     pub fn memory_heap_count(mut self, memory_heap_count: u32) -> Self {
1945         self.inner.memory_heap_count = memory_heap_count;
1946         self
1947     }
1948     #[inline]
memory_heaps(mut self, memory_heaps: [MemoryHeap; MAX_MEMORY_HEAPS]) -> Self1949     pub fn memory_heaps(mut self, memory_heaps: [MemoryHeap; MAX_MEMORY_HEAPS]) -> Self {
1950         self.inner.memory_heaps = memory_heaps;
1951         self
1952     }
1953     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1954     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1955     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMemoryProperties1956     pub fn build(self) -> PhysicalDeviceMemoryProperties {
1957         self.inner
1958     }
1959 }
1960 #[repr(C)]
1961 #[cfg_attr(feature = "debug", derive(Debug))]
1962 #[derive(Copy, Clone)]
1963 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryAllocateInfo.html>"]
1964 pub struct MemoryAllocateInfo {
1965     pub s_type: StructureType,
1966     pub p_next: *const c_void,
1967     pub allocation_size: DeviceSize,
1968     pub memory_type_index: u32,
1969 }
1970 impl ::std::default::Default for MemoryAllocateInfo {
1971     #[inline]
default() -> Self1972     fn default() -> Self {
1973         Self {
1974             s_type: Self::STRUCTURE_TYPE,
1975             p_next: ::std::ptr::null(),
1976             allocation_size: DeviceSize::default(),
1977             memory_type_index: u32::default(),
1978         }
1979     }
1980 }
1981 unsafe impl TaggedStructure for MemoryAllocateInfo {
1982     const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_ALLOCATE_INFO;
1983 }
1984 impl MemoryAllocateInfo {
builder<'a>() -> MemoryAllocateInfoBuilder<'a>1985     pub fn builder<'a>() -> MemoryAllocateInfoBuilder<'a> {
1986         MemoryAllocateInfoBuilder {
1987             inner: Self::default(),
1988             marker: ::std::marker::PhantomData,
1989         }
1990     }
1991 }
1992 #[repr(transparent)]
1993 pub struct MemoryAllocateInfoBuilder<'a> {
1994     inner: MemoryAllocateInfo,
1995     marker: ::std::marker::PhantomData<&'a ()>,
1996 }
1997 pub unsafe trait ExtendsMemoryAllocateInfo {}
1998 impl<'a> ::std::ops::Deref for MemoryAllocateInfoBuilder<'a> {
1999     type Target = MemoryAllocateInfo;
deref(&self) -> &Self::Target2000     fn deref(&self) -> &Self::Target {
2001         &self.inner
2002     }
2003 }
2004 impl<'a> ::std::ops::DerefMut for MemoryAllocateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target2005     fn deref_mut(&mut self) -> &mut Self::Target {
2006         &mut self.inner
2007     }
2008 }
2009 impl<'a> MemoryAllocateInfoBuilder<'a> {
2010     #[inline]
allocation_size(mut self, allocation_size: DeviceSize) -> Self2011     pub fn allocation_size(mut self, allocation_size: DeviceSize) -> Self {
2012         self.inner.allocation_size = allocation_size;
2013         self
2014     }
2015     #[inline]
memory_type_index(mut self, memory_type_index: u32) -> Self2016     pub fn memory_type_index(mut self, memory_type_index: u32) -> Self {
2017         self.inner.memory_type_index = memory_type_index;
2018         self
2019     }
2020     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
2021     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
2022     #[doc = r" valid extension structs can be pushed into the chain."]
2023     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
2024     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsMemoryAllocateInfo>(mut self, next: &'a mut T) -> Self2025     pub fn push_next<T: ExtendsMemoryAllocateInfo>(mut self, next: &'a mut T) -> Self {
2026         unsafe {
2027             let next_ptr = <*const T>::cast(next);
2028             let last_next = ptr_chain_iter(next).last().unwrap();
2029             (*last_next).p_next = self.inner.p_next as _;
2030             self.inner.p_next = next_ptr;
2031         }
2032         self
2033     }
2034     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2035     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2036     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryAllocateInfo2037     pub fn build(self) -> MemoryAllocateInfo {
2038         self.inner
2039     }
2040 }
2041 #[repr(C)]
2042 #[cfg_attr(feature = "debug", derive(Debug))]
2043 #[derive(Copy, Clone, Default)]
2044 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryRequirements.html>"]
2045 pub struct MemoryRequirements {
2046     pub size: DeviceSize,
2047     pub alignment: DeviceSize,
2048     pub memory_type_bits: u32,
2049 }
2050 impl MemoryRequirements {
builder<'a>() -> MemoryRequirementsBuilder<'a>2051     pub fn builder<'a>() -> MemoryRequirementsBuilder<'a> {
2052         MemoryRequirementsBuilder {
2053             inner: Self::default(),
2054             marker: ::std::marker::PhantomData,
2055         }
2056     }
2057 }
2058 #[repr(transparent)]
2059 pub struct MemoryRequirementsBuilder<'a> {
2060     inner: MemoryRequirements,
2061     marker: ::std::marker::PhantomData<&'a ()>,
2062 }
2063 impl<'a> ::std::ops::Deref for MemoryRequirementsBuilder<'a> {
2064     type Target = MemoryRequirements;
deref(&self) -> &Self::Target2065     fn deref(&self) -> &Self::Target {
2066         &self.inner
2067     }
2068 }
2069 impl<'a> ::std::ops::DerefMut for MemoryRequirementsBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target2070     fn deref_mut(&mut self) -> &mut Self::Target {
2071         &mut self.inner
2072     }
2073 }
2074 impl<'a> MemoryRequirementsBuilder<'a> {
2075     #[inline]
size(mut self, size: DeviceSize) -> Self2076     pub fn size(mut self, size: DeviceSize) -> Self {
2077         self.inner.size = size;
2078         self
2079     }
2080     #[inline]
alignment(mut self, alignment: DeviceSize) -> Self2081     pub fn alignment(mut self, alignment: DeviceSize) -> Self {
2082         self.inner.alignment = alignment;
2083         self
2084     }
2085     #[inline]
memory_type_bits(mut self, memory_type_bits: u32) -> Self2086     pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self {
2087         self.inner.memory_type_bits = memory_type_bits;
2088         self
2089     }
2090     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2091     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2092     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryRequirements2093     pub fn build(self) -> MemoryRequirements {
2094         self.inner
2095     }
2096 }
2097 #[repr(C)]
2098 #[cfg_attr(feature = "debug", derive(Debug))]
2099 #[derive(Copy, Clone, Default)]
2100 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageFormatProperties.html>"]
2101 pub struct SparseImageFormatProperties {
2102     pub aspect_mask: ImageAspectFlags,
2103     pub image_granularity: Extent3D,
2104     pub flags: SparseImageFormatFlags,
2105 }
2106 impl SparseImageFormatProperties {
builder<'a>() -> SparseImageFormatPropertiesBuilder<'a>2107     pub fn builder<'a>() -> SparseImageFormatPropertiesBuilder<'a> {
2108         SparseImageFormatPropertiesBuilder {
2109             inner: Self::default(),
2110             marker: ::std::marker::PhantomData,
2111         }
2112     }
2113 }
2114 #[repr(transparent)]
2115 pub struct SparseImageFormatPropertiesBuilder<'a> {
2116     inner: SparseImageFormatProperties,
2117     marker: ::std::marker::PhantomData<&'a ()>,
2118 }
2119 impl<'a> ::std::ops::Deref for SparseImageFormatPropertiesBuilder<'a> {
2120     type Target = SparseImageFormatProperties;
deref(&self) -> &Self::Target2121     fn deref(&self) -> &Self::Target {
2122         &self.inner
2123     }
2124 }
2125 impl<'a> ::std::ops::DerefMut for SparseImageFormatPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target2126     fn deref_mut(&mut self) -> &mut Self::Target {
2127         &mut self.inner
2128     }
2129 }
2130 impl<'a> SparseImageFormatPropertiesBuilder<'a> {
2131     #[inline]
aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self2132     pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self {
2133         self.inner.aspect_mask = aspect_mask;
2134         self
2135     }
2136     #[inline]
image_granularity(mut self, image_granularity: Extent3D) -> Self2137     pub fn image_granularity(mut self, image_granularity: Extent3D) -> Self {
2138         self.inner.image_granularity = image_granularity;
2139         self
2140     }
2141     #[inline]
flags(mut self, flags: SparseImageFormatFlags) -> Self2142     pub fn flags(mut self, flags: SparseImageFormatFlags) -> Self {
2143         self.inner.flags = flags;
2144         self
2145     }
2146     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2147     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2148     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SparseImageFormatProperties2149     pub fn build(self) -> SparseImageFormatProperties {
2150         self.inner
2151     }
2152 }
2153 #[repr(C)]
2154 #[cfg_attr(feature = "debug", derive(Debug))]
2155 #[derive(Copy, Clone, Default)]
2156 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageMemoryRequirements.html>"]
2157 pub struct SparseImageMemoryRequirements {
2158     pub format_properties: SparseImageFormatProperties,
2159     pub image_mip_tail_first_lod: u32,
2160     pub image_mip_tail_size: DeviceSize,
2161     pub image_mip_tail_offset: DeviceSize,
2162     pub image_mip_tail_stride: DeviceSize,
2163 }
2164 impl SparseImageMemoryRequirements {
builder<'a>() -> SparseImageMemoryRequirementsBuilder<'a>2165     pub fn builder<'a>() -> SparseImageMemoryRequirementsBuilder<'a> {
2166         SparseImageMemoryRequirementsBuilder {
2167             inner: Self::default(),
2168             marker: ::std::marker::PhantomData,
2169         }
2170     }
2171 }
2172 #[repr(transparent)]
2173 pub struct SparseImageMemoryRequirementsBuilder<'a> {
2174     inner: SparseImageMemoryRequirements,
2175     marker: ::std::marker::PhantomData<&'a ()>,
2176 }
2177 impl<'a> ::std::ops::Deref for SparseImageMemoryRequirementsBuilder<'a> {
2178     type Target = SparseImageMemoryRequirements;
deref(&self) -> &Self::Target2179     fn deref(&self) -> &Self::Target {
2180         &self.inner
2181     }
2182 }
2183 impl<'a> ::std::ops::DerefMut for SparseImageMemoryRequirementsBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target2184     fn deref_mut(&mut self) -> &mut Self::Target {
2185         &mut self.inner
2186     }
2187 }
2188 impl<'a> SparseImageMemoryRequirementsBuilder<'a> {
2189     #[inline]
format_properties(mut self, format_properties: SparseImageFormatProperties) -> Self2190     pub fn format_properties(mut self, format_properties: SparseImageFormatProperties) -> Self {
2191         self.inner.format_properties = format_properties;
2192         self
2193     }
2194     #[inline]
image_mip_tail_first_lod(mut self, image_mip_tail_first_lod: u32) -> Self2195     pub fn image_mip_tail_first_lod(mut self, image_mip_tail_first_lod: u32) -> Self {
2196         self.inner.image_mip_tail_first_lod = image_mip_tail_first_lod;
2197         self
2198     }
2199     #[inline]
image_mip_tail_size(mut self, image_mip_tail_size: DeviceSize) -> Self2200     pub fn image_mip_tail_size(mut self, image_mip_tail_size: DeviceSize) -> Self {
2201         self.inner.image_mip_tail_size = image_mip_tail_size;
2202         self
2203     }
2204     #[inline]
image_mip_tail_offset(mut self, image_mip_tail_offset: DeviceSize) -> Self2205     pub fn image_mip_tail_offset(mut self, image_mip_tail_offset: DeviceSize) -> Self {
2206         self.inner.image_mip_tail_offset = image_mip_tail_offset;
2207         self
2208     }
2209     #[inline]
image_mip_tail_stride(mut self, image_mip_tail_stride: DeviceSize) -> Self2210     pub fn image_mip_tail_stride(mut self, image_mip_tail_stride: DeviceSize) -> Self {
2211         self.inner.image_mip_tail_stride = image_mip_tail_stride;
2212         self
2213     }
2214     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2215     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2216     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SparseImageMemoryRequirements2217     pub fn build(self) -> SparseImageMemoryRequirements {
2218         self.inner
2219     }
2220 }
2221 #[repr(C)]
2222 #[cfg_attr(feature = "debug", derive(Debug))]
2223 #[derive(Copy, Clone, Default)]
2224 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryType.html>"]
2225 pub struct MemoryType {
2226     pub property_flags: MemoryPropertyFlags,
2227     pub heap_index: u32,
2228 }
2229 impl MemoryType {
builder<'a>() -> MemoryTypeBuilder<'a>2230     pub fn builder<'a>() -> MemoryTypeBuilder<'a> {
2231         MemoryTypeBuilder {
2232             inner: Self::default(),
2233             marker: ::std::marker::PhantomData,
2234         }
2235     }
2236 }
2237 #[repr(transparent)]
2238 pub struct MemoryTypeBuilder<'a> {
2239     inner: MemoryType,
2240     marker: ::std::marker::PhantomData<&'a ()>,
2241 }
2242 impl<'a> ::std::ops::Deref for MemoryTypeBuilder<'a> {
2243     type Target = MemoryType;
deref(&self) -> &Self::Target2244     fn deref(&self) -> &Self::Target {
2245         &self.inner
2246     }
2247 }
2248 impl<'a> ::std::ops::DerefMut for MemoryTypeBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target2249     fn deref_mut(&mut self) -> &mut Self::Target {
2250         &mut self.inner
2251     }
2252 }
2253 impl<'a> MemoryTypeBuilder<'a> {
2254     #[inline]
property_flags(mut self, property_flags: MemoryPropertyFlags) -> Self2255     pub fn property_flags(mut self, property_flags: MemoryPropertyFlags) -> Self {
2256         self.inner.property_flags = property_flags;
2257         self
2258     }
2259     #[inline]
heap_index(mut self, heap_index: u32) -> Self2260     pub fn heap_index(mut self, heap_index: u32) -> Self {
2261         self.inner.heap_index = heap_index;
2262         self
2263     }
2264     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2265     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2266     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryType2267     pub fn build(self) -> MemoryType {
2268         self.inner
2269     }
2270 }
2271 #[repr(C)]
2272 #[cfg_attr(feature = "debug", derive(Debug))]
2273 #[derive(Copy, Clone, Default)]
2274 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryHeap.html>"]
2275 pub struct MemoryHeap {
2276     pub size: DeviceSize,
2277     pub flags: MemoryHeapFlags,
2278 }
2279 impl MemoryHeap {
builder<'a>() -> MemoryHeapBuilder<'a>2280     pub fn builder<'a>() -> MemoryHeapBuilder<'a> {
2281         MemoryHeapBuilder {
2282             inner: Self::default(),
2283             marker: ::std::marker::PhantomData,
2284         }
2285     }
2286 }
2287 #[repr(transparent)]
2288 pub struct MemoryHeapBuilder<'a> {
2289     inner: MemoryHeap,
2290     marker: ::std::marker::PhantomData<&'a ()>,
2291 }
2292 impl<'a> ::std::ops::Deref for MemoryHeapBuilder<'a> {
2293     type Target = MemoryHeap;
deref(&self) -> &Self::Target2294     fn deref(&self) -> &Self::Target {
2295         &self.inner
2296     }
2297 }
2298 impl<'a> ::std::ops::DerefMut for MemoryHeapBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target2299     fn deref_mut(&mut self) -> &mut Self::Target {
2300         &mut self.inner
2301     }
2302 }
2303 impl<'a> MemoryHeapBuilder<'a> {
2304     #[inline]
size(mut self, size: DeviceSize) -> Self2305     pub fn size(mut self, size: DeviceSize) -> Self {
2306         self.inner.size = size;
2307         self
2308     }
2309     #[inline]
flags(mut self, flags: MemoryHeapFlags) -> Self2310     pub fn flags(mut self, flags: MemoryHeapFlags) -> Self {
2311         self.inner.flags = flags;
2312         self
2313     }
2314     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2315     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2316     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryHeap2317     pub fn build(self) -> MemoryHeap {
2318         self.inner
2319     }
2320 }
2321 #[repr(C)]
2322 #[cfg_attr(feature = "debug", derive(Debug))]
2323 #[derive(Copy, Clone)]
2324 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMappedMemoryRange.html>"]
2325 pub struct MappedMemoryRange {
2326     pub s_type: StructureType,
2327     pub p_next: *const c_void,
2328     pub memory: DeviceMemory,
2329     pub offset: DeviceSize,
2330     pub size: DeviceSize,
2331 }
2332 impl ::std::default::Default for MappedMemoryRange {
2333     #[inline]
default() -> Self2334     fn default() -> Self {
2335         Self {
2336             s_type: Self::STRUCTURE_TYPE,
2337             p_next: ::std::ptr::null(),
2338             memory: DeviceMemory::default(),
2339             offset: DeviceSize::default(),
2340             size: DeviceSize::default(),
2341         }
2342     }
2343 }
2344 unsafe impl TaggedStructure for MappedMemoryRange {
2345     const STRUCTURE_TYPE: StructureType = StructureType::MAPPED_MEMORY_RANGE;
2346 }
2347 impl MappedMemoryRange {
builder<'a>() -> MappedMemoryRangeBuilder<'a>2348     pub fn builder<'a>() -> MappedMemoryRangeBuilder<'a> {
2349         MappedMemoryRangeBuilder {
2350             inner: Self::default(),
2351             marker: ::std::marker::PhantomData,
2352         }
2353     }
2354 }
2355 #[repr(transparent)]
2356 pub struct MappedMemoryRangeBuilder<'a> {
2357     inner: MappedMemoryRange,
2358     marker: ::std::marker::PhantomData<&'a ()>,
2359 }
2360 impl<'a> ::std::ops::Deref for MappedMemoryRangeBuilder<'a> {
2361     type Target = MappedMemoryRange;
deref(&self) -> &Self::Target2362     fn deref(&self) -> &Self::Target {
2363         &self.inner
2364     }
2365 }
2366 impl<'a> ::std::ops::DerefMut for MappedMemoryRangeBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target2367     fn deref_mut(&mut self) -> &mut Self::Target {
2368         &mut self.inner
2369     }
2370 }
2371 impl<'a> MappedMemoryRangeBuilder<'a> {
2372     #[inline]
memory(mut self, memory: DeviceMemory) -> Self2373     pub fn memory(mut self, memory: DeviceMemory) -> Self {
2374         self.inner.memory = memory;
2375         self
2376     }
2377     #[inline]
offset(mut self, offset: DeviceSize) -> Self2378     pub fn offset(mut self, offset: DeviceSize) -> Self {
2379         self.inner.offset = offset;
2380         self
2381     }
2382     #[inline]
size(mut self, size: DeviceSize) -> Self2383     pub fn size(mut self, size: DeviceSize) -> Self {
2384         self.inner.size = size;
2385         self
2386     }
2387     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2388     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2389     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MappedMemoryRange2390     pub fn build(self) -> MappedMemoryRange {
2391         self.inner
2392     }
2393 }
2394 #[repr(C)]
2395 #[cfg_attr(feature = "debug", derive(Debug))]
2396 #[derive(Copy, Clone, Default)]
2397 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFormatProperties.html>"]
2398 pub struct FormatProperties {
2399     pub linear_tiling_features: FormatFeatureFlags,
2400     pub optimal_tiling_features: FormatFeatureFlags,
2401     pub buffer_features: FormatFeatureFlags,
2402 }
2403 impl FormatProperties {
builder<'a>() -> FormatPropertiesBuilder<'a>2404     pub fn builder<'a>() -> FormatPropertiesBuilder<'a> {
2405         FormatPropertiesBuilder {
2406             inner: Self::default(),
2407             marker: ::std::marker::PhantomData,
2408         }
2409     }
2410 }
2411 #[repr(transparent)]
2412 pub struct FormatPropertiesBuilder<'a> {
2413     inner: FormatProperties,
2414     marker: ::std::marker::PhantomData<&'a ()>,
2415 }
2416 impl<'a> ::std::ops::Deref for FormatPropertiesBuilder<'a> {
2417     type Target = FormatProperties;
deref(&self) -> &Self::Target2418     fn deref(&self) -> &Self::Target {
2419         &self.inner
2420     }
2421 }
2422 impl<'a> ::std::ops::DerefMut for FormatPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target2423     fn deref_mut(&mut self) -> &mut Self::Target {
2424         &mut self.inner
2425     }
2426 }
2427 impl<'a> FormatPropertiesBuilder<'a> {
2428     #[inline]
linear_tiling_features(mut self, linear_tiling_features: FormatFeatureFlags) -> Self2429     pub fn linear_tiling_features(mut self, linear_tiling_features: FormatFeatureFlags) -> Self {
2430         self.inner.linear_tiling_features = linear_tiling_features;
2431         self
2432     }
2433     #[inline]
optimal_tiling_features(mut self, optimal_tiling_features: FormatFeatureFlags) -> Self2434     pub fn optimal_tiling_features(mut self, optimal_tiling_features: FormatFeatureFlags) -> Self {
2435         self.inner.optimal_tiling_features = optimal_tiling_features;
2436         self
2437     }
2438     #[inline]
buffer_features(mut self, buffer_features: FormatFeatureFlags) -> Self2439     pub fn buffer_features(mut self, buffer_features: FormatFeatureFlags) -> Self {
2440         self.inner.buffer_features = buffer_features;
2441         self
2442     }
2443     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2444     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2445     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> FormatProperties2446     pub fn build(self) -> FormatProperties {
2447         self.inner
2448     }
2449 }
2450 #[repr(C)]
2451 #[cfg_attr(feature = "debug", derive(Debug))]
2452 #[derive(Copy, Clone, Default)]
2453 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageFormatProperties.html>"]
2454 pub struct ImageFormatProperties {
2455     pub max_extent: Extent3D,
2456     pub max_mip_levels: u32,
2457     pub max_array_layers: u32,
2458     pub sample_counts: SampleCountFlags,
2459     pub max_resource_size: DeviceSize,
2460 }
2461 impl ImageFormatProperties {
builder<'a>() -> ImageFormatPropertiesBuilder<'a>2462     pub fn builder<'a>() -> ImageFormatPropertiesBuilder<'a> {
2463         ImageFormatPropertiesBuilder {
2464             inner: Self::default(),
2465             marker: ::std::marker::PhantomData,
2466         }
2467     }
2468 }
2469 #[repr(transparent)]
2470 pub struct ImageFormatPropertiesBuilder<'a> {
2471     inner: ImageFormatProperties,
2472     marker: ::std::marker::PhantomData<&'a ()>,
2473 }
2474 impl<'a> ::std::ops::Deref for ImageFormatPropertiesBuilder<'a> {
2475     type Target = ImageFormatProperties;
deref(&self) -> &Self::Target2476     fn deref(&self) -> &Self::Target {
2477         &self.inner
2478     }
2479 }
2480 impl<'a> ::std::ops::DerefMut for ImageFormatPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target2481     fn deref_mut(&mut self) -> &mut Self::Target {
2482         &mut self.inner
2483     }
2484 }
2485 impl<'a> ImageFormatPropertiesBuilder<'a> {
2486     #[inline]
max_extent(mut self, max_extent: Extent3D) -> Self2487     pub fn max_extent(mut self, max_extent: Extent3D) -> Self {
2488         self.inner.max_extent = max_extent;
2489         self
2490     }
2491     #[inline]
max_mip_levels(mut self, max_mip_levels: u32) -> Self2492     pub fn max_mip_levels(mut self, max_mip_levels: u32) -> Self {
2493         self.inner.max_mip_levels = max_mip_levels;
2494         self
2495     }
2496     #[inline]
max_array_layers(mut self, max_array_layers: u32) -> Self2497     pub fn max_array_layers(mut self, max_array_layers: u32) -> Self {
2498         self.inner.max_array_layers = max_array_layers;
2499         self
2500     }
2501     #[inline]
sample_counts(mut self, sample_counts: SampleCountFlags) -> Self2502     pub fn sample_counts(mut self, sample_counts: SampleCountFlags) -> Self {
2503         self.inner.sample_counts = sample_counts;
2504         self
2505     }
2506     #[inline]
max_resource_size(mut self, max_resource_size: DeviceSize) -> Self2507     pub fn max_resource_size(mut self, max_resource_size: DeviceSize) -> Self {
2508         self.inner.max_resource_size = max_resource_size;
2509         self
2510     }
2511     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2512     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2513     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageFormatProperties2514     pub fn build(self) -> ImageFormatProperties {
2515         self.inner
2516     }
2517 }
2518 #[repr(C)]
2519 #[cfg_attr(feature = "debug", derive(Debug))]
2520 #[derive(Copy, Clone, Default)]
2521 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorBufferInfo.html>"]
2522 pub struct DescriptorBufferInfo {
2523     pub buffer: Buffer,
2524     pub offset: DeviceSize,
2525     pub range: DeviceSize,
2526 }
2527 impl DescriptorBufferInfo {
builder<'a>() -> DescriptorBufferInfoBuilder<'a>2528     pub fn builder<'a>() -> DescriptorBufferInfoBuilder<'a> {
2529         DescriptorBufferInfoBuilder {
2530             inner: Self::default(),
2531             marker: ::std::marker::PhantomData,
2532         }
2533     }
2534 }
2535 #[repr(transparent)]
2536 pub struct DescriptorBufferInfoBuilder<'a> {
2537     inner: DescriptorBufferInfo,
2538     marker: ::std::marker::PhantomData<&'a ()>,
2539 }
2540 impl<'a> ::std::ops::Deref for DescriptorBufferInfoBuilder<'a> {
2541     type Target = DescriptorBufferInfo;
deref(&self) -> &Self::Target2542     fn deref(&self) -> &Self::Target {
2543         &self.inner
2544     }
2545 }
2546 impl<'a> ::std::ops::DerefMut for DescriptorBufferInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target2547     fn deref_mut(&mut self) -> &mut Self::Target {
2548         &mut self.inner
2549     }
2550 }
2551 impl<'a> DescriptorBufferInfoBuilder<'a> {
2552     #[inline]
buffer(mut self, buffer: Buffer) -> Self2553     pub fn buffer(mut self, buffer: Buffer) -> Self {
2554         self.inner.buffer = buffer;
2555         self
2556     }
2557     #[inline]
offset(mut self, offset: DeviceSize) -> Self2558     pub fn offset(mut self, offset: DeviceSize) -> Self {
2559         self.inner.offset = offset;
2560         self
2561     }
2562     #[inline]
range(mut self, range: DeviceSize) -> Self2563     pub fn range(mut self, range: DeviceSize) -> Self {
2564         self.inner.range = range;
2565         self
2566     }
2567     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2568     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2569     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorBufferInfo2570     pub fn build(self) -> DescriptorBufferInfo {
2571         self.inner
2572     }
2573 }
2574 #[repr(C)]
2575 #[cfg_attr(feature = "debug", derive(Debug))]
2576 #[derive(Copy, Clone, Default)]
2577 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorImageInfo.html>"]
2578 pub struct DescriptorImageInfo {
2579     pub sampler: Sampler,
2580     pub image_view: ImageView,
2581     pub image_layout: ImageLayout,
2582 }
2583 impl DescriptorImageInfo {
builder<'a>() -> DescriptorImageInfoBuilder<'a>2584     pub fn builder<'a>() -> DescriptorImageInfoBuilder<'a> {
2585         DescriptorImageInfoBuilder {
2586             inner: Self::default(),
2587             marker: ::std::marker::PhantomData,
2588         }
2589     }
2590 }
2591 #[repr(transparent)]
2592 pub struct DescriptorImageInfoBuilder<'a> {
2593     inner: DescriptorImageInfo,
2594     marker: ::std::marker::PhantomData<&'a ()>,
2595 }
2596 impl<'a> ::std::ops::Deref for DescriptorImageInfoBuilder<'a> {
2597     type Target = DescriptorImageInfo;
deref(&self) -> &Self::Target2598     fn deref(&self) -> &Self::Target {
2599         &self.inner
2600     }
2601 }
2602 impl<'a> ::std::ops::DerefMut for DescriptorImageInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target2603     fn deref_mut(&mut self) -> &mut Self::Target {
2604         &mut self.inner
2605     }
2606 }
2607 impl<'a> DescriptorImageInfoBuilder<'a> {
2608     #[inline]
sampler(mut self, sampler: Sampler) -> Self2609     pub fn sampler(mut self, sampler: Sampler) -> Self {
2610         self.inner.sampler = sampler;
2611         self
2612     }
2613     #[inline]
image_view(mut self, image_view: ImageView) -> Self2614     pub fn image_view(mut self, image_view: ImageView) -> Self {
2615         self.inner.image_view = image_view;
2616         self
2617     }
2618     #[inline]
image_layout(mut self, image_layout: ImageLayout) -> Self2619     pub fn image_layout(mut self, image_layout: ImageLayout) -> Self {
2620         self.inner.image_layout = image_layout;
2621         self
2622     }
2623     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2624     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2625     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorImageInfo2626     pub fn build(self) -> DescriptorImageInfo {
2627         self.inner
2628     }
2629 }
2630 #[repr(C)]
2631 #[cfg_attr(feature = "debug", derive(Debug))]
2632 #[derive(Copy, Clone)]
2633 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWriteDescriptorSet.html>"]
2634 pub struct WriteDescriptorSet {
2635     pub s_type: StructureType,
2636     pub p_next: *const c_void,
2637     pub dst_set: DescriptorSet,
2638     pub dst_binding: u32,
2639     pub dst_array_element: u32,
2640     pub descriptor_count: u32,
2641     pub descriptor_type: DescriptorType,
2642     pub p_image_info: *const DescriptorImageInfo,
2643     pub p_buffer_info: *const DescriptorBufferInfo,
2644     pub p_texel_buffer_view: *const BufferView,
2645 }
2646 impl ::std::default::Default for WriteDescriptorSet {
2647     #[inline]
default() -> Self2648     fn default() -> Self {
2649         Self {
2650             s_type: Self::STRUCTURE_TYPE,
2651             p_next: ::std::ptr::null(),
2652             dst_set: DescriptorSet::default(),
2653             dst_binding: u32::default(),
2654             dst_array_element: u32::default(),
2655             descriptor_count: u32::default(),
2656             descriptor_type: DescriptorType::default(),
2657             p_image_info: ::std::ptr::null(),
2658             p_buffer_info: ::std::ptr::null(),
2659             p_texel_buffer_view: ::std::ptr::null(),
2660         }
2661     }
2662 }
2663 unsafe impl TaggedStructure for WriteDescriptorSet {
2664     const STRUCTURE_TYPE: StructureType = StructureType::WRITE_DESCRIPTOR_SET;
2665 }
2666 impl WriteDescriptorSet {
builder<'a>() -> WriteDescriptorSetBuilder<'a>2667     pub fn builder<'a>() -> WriteDescriptorSetBuilder<'a> {
2668         WriteDescriptorSetBuilder {
2669             inner: Self::default(),
2670             marker: ::std::marker::PhantomData,
2671         }
2672     }
2673 }
2674 #[repr(transparent)]
2675 pub struct WriteDescriptorSetBuilder<'a> {
2676     inner: WriteDescriptorSet,
2677     marker: ::std::marker::PhantomData<&'a ()>,
2678 }
2679 pub unsafe trait ExtendsWriteDescriptorSet {}
2680 impl<'a> ::std::ops::Deref for WriteDescriptorSetBuilder<'a> {
2681     type Target = WriteDescriptorSet;
deref(&self) -> &Self::Target2682     fn deref(&self) -> &Self::Target {
2683         &self.inner
2684     }
2685 }
2686 impl<'a> ::std::ops::DerefMut for WriteDescriptorSetBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target2687     fn deref_mut(&mut self) -> &mut Self::Target {
2688         &mut self.inner
2689     }
2690 }
2691 impl<'a> WriteDescriptorSetBuilder<'a> {
2692     #[inline]
dst_set(mut self, dst_set: DescriptorSet) -> Self2693     pub fn dst_set(mut self, dst_set: DescriptorSet) -> Self {
2694         self.inner.dst_set = dst_set;
2695         self
2696     }
2697     #[inline]
dst_binding(mut self, dst_binding: u32) -> Self2698     pub fn dst_binding(mut self, dst_binding: u32) -> Self {
2699         self.inner.dst_binding = dst_binding;
2700         self
2701     }
2702     #[inline]
dst_array_element(mut self, dst_array_element: u32) -> Self2703     pub fn dst_array_element(mut self, dst_array_element: u32) -> Self {
2704         self.inner.dst_array_element = dst_array_element;
2705         self
2706     }
2707     #[inline]
descriptor_type(mut self, descriptor_type: DescriptorType) -> Self2708     pub fn descriptor_type(mut self, descriptor_type: DescriptorType) -> Self {
2709         self.inner.descriptor_type = descriptor_type;
2710         self
2711     }
2712     #[inline]
image_info(mut self, image_info: &'a [DescriptorImageInfo]) -> Self2713     pub fn image_info(mut self, image_info: &'a [DescriptorImageInfo]) -> Self {
2714         self.inner.descriptor_count = image_info.len() as _;
2715         self.inner.p_image_info = image_info.as_ptr();
2716         self
2717     }
2718     #[inline]
buffer_info(mut self, buffer_info: &'a [DescriptorBufferInfo]) -> Self2719     pub fn buffer_info(mut self, buffer_info: &'a [DescriptorBufferInfo]) -> Self {
2720         self.inner.descriptor_count = buffer_info.len() as _;
2721         self.inner.p_buffer_info = buffer_info.as_ptr();
2722         self
2723     }
2724     #[inline]
texel_buffer_view(mut self, texel_buffer_view: &'a [BufferView]) -> Self2725     pub fn texel_buffer_view(mut self, texel_buffer_view: &'a [BufferView]) -> Self {
2726         self.inner.descriptor_count = texel_buffer_view.len() as _;
2727         self.inner.p_texel_buffer_view = texel_buffer_view.as_ptr();
2728         self
2729     }
2730     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
2731     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
2732     #[doc = r" valid extension structs can be pushed into the chain."]
2733     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
2734     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsWriteDescriptorSet>(mut self, next: &'a mut T) -> Self2735     pub fn push_next<T: ExtendsWriteDescriptorSet>(mut self, next: &'a mut T) -> Self {
2736         unsafe {
2737             let next_ptr = <*const T>::cast(next);
2738             let last_next = ptr_chain_iter(next).last().unwrap();
2739             (*last_next).p_next = self.inner.p_next as _;
2740             self.inner.p_next = next_ptr;
2741         }
2742         self
2743     }
2744     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2745     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2746     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> WriteDescriptorSet2747     pub fn build(self) -> WriteDescriptorSet {
2748         self.inner
2749     }
2750 }
2751 #[repr(C)]
2752 #[cfg_attr(feature = "debug", derive(Debug))]
2753 #[derive(Copy, Clone)]
2754 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyDescriptorSet.html>"]
2755 pub struct CopyDescriptorSet {
2756     pub s_type: StructureType,
2757     pub p_next: *const c_void,
2758     pub src_set: DescriptorSet,
2759     pub src_binding: u32,
2760     pub src_array_element: u32,
2761     pub dst_set: DescriptorSet,
2762     pub dst_binding: u32,
2763     pub dst_array_element: u32,
2764     pub descriptor_count: u32,
2765 }
2766 impl ::std::default::Default for CopyDescriptorSet {
2767     #[inline]
default() -> Self2768     fn default() -> Self {
2769         Self {
2770             s_type: Self::STRUCTURE_TYPE,
2771             p_next: ::std::ptr::null(),
2772             src_set: DescriptorSet::default(),
2773             src_binding: u32::default(),
2774             src_array_element: u32::default(),
2775             dst_set: DescriptorSet::default(),
2776             dst_binding: u32::default(),
2777             dst_array_element: u32::default(),
2778             descriptor_count: u32::default(),
2779         }
2780     }
2781 }
2782 unsafe impl TaggedStructure for CopyDescriptorSet {
2783     const STRUCTURE_TYPE: StructureType = StructureType::COPY_DESCRIPTOR_SET;
2784 }
2785 impl CopyDescriptorSet {
builder<'a>() -> CopyDescriptorSetBuilder<'a>2786     pub fn builder<'a>() -> CopyDescriptorSetBuilder<'a> {
2787         CopyDescriptorSetBuilder {
2788             inner: Self::default(),
2789             marker: ::std::marker::PhantomData,
2790         }
2791     }
2792 }
2793 #[repr(transparent)]
2794 pub struct CopyDescriptorSetBuilder<'a> {
2795     inner: CopyDescriptorSet,
2796     marker: ::std::marker::PhantomData<&'a ()>,
2797 }
2798 impl<'a> ::std::ops::Deref for CopyDescriptorSetBuilder<'a> {
2799     type Target = CopyDescriptorSet;
deref(&self) -> &Self::Target2800     fn deref(&self) -> &Self::Target {
2801         &self.inner
2802     }
2803 }
2804 impl<'a> ::std::ops::DerefMut for CopyDescriptorSetBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target2805     fn deref_mut(&mut self) -> &mut Self::Target {
2806         &mut self.inner
2807     }
2808 }
2809 impl<'a> CopyDescriptorSetBuilder<'a> {
2810     #[inline]
src_set(mut self, src_set: DescriptorSet) -> Self2811     pub fn src_set(mut self, src_set: DescriptorSet) -> Self {
2812         self.inner.src_set = src_set;
2813         self
2814     }
2815     #[inline]
src_binding(mut self, src_binding: u32) -> Self2816     pub fn src_binding(mut self, src_binding: u32) -> Self {
2817         self.inner.src_binding = src_binding;
2818         self
2819     }
2820     #[inline]
src_array_element(mut self, src_array_element: u32) -> Self2821     pub fn src_array_element(mut self, src_array_element: u32) -> Self {
2822         self.inner.src_array_element = src_array_element;
2823         self
2824     }
2825     #[inline]
dst_set(mut self, dst_set: DescriptorSet) -> Self2826     pub fn dst_set(mut self, dst_set: DescriptorSet) -> Self {
2827         self.inner.dst_set = dst_set;
2828         self
2829     }
2830     #[inline]
dst_binding(mut self, dst_binding: u32) -> Self2831     pub fn dst_binding(mut self, dst_binding: u32) -> Self {
2832         self.inner.dst_binding = dst_binding;
2833         self
2834     }
2835     #[inline]
dst_array_element(mut self, dst_array_element: u32) -> Self2836     pub fn dst_array_element(mut self, dst_array_element: u32) -> Self {
2837         self.inner.dst_array_element = dst_array_element;
2838         self
2839     }
2840     #[inline]
descriptor_count(mut self, descriptor_count: u32) -> Self2841     pub fn descriptor_count(mut self, descriptor_count: u32) -> Self {
2842         self.inner.descriptor_count = descriptor_count;
2843         self
2844     }
2845     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2846     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2847     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CopyDescriptorSet2848     pub fn build(self) -> CopyDescriptorSet {
2849         self.inner
2850     }
2851 }
2852 #[repr(C)]
2853 #[cfg_attr(feature = "debug", derive(Debug))]
2854 #[derive(Copy, Clone)]
2855 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCreateInfo.html>"]
2856 pub struct BufferCreateInfo {
2857     pub s_type: StructureType,
2858     pub p_next: *const c_void,
2859     pub flags: BufferCreateFlags,
2860     pub size: DeviceSize,
2861     pub usage: BufferUsageFlags,
2862     pub sharing_mode: SharingMode,
2863     pub queue_family_index_count: u32,
2864     pub p_queue_family_indices: *const u32,
2865 }
2866 impl ::std::default::Default for BufferCreateInfo {
2867     #[inline]
default() -> Self2868     fn default() -> Self {
2869         Self {
2870             s_type: Self::STRUCTURE_TYPE,
2871             p_next: ::std::ptr::null(),
2872             flags: BufferCreateFlags::default(),
2873             size: DeviceSize::default(),
2874             usage: BufferUsageFlags::default(),
2875             sharing_mode: SharingMode::default(),
2876             queue_family_index_count: u32::default(),
2877             p_queue_family_indices: ::std::ptr::null(),
2878         }
2879     }
2880 }
2881 unsafe impl TaggedStructure for BufferCreateInfo {
2882     const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_CREATE_INFO;
2883 }
2884 impl BufferCreateInfo {
builder<'a>() -> BufferCreateInfoBuilder<'a>2885     pub fn builder<'a>() -> BufferCreateInfoBuilder<'a> {
2886         BufferCreateInfoBuilder {
2887             inner: Self::default(),
2888             marker: ::std::marker::PhantomData,
2889         }
2890     }
2891 }
2892 #[repr(transparent)]
2893 pub struct BufferCreateInfoBuilder<'a> {
2894     inner: BufferCreateInfo,
2895     marker: ::std::marker::PhantomData<&'a ()>,
2896 }
2897 pub unsafe trait ExtendsBufferCreateInfo {}
2898 impl<'a> ::std::ops::Deref for BufferCreateInfoBuilder<'a> {
2899     type Target = BufferCreateInfo;
deref(&self) -> &Self::Target2900     fn deref(&self) -> &Self::Target {
2901         &self.inner
2902     }
2903 }
2904 impl<'a> ::std::ops::DerefMut for BufferCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target2905     fn deref_mut(&mut self) -> &mut Self::Target {
2906         &mut self.inner
2907     }
2908 }
2909 impl<'a> BufferCreateInfoBuilder<'a> {
2910     #[inline]
flags(mut self, flags: BufferCreateFlags) -> Self2911     pub fn flags(mut self, flags: BufferCreateFlags) -> Self {
2912         self.inner.flags = flags;
2913         self
2914     }
2915     #[inline]
size(mut self, size: DeviceSize) -> Self2916     pub fn size(mut self, size: DeviceSize) -> Self {
2917         self.inner.size = size;
2918         self
2919     }
2920     #[inline]
usage(mut self, usage: BufferUsageFlags) -> Self2921     pub fn usage(mut self, usage: BufferUsageFlags) -> Self {
2922         self.inner.usage = usage;
2923         self
2924     }
2925     #[inline]
sharing_mode(mut self, sharing_mode: SharingMode) -> Self2926     pub fn sharing_mode(mut self, sharing_mode: SharingMode) -> Self {
2927         self.inner.sharing_mode = sharing_mode;
2928         self
2929     }
2930     #[inline]
queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self2931     pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self {
2932         self.inner.queue_family_index_count = queue_family_indices.len() as _;
2933         self.inner.p_queue_family_indices = queue_family_indices.as_ptr();
2934         self
2935     }
2936     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
2937     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
2938     #[doc = r" valid extension structs can be pushed into the chain."]
2939     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
2940     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsBufferCreateInfo>(mut self, next: &'a mut T) -> Self2941     pub fn push_next<T: ExtendsBufferCreateInfo>(mut self, next: &'a mut T) -> Self {
2942         unsafe {
2943             let next_ptr = <*const T>::cast(next);
2944             let last_next = ptr_chain_iter(next).last().unwrap();
2945             (*last_next).p_next = self.inner.p_next as _;
2946             self.inner.p_next = next_ptr;
2947         }
2948         self
2949     }
2950     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2951     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2952     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferCreateInfo2953     pub fn build(self) -> BufferCreateInfo {
2954         self.inner
2955     }
2956 }
2957 #[repr(C)]
2958 #[cfg_attr(feature = "debug", derive(Debug))]
2959 #[derive(Copy, Clone)]
2960 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferViewCreateInfo.html>"]
2961 pub struct BufferViewCreateInfo {
2962     pub s_type: StructureType,
2963     pub p_next: *const c_void,
2964     pub flags: BufferViewCreateFlags,
2965     pub buffer: Buffer,
2966     pub format: Format,
2967     pub offset: DeviceSize,
2968     pub range: DeviceSize,
2969 }
2970 impl ::std::default::Default for BufferViewCreateInfo {
2971     #[inline]
default() -> Self2972     fn default() -> Self {
2973         Self {
2974             s_type: Self::STRUCTURE_TYPE,
2975             p_next: ::std::ptr::null(),
2976             flags: BufferViewCreateFlags::default(),
2977             buffer: Buffer::default(),
2978             format: Format::default(),
2979             offset: DeviceSize::default(),
2980             range: DeviceSize::default(),
2981         }
2982     }
2983 }
2984 unsafe impl TaggedStructure for BufferViewCreateInfo {
2985     const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_VIEW_CREATE_INFO;
2986 }
2987 impl BufferViewCreateInfo {
builder<'a>() -> BufferViewCreateInfoBuilder<'a>2988     pub fn builder<'a>() -> BufferViewCreateInfoBuilder<'a> {
2989         BufferViewCreateInfoBuilder {
2990             inner: Self::default(),
2991             marker: ::std::marker::PhantomData,
2992         }
2993     }
2994 }
2995 #[repr(transparent)]
2996 pub struct BufferViewCreateInfoBuilder<'a> {
2997     inner: BufferViewCreateInfo,
2998     marker: ::std::marker::PhantomData<&'a ()>,
2999 }
3000 pub unsafe trait ExtendsBufferViewCreateInfo {}
3001 impl<'a> ::std::ops::Deref for BufferViewCreateInfoBuilder<'a> {
3002     type Target = BufferViewCreateInfo;
deref(&self) -> &Self::Target3003     fn deref(&self) -> &Self::Target {
3004         &self.inner
3005     }
3006 }
3007 impl<'a> ::std::ops::DerefMut for BufferViewCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target3008     fn deref_mut(&mut self) -> &mut Self::Target {
3009         &mut self.inner
3010     }
3011 }
3012 impl<'a> BufferViewCreateInfoBuilder<'a> {
3013     #[inline]
flags(mut self, flags: BufferViewCreateFlags) -> Self3014     pub fn flags(mut self, flags: BufferViewCreateFlags) -> Self {
3015         self.inner.flags = flags;
3016         self
3017     }
3018     #[inline]
buffer(mut self, buffer: Buffer) -> Self3019     pub fn buffer(mut self, buffer: Buffer) -> Self {
3020         self.inner.buffer = buffer;
3021         self
3022     }
3023     #[inline]
format(mut self, format: Format) -> Self3024     pub fn format(mut self, format: Format) -> Self {
3025         self.inner.format = format;
3026         self
3027     }
3028     #[inline]
offset(mut self, offset: DeviceSize) -> Self3029     pub fn offset(mut self, offset: DeviceSize) -> Self {
3030         self.inner.offset = offset;
3031         self
3032     }
3033     #[inline]
range(mut self, range: DeviceSize) -> Self3034     pub fn range(mut self, range: DeviceSize) -> Self {
3035         self.inner.range = range;
3036         self
3037     }
3038     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
3039     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
3040     #[doc = r" valid extension structs can be pushed into the chain."]
3041     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
3042     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsBufferViewCreateInfo>(mut self, next: &'a mut T) -> Self3043     pub fn push_next<T: ExtendsBufferViewCreateInfo>(mut self, next: &'a mut T) -> Self {
3044         unsafe {
3045             let next_ptr = <*const T>::cast(next);
3046             let last_next = ptr_chain_iter(next).last().unwrap();
3047             (*last_next).p_next = self.inner.p_next as _;
3048             self.inner.p_next = next_ptr;
3049         }
3050         self
3051     }
3052     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3053     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3054     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferViewCreateInfo3055     pub fn build(self) -> BufferViewCreateInfo {
3056         self.inner
3057     }
3058 }
3059 #[repr(C)]
3060 #[cfg_attr(feature = "debug", derive(Debug))]
3061 #[derive(Copy, Clone, Default)]
3062 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSubresource.html>"]
3063 pub struct ImageSubresource {
3064     pub aspect_mask: ImageAspectFlags,
3065     pub mip_level: u32,
3066     pub array_layer: u32,
3067 }
3068 impl ImageSubresource {
builder<'a>() -> ImageSubresourceBuilder<'a>3069     pub fn builder<'a>() -> ImageSubresourceBuilder<'a> {
3070         ImageSubresourceBuilder {
3071             inner: Self::default(),
3072             marker: ::std::marker::PhantomData,
3073         }
3074     }
3075 }
3076 #[repr(transparent)]
3077 pub struct ImageSubresourceBuilder<'a> {
3078     inner: ImageSubresource,
3079     marker: ::std::marker::PhantomData<&'a ()>,
3080 }
3081 impl<'a> ::std::ops::Deref for ImageSubresourceBuilder<'a> {
3082     type Target = ImageSubresource;
deref(&self) -> &Self::Target3083     fn deref(&self) -> &Self::Target {
3084         &self.inner
3085     }
3086 }
3087 impl<'a> ::std::ops::DerefMut for ImageSubresourceBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target3088     fn deref_mut(&mut self) -> &mut Self::Target {
3089         &mut self.inner
3090     }
3091 }
3092 impl<'a> ImageSubresourceBuilder<'a> {
3093     #[inline]
aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self3094     pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self {
3095         self.inner.aspect_mask = aspect_mask;
3096         self
3097     }
3098     #[inline]
mip_level(mut self, mip_level: u32) -> Self3099     pub fn mip_level(mut self, mip_level: u32) -> Self {
3100         self.inner.mip_level = mip_level;
3101         self
3102     }
3103     #[inline]
array_layer(mut self, array_layer: u32) -> Self3104     pub fn array_layer(mut self, array_layer: u32) -> Self {
3105         self.inner.array_layer = array_layer;
3106         self
3107     }
3108     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3109     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3110     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageSubresource3111     pub fn build(self) -> ImageSubresource {
3112         self.inner
3113     }
3114 }
3115 #[repr(C)]
3116 #[cfg_attr(feature = "debug", derive(Debug))]
3117 #[derive(Copy, Clone, Default)]
3118 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSubresourceLayers.html>"]
3119 pub struct ImageSubresourceLayers {
3120     pub aspect_mask: ImageAspectFlags,
3121     pub mip_level: u32,
3122     pub base_array_layer: u32,
3123     pub layer_count: u32,
3124 }
3125 impl ImageSubresourceLayers {
builder<'a>() -> ImageSubresourceLayersBuilder<'a>3126     pub fn builder<'a>() -> ImageSubresourceLayersBuilder<'a> {
3127         ImageSubresourceLayersBuilder {
3128             inner: Self::default(),
3129             marker: ::std::marker::PhantomData,
3130         }
3131     }
3132 }
3133 #[repr(transparent)]
3134 pub struct ImageSubresourceLayersBuilder<'a> {
3135     inner: ImageSubresourceLayers,
3136     marker: ::std::marker::PhantomData<&'a ()>,
3137 }
3138 impl<'a> ::std::ops::Deref for ImageSubresourceLayersBuilder<'a> {
3139     type Target = ImageSubresourceLayers;
deref(&self) -> &Self::Target3140     fn deref(&self) -> &Self::Target {
3141         &self.inner
3142     }
3143 }
3144 impl<'a> ::std::ops::DerefMut for ImageSubresourceLayersBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target3145     fn deref_mut(&mut self) -> &mut Self::Target {
3146         &mut self.inner
3147     }
3148 }
3149 impl<'a> ImageSubresourceLayersBuilder<'a> {
3150     #[inline]
aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self3151     pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self {
3152         self.inner.aspect_mask = aspect_mask;
3153         self
3154     }
3155     #[inline]
mip_level(mut self, mip_level: u32) -> Self3156     pub fn mip_level(mut self, mip_level: u32) -> Self {
3157         self.inner.mip_level = mip_level;
3158         self
3159     }
3160     #[inline]
base_array_layer(mut self, base_array_layer: u32) -> Self3161     pub fn base_array_layer(mut self, base_array_layer: u32) -> Self {
3162         self.inner.base_array_layer = base_array_layer;
3163         self
3164     }
3165     #[inline]
layer_count(mut self, layer_count: u32) -> Self3166     pub fn layer_count(mut self, layer_count: u32) -> Self {
3167         self.inner.layer_count = layer_count;
3168         self
3169     }
3170     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3171     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3172     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageSubresourceLayers3173     pub fn build(self) -> ImageSubresourceLayers {
3174         self.inner
3175     }
3176 }
3177 #[repr(C)]
3178 #[cfg_attr(feature = "debug", derive(Debug))]
3179 #[derive(Copy, Clone, Default)]
3180 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSubresourceRange.html>"]
3181 pub struct ImageSubresourceRange {
3182     pub aspect_mask: ImageAspectFlags,
3183     pub base_mip_level: u32,
3184     pub level_count: u32,
3185     pub base_array_layer: u32,
3186     pub layer_count: u32,
3187 }
3188 impl ImageSubresourceRange {
builder<'a>() -> ImageSubresourceRangeBuilder<'a>3189     pub fn builder<'a>() -> ImageSubresourceRangeBuilder<'a> {
3190         ImageSubresourceRangeBuilder {
3191             inner: Self::default(),
3192             marker: ::std::marker::PhantomData,
3193         }
3194     }
3195 }
3196 #[repr(transparent)]
3197 pub struct ImageSubresourceRangeBuilder<'a> {
3198     inner: ImageSubresourceRange,
3199     marker: ::std::marker::PhantomData<&'a ()>,
3200 }
3201 impl<'a> ::std::ops::Deref for ImageSubresourceRangeBuilder<'a> {
3202     type Target = ImageSubresourceRange;
deref(&self) -> &Self::Target3203     fn deref(&self) -> &Self::Target {
3204         &self.inner
3205     }
3206 }
3207 impl<'a> ::std::ops::DerefMut for ImageSubresourceRangeBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target3208     fn deref_mut(&mut self) -> &mut Self::Target {
3209         &mut self.inner
3210     }
3211 }
3212 impl<'a> ImageSubresourceRangeBuilder<'a> {
3213     #[inline]
aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self3214     pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self {
3215         self.inner.aspect_mask = aspect_mask;
3216         self
3217     }
3218     #[inline]
base_mip_level(mut self, base_mip_level: u32) -> Self3219     pub fn base_mip_level(mut self, base_mip_level: u32) -> Self {
3220         self.inner.base_mip_level = base_mip_level;
3221         self
3222     }
3223     #[inline]
level_count(mut self, level_count: u32) -> Self3224     pub fn level_count(mut self, level_count: u32) -> Self {
3225         self.inner.level_count = level_count;
3226         self
3227     }
3228     #[inline]
base_array_layer(mut self, base_array_layer: u32) -> Self3229     pub fn base_array_layer(mut self, base_array_layer: u32) -> Self {
3230         self.inner.base_array_layer = base_array_layer;
3231         self
3232     }
3233     #[inline]
layer_count(mut self, layer_count: u32) -> Self3234     pub fn layer_count(mut self, layer_count: u32) -> Self {
3235         self.inner.layer_count = layer_count;
3236         self
3237     }
3238     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3239     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3240     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageSubresourceRange3241     pub fn build(self) -> ImageSubresourceRange {
3242         self.inner
3243     }
3244 }
3245 #[repr(C)]
3246 #[cfg_attr(feature = "debug", derive(Debug))]
3247 #[derive(Copy, Clone)]
3248 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryBarrier.html>"]
3249 pub struct MemoryBarrier {
3250     pub s_type: StructureType,
3251     pub p_next: *const c_void,
3252     pub src_access_mask: AccessFlags,
3253     pub dst_access_mask: AccessFlags,
3254 }
3255 impl ::std::default::Default for MemoryBarrier {
3256     #[inline]
default() -> Self3257     fn default() -> Self {
3258         Self {
3259             s_type: Self::STRUCTURE_TYPE,
3260             p_next: ::std::ptr::null(),
3261             src_access_mask: AccessFlags::default(),
3262             dst_access_mask: AccessFlags::default(),
3263         }
3264     }
3265 }
3266 unsafe impl TaggedStructure for MemoryBarrier {
3267     const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_BARRIER;
3268 }
3269 impl MemoryBarrier {
builder<'a>() -> MemoryBarrierBuilder<'a>3270     pub fn builder<'a>() -> MemoryBarrierBuilder<'a> {
3271         MemoryBarrierBuilder {
3272             inner: Self::default(),
3273             marker: ::std::marker::PhantomData,
3274         }
3275     }
3276 }
3277 #[repr(transparent)]
3278 pub struct MemoryBarrierBuilder<'a> {
3279     inner: MemoryBarrier,
3280     marker: ::std::marker::PhantomData<&'a ()>,
3281 }
3282 impl<'a> ::std::ops::Deref for MemoryBarrierBuilder<'a> {
3283     type Target = MemoryBarrier;
deref(&self) -> &Self::Target3284     fn deref(&self) -> &Self::Target {
3285         &self.inner
3286     }
3287 }
3288 impl<'a> ::std::ops::DerefMut for MemoryBarrierBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target3289     fn deref_mut(&mut self) -> &mut Self::Target {
3290         &mut self.inner
3291     }
3292 }
3293 impl<'a> MemoryBarrierBuilder<'a> {
3294     #[inline]
src_access_mask(mut self, src_access_mask: AccessFlags) -> Self3295     pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self {
3296         self.inner.src_access_mask = src_access_mask;
3297         self
3298     }
3299     #[inline]
dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self3300     pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self {
3301         self.inner.dst_access_mask = dst_access_mask;
3302         self
3303     }
3304     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3305     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3306     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryBarrier3307     pub fn build(self) -> MemoryBarrier {
3308         self.inner
3309     }
3310 }
3311 #[repr(C)]
3312 #[cfg_attr(feature = "debug", derive(Debug))]
3313 #[derive(Copy, Clone)]
3314 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferMemoryBarrier.html>"]
3315 pub struct BufferMemoryBarrier {
3316     pub s_type: StructureType,
3317     pub p_next: *const c_void,
3318     pub src_access_mask: AccessFlags,
3319     pub dst_access_mask: AccessFlags,
3320     pub src_queue_family_index: u32,
3321     pub dst_queue_family_index: u32,
3322     pub buffer: Buffer,
3323     pub offset: DeviceSize,
3324     pub size: DeviceSize,
3325 }
3326 impl ::std::default::Default for BufferMemoryBarrier {
3327     #[inline]
default() -> Self3328     fn default() -> Self {
3329         Self {
3330             s_type: Self::STRUCTURE_TYPE,
3331             p_next: ::std::ptr::null(),
3332             src_access_mask: AccessFlags::default(),
3333             dst_access_mask: AccessFlags::default(),
3334             src_queue_family_index: u32::default(),
3335             dst_queue_family_index: u32::default(),
3336             buffer: Buffer::default(),
3337             offset: DeviceSize::default(),
3338             size: DeviceSize::default(),
3339         }
3340     }
3341 }
3342 unsafe impl TaggedStructure for BufferMemoryBarrier {
3343     const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_MEMORY_BARRIER;
3344 }
3345 impl BufferMemoryBarrier {
builder<'a>() -> BufferMemoryBarrierBuilder<'a>3346     pub fn builder<'a>() -> BufferMemoryBarrierBuilder<'a> {
3347         BufferMemoryBarrierBuilder {
3348             inner: Self::default(),
3349             marker: ::std::marker::PhantomData,
3350         }
3351     }
3352 }
3353 #[repr(transparent)]
3354 pub struct BufferMemoryBarrierBuilder<'a> {
3355     inner: BufferMemoryBarrier,
3356     marker: ::std::marker::PhantomData<&'a ()>,
3357 }
3358 impl<'a> ::std::ops::Deref for BufferMemoryBarrierBuilder<'a> {
3359     type Target = BufferMemoryBarrier;
deref(&self) -> &Self::Target3360     fn deref(&self) -> &Self::Target {
3361         &self.inner
3362     }
3363 }
3364 impl<'a> ::std::ops::DerefMut for BufferMemoryBarrierBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target3365     fn deref_mut(&mut self) -> &mut Self::Target {
3366         &mut self.inner
3367     }
3368 }
3369 impl<'a> BufferMemoryBarrierBuilder<'a> {
3370     #[inline]
src_access_mask(mut self, src_access_mask: AccessFlags) -> Self3371     pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self {
3372         self.inner.src_access_mask = src_access_mask;
3373         self
3374     }
3375     #[inline]
dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self3376     pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self {
3377         self.inner.dst_access_mask = dst_access_mask;
3378         self
3379     }
3380     #[inline]
src_queue_family_index(mut self, src_queue_family_index: u32) -> Self3381     pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self {
3382         self.inner.src_queue_family_index = src_queue_family_index;
3383         self
3384     }
3385     #[inline]
dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self3386     pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self {
3387         self.inner.dst_queue_family_index = dst_queue_family_index;
3388         self
3389     }
3390     #[inline]
buffer(mut self, buffer: Buffer) -> Self3391     pub fn buffer(mut self, buffer: Buffer) -> Self {
3392         self.inner.buffer = buffer;
3393         self
3394     }
3395     #[inline]
offset(mut self, offset: DeviceSize) -> Self3396     pub fn offset(mut self, offset: DeviceSize) -> Self {
3397         self.inner.offset = offset;
3398         self
3399     }
3400     #[inline]
size(mut self, size: DeviceSize) -> Self3401     pub fn size(mut self, size: DeviceSize) -> Self {
3402         self.inner.size = size;
3403         self
3404     }
3405     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3406     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3407     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferMemoryBarrier3408     pub fn build(self) -> BufferMemoryBarrier {
3409         self.inner
3410     }
3411 }
3412 #[repr(C)]
3413 #[cfg_attr(feature = "debug", derive(Debug))]
3414 #[derive(Copy, Clone)]
3415 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageMemoryBarrier.html>"]
3416 pub struct ImageMemoryBarrier {
3417     pub s_type: StructureType,
3418     pub p_next: *const c_void,
3419     pub src_access_mask: AccessFlags,
3420     pub dst_access_mask: AccessFlags,
3421     pub old_layout: ImageLayout,
3422     pub new_layout: ImageLayout,
3423     pub src_queue_family_index: u32,
3424     pub dst_queue_family_index: u32,
3425     pub image: Image,
3426     pub subresource_range: ImageSubresourceRange,
3427 }
3428 impl ::std::default::Default for ImageMemoryBarrier {
3429     #[inline]
default() -> Self3430     fn default() -> Self {
3431         Self {
3432             s_type: Self::STRUCTURE_TYPE,
3433             p_next: ::std::ptr::null(),
3434             src_access_mask: AccessFlags::default(),
3435             dst_access_mask: AccessFlags::default(),
3436             old_layout: ImageLayout::default(),
3437             new_layout: ImageLayout::default(),
3438             src_queue_family_index: u32::default(),
3439             dst_queue_family_index: u32::default(),
3440             image: Image::default(),
3441             subresource_range: ImageSubresourceRange::default(),
3442         }
3443     }
3444 }
3445 unsafe impl TaggedStructure for ImageMemoryBarrier {
3446     const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_MEMORY_BARRIER;
3447 }
3448 impl ImageMemoryBarrier {
builder<'a>() -> ImageMemoryBarrierBuilder<'a>3449     pub fn builder<'a>() -> ImageMemoryBarrierBuilder<'a> {
3450         ImageMemoryBarrierBuilder {
3451             inner: Self::default(),
3452             marker: ::std::marker::PhantomData,
3453         }
3454     }
3455 }
3456 #[repr(transparent)]
3457 pub struct ImageMemoryBarrierBuilder<'a> {
3458     inner: ImageMemoryBarrier,
3459     marker: ::std::marker::PhantomData<&'a ()>,
3460 }
3461 pub unsafe trait ExtendsImageMemoryBarrier {}
3462 impl<'a> ::std::ops::Deref for ImageMemoryBarrierBuilder<'a> {
3463     type Target = ImageMemoryBarrier;
deref(&self) -> &Self::Target3464     fn deref(&self) -> &Self::Target {
3465         &self.inner
3466     }
3467 }
3468 impl<'a> ::std::ops::DerefMut for ImageMemoryBarrierBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target3469     fn deref_mut(&mut self) -> &mut Self::Target {
3470         &mut self.inner
3471     }
3472 }
3473 impl<'a> ImageMemoryBarrierBuilder<'a> {
3474     #[inline]
src_access_mask(mut self, src_access_mask: AccessFlags) -> Self3475     pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self {
3476         self.inner.src_access_mask = src_access_mask;
3477         self
3478     }
3479     #[inline]
dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self3480     pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self {
3481         self.inner.dst_access_mask = dst_access_mask;
3482         self
3483     }
3484     #[inline]
old_layout(mut self, old_layout: ImageLayout) -> Self3485     pub fn old_layout(mut self, old_layout: ImageLayout) -> Self {
3486         self.inner.old_layout = old_layout;
3487         self
3488     }
3489     #[inline]
new_layout(mut self, new_layout: ImageLayout) -> Self3490     pub fn new_layout(mut self, new_layout: ImageLayout) -> Self {
3491         self.inner.new_layout = new_layout;
3492         self
3493     }
3494     #[inline]
src_queue_family_index(mut self, src_queue_family_index: u32) -> Self3495     pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self {
3496         self.inner.src_queue_family_index = src_queue_family_index;
3497         self
3498     }
3499     #[inline]
dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self3500     pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self {
3501         self.inner.dst_queue_family_index = dst_queue_family_index;
3502         self
3503     }
3504     #[inline]
image(mut self, image: Image) -> Self3505     pub fn image(mut self, image: Image) -> Self {
3506         self.inner.image = image;
3507         self
3508     }
3509     #[inline]
subresource_range(mut self, subresource_range: ImageSubresourceRange) -> Self3510     pub fn subresource_range(mut self, subresource_range: ImageSubresourceRange) -> Self {
3511         self.inner.subresource_range = subresource_range;
3512         self
3513     }
3514     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
3515     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
3516     #[doc = r" valid extension structs can be pushed into the chain."]
3517     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
3518     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsImageMemoryBarrier>(mut self, next: &'a mut T) -> Self3519     pub fn push_next<T: ExtendsImageMemoryBarrier>(mut self, next: &'a mut T) -> Self {
3520         unsafe {
3521             let next_ptr = <*const T>::cast(next);
3522             let last_next = ptr_chain_iter(next).last().unwrap();
3523             (*last_next).p_next = self.inner.p_next as _;
3524             self.inner.p_next = next_ptr;
3525         }
3526         self
3527     }
3528     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3529     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3530     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageMemoryBarrier3531     pub fn build(self) -> ImageMemoryBarrier {
3532         self.inner
3533     }
3534 }
3535 #[repr(C)]
3536 #[cfg_attr(feature = "debug", derive(Debug))]
3537 #[derive(Copy, Clone)]
3538 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCreateInfo.html>"]
3539 pub struct ImageCreateInfo {
3540     pub s_type: StructureType,
3541     pub p_next: *const c_void,
3542     pub flags: ImageCreateFlags,
3543     pub image_type: ImageType,
3544     pub format: Format,
3545     pub extent: Extent3D,
3546     pub mip_levels: u32,
3547     pub array_layers: u32,
3548     pub samples: SampleCountFlags,
3549     pub tiling: ImageTiling,
3550     pub usage: ImageUsageFlags,
3551     pub sharing_mode: SharingMode,
3552     pub queue_family_index_count: u32,
3553     pub p_queue_family_indices: *const u32,
3554     pub initial_layout: ImageLayout,
3555 }
3556 impl ::std::default::Default for ImageCreateInfo {
3557     #[inline]
default() -> Self3558     fn default() -> Self {
3559         Self {
3560             s_type: Self::STRUCTURE_TYPE,
3561             p_next: ::std::ptr::null(),
3562             flags: ImageCreateFlags::default(),
3563             image_type: ImageType::default(),
3564             format: Format::default(),
3565             extent: Extent3D::default(),
3566             mip_levels: u32::default(),
3567             array_layers: u32::default(),
3568             samples: SampleCountFlags::default(),
3569             tiling: ImageTiling::default(),
3570             usage: ImageUsageFlags::default(),
3571             sharing_mode: SharingMode::default(),
3572             queue_family_index_count: u32::default(),
3573             p_queue_family_indices: ::std::ptr::null(),
3574             initial_layout: ImageLayout::default(),
3575         }
3576     }
3577 }
3578 unsafe impl TaggedStructure for ImageCreateInfo {
3579     const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_CREATE_INFO;
3580 }
3581 impl ImageCreateInfo {
builder<'a>() -> ImageCreateInfoBuilder<'a>3582     pub fn builder<'a>() -> ImageCreateInfoBuilder<'a> {
3583         ImageCreateInfoBuilder {
3584             inner: Self::default(),
3585             marker: ::std::marker::PhantomData,
3586         }
3587     }
3588 }
3589 #[repr(transparent)]
3590 pub struct ImageCreateInfoBuilder<'a> {
3591     inner: ImageCreateInfo,
3592     marker: ::std::marker::PhantomData<&'a ()>,
3593 }
3594 pub unsafe trait ExtendsImageCreateInfo {}
3595 impl<'a> ::std::ops::Deref for ImageCreateInfoBuilder<'a> {
3596     type Target = ImageCreateInfo;
deref(&self) -> &Self::Target3597     fn deref(&self) -> &Self::Target {
3598         &self.inner
3599     }
3600 }
3601 impl<'a> ::std::ops::DerefMut for ImageCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target3602     fn deref_mut(&mut self) -> &mut Self::Target {
3603         &mut self.inner
3604     }
3605 }
3606 impl<'a> ImageCreateInfoBuilder<'a> {
3607     #[inline]
flags(mut self, flags: ImageCreateFlags) -> Self3608     pub fn flags(mut self, flags: ImageCreateFlags) -> Self {
3609         self.inner.flags = flags;
3610         self
3611     }
3612     #[inline]
image_type(mut self, image_type: ImageType) -> Self3613     pub fn image_type(mut self, image_type: ImageType) -> Self {
3614         self.inner.image_type = image_type;
3615         self
3616     }
3617     #[inline]
format(mut self, format: Format) -> Self3618     pub fn format(mut self, format: Format) -> Self {
3619         self.inner.format = format;
3620         self
3621     }
3622     #[inline]
extent(mut self, extent: Extent3D) -> Self3623     pub fn extent(mut self, extent: Extent3D) -> Self {
3624         self.inner.extent = extent;
3625         self
3626     }
3627     #[inline]
mip_levels(mut self, mip_levels: u32) -> Self3628     pub fn mip_levels(mut self, mip_levels: u32) -> Self {
3629         self.inner.mip_levels = mip_levels;
3630         self
3631     }
3632     #[inline]
array_layers(mut self, array_layers: u32) -> Self3633     pub fn array_layers(mut self, array_layers: u32) -> Self {
3634         self.inner.array_layers = array_layers;
3635         self
3636     }
3637     #[inline]
samples(mut self, samples: SampleCountFlags) -> Self3638     pub fn samples(mut self, samples: SampleCountFlags) -> Self {
3639         self.inner.samples = samples;
3640         self
3641     }
3642     #[inline]
tiling(mut self, tiling: ImageTiling) -> Self3643     pub fn tiling(mut self, tiling: ImageTiling) -> Self {
3644         self.inner.tiling = tiling;
3645         self
3646     }
3647     #[inline]
usage(mut self, usage: ImageUsageFlags) -> Self3648     pub fn usage(mut self, usage: ImageUsageFlags) -> Self {
3649         self.inner.usage = usage;
3650         self
3651     }
3652     #[inline]
sharing_mode(mut self, sharing_mode: SharingMode) -> Self3653     pub fn sharing_mode(mut self, sharing_mode: SharingMode) -> Self {
3654         self.inner.sharing_mode = sharing_mode;
3655         self
3656     }
3657     #[inline]
queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self3658     pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self {
3659         self.inner.queue_family_index_count = queue_family_indices.len() as _;
3660         self.inner.p_queue_family_indices = queue_family_indices.as_ptr();
3661         self
3662     }
3663     #[inline]
initial_layout(mut self, initial_layout: ImageLayout) -> Self3664     pub fn initial_layout(mut self, initial_layout: ImageLayout) -> Self {
3665         self.inner.initial_layout = initial_layout;
3666         self
3667     }
3668     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
3669     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
3670     #[doc = r" valid extension structs can be pushed into the chain."]
3671     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
3672     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsImageCreateInfo>(mut self, next: &'a mut T) -> Self3673     pub fn push_next<T: ExtendsImageCreateInfo>(mut self, next: &'a mut T) -> Self {
3674         unsafe {
3675             let next_ptr = <*const T>::cast(next);
3676             let last_next = ptr_chain_iter(next).last().unwrap();
3677             (*last_next).p_next = self.inner.p_next as _;
3678             self.inner.p_next = next_ptr;
3679         }
3680         self
3681     }
3682     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3683     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3684     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageCreateInfo3685     pub fn build(self) -> ImageCreateInfo {
3686         self.inner
3687     }
3688 }
3689 #[repr(C)]
3690 #[cfg_attr(feature = "debug", derive(Debug))]
3691 #[derive(Copy, Clone, Default)]
3692 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubresourceLayout.html>"]
3693 pub struct SubresourceLayout {
3694     pub offset: DeviceSize,
3695     pub size: DeviceSize,
3696     pub row_pitch: DeviceSize,
3697     pub array_pitch: DeviceSize,
3698     pub depth_pitch: DeviceSize,
3699 }
3700 impl SubresourceLayout {
builder<'a>() -> SubresourceLayoutBuilder<'a>3701     pub fn builder<'a>() -> SubresourceLayoutBuilder<'a> {
3702         SubresourceLayoutBuilder {
3703             inner: Self::default(),
3704             marker: ::std::marker::PhantomData,
3705         }
3706     }
3707 }
3708 #[repr(transparent)]
3709 pub struct SubresourceLayoutBuilder<'a> {
3710     inner: SubresourceLayout,
3711     marker: ::std::marker::PhantomData<&'a ()>,
3712 }
3713 impl<'a> ::std::ops::Deref for SubresourceLayoutBuilder<'a> {
3714     type Target = SubresourceLayout;
deref(&self) -> &Self::Target3715     fn deref(&self) -> &Self::Target {
3716         &self.inner
3717     }
3718 }
3719 impl<'a> ::std::ops::DerefMut for SubresourceLayoutBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target3720     fn deref_mut(&mut self) -> &mut Self::Target {
3721         &mut self.inner
3722     }
3723 }
3724 impl<'a> SubresourceLayoutBuilder<'a> {
3725     #[inline]
offset(mut self, offset: DeviceSize) -> Self3726     pub fn offset(mut self, offset: DeviceSize) -> Self {
3727         self.inner.offset = offset;
3728         self
3729     }
3730     #[inline]
size(mut self, size: DeviceSize) -> Self3731     pub fn size(mut self, size: DeviceSize) -> Self {
3732         self.inner.size = size;
3733         self
3734     }
3735     #[inline]
row_pitch(mut self, row_pitch: DeviceSize) -> Self3736     pub fn row_pitch(mut self, row_pitch: DeviceSize) -> Self {
3737         self.inner.row_pitch = row_pitch;
3738         self
3739     }
3740     #[inline]
array_pitch(mut self, array_pitch: DeviceSize) -> Self3741     pub fn array_pitch(mut self, array_pitch: DeviceSize) -> Self {
3742         self.inner.array_pitch = array_pitch;
3743         self
3744     }
3745     #[inline]
depth_pitch(mut self, depth_pitch: DeviceSize) -> Self3746     pub fn depth_pitch(mut self, depth_pitch: DeviceSize) -> Self {
3747         self.inner.depth_pitch = depth_pitch;
3748         self
3749     }
3750     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3751     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3752     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SubresourceLayout3753     pub fn build(self) -> SubresourceLayout {
3754         self.inner
3755     }
3756 }
3757 #[repr(C)]
3758 #[cfg_attr(feature = "debug", derive(Debug))]
3759 #[derive(Copy, Clone)]
3760 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewCreateInfo.html>"]
3761 pub struct ImageViewCreateInfo {
3762     pub s_type: StructureType,
3763     pub p_next: *const c_void,
3764     pub flags: ImageViewCreateFlags,
3765     pub image: Image,
3766     pub view_type: ImageViewType,
3767     pub format: Format,
3768     pub components: ComponentMapping,
3769     pub subresource_range: ImageSubresourceRange,
3770 }
3771 impl ::std::default::Default for ImageViewCreateInfo {
3772     #[inline]
default() -> Self3773     fn default() -> Self {
3774         Self {
3775             s_type: Self::STRUCTURE_TYPE,
3776             p_next: ::std::ptr::null(),
3777             flags: ImageViewCreateFlags::default(),
3778             image: Image::default(),
3779             view_type: ImageViewType::default(),
3780             format: Format::default(),
3781             components: ComponentMapping::default(),
3782             subresource_range: ImageSubresourceRange::default(),
3783         }
3784     }
3785 }
3786 unsafe impl TaggedStructure for ImageViewCreateInfo {
3787     const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_CREATE_INFO;
3788 }
3789 impl ImageViewCreateInfo {
builder<'a>() -> ImageViewCreateInfoBuilder<'a>3790     pub fn builder<'a>() -> ImageViewCreateInfoBuilder<'a> {
3791         ImageViewCreateInfoBuilder {
3792             inner: Self::default(),
3793             marker: ::std::marker::PhantomData,
3794         }
3795     }
3796 }
3797 #[repr(transparent)]
3798 pub struct ImageViewCreateInfoBuilder<'a> {
3799     inner: ImageViewCreateInfo,
3800     marker: ::std::marker::PhantomData<&'a ()>,
3801 }
3802 pub unsafe trait ExtendsImageViewCreateInfo {}
3803 impl<'a> ::std::ops::Deref for ImageViewCreateInfoBuilder<'a> {
3804     type Target = ImageViewCreateInfo;
deref(&self) -> &Self::Target3805     fn deref(&self) -> &Self::Target {
3806         &self.inner
3807     }
3808 }
3809 impl<'a> ::std::ops::DerefMut for ImageViewCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target3810     fn deref_mut(&mut self) -> &mut Self::Target {
3811         &mut self.inner
3812     }
3813 }
3814 impl<'a> ImageViewCreateInfoBuilder<'a> {
3815     #[inline]
flags(mut self, flags: ImageViewCreateFlags) -> Self3816     pub fn flags(mut self, flags: ImageViewCreateFlags) -> Self {
3817         self.inner.flags = flags;
3818         self
3819     }
3820     #[inline]
image(mut self, image: Image) -> Self3821     pub fn image(mut self, image: Image) -> Self {
3822         self.inner.image = image;
3823         self
3824     }
3825     #[inline]
view_type(mut self, view_type: ImageViewType) -> Self3826     pub fn view_type(mut self, view_type: ImageViewType) -> Self {
3827         self.inner.view_type = view_type;
3828         self
3829     }
3830     #[inline]
format(mut self, format: Format) -> Self3831     pub fn format(mut self, format: Format) -> Self {
3832         self.inner.format = format;
3833         self
3834     }
3835     #[inline]
components(mut self, components: ComponentMapping) -> Self3836     pub fn components(mut self, components: ComponentMapping) -> Self {
3837         self.inner.components = components;
3838         self
3839     }
3840     #[inline]
subresource_range(mut self, subresource_range: ImageSubresourceRange) -> Self3841     pub fn subresource_range(mut self, subresource_range: ImageSubresourceRange) -> Self {
3842         self.inner.subresource_range = subresource_range;
3843         self
3844     }
3845     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
3846     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
3847     #[doc = r" valid extension structs can be pushed into the chain."]
3848     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
3849     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsImageViewCreateInfo>(mut self, next: &'a mut T) -> Self3850     pub fn push_next<T: ExtendsImageViewCreateInfo>(mut self, next: &'a mut T) -> Self {
3851         unsafe {
3852             let next_ptr = <*const T>::cast(next);
3853             let last_next = ptr_chain_iter(next).last().unwrap();
3854             (*last_next).p_next = self.inner.p_next as _;
3855             self.inner.p_next = next_ptr;
3856         }
3857         self
3858     }
3859     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3860     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3861     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageViewCreateInfo3862     pub fn build(self) -> ImageViewCreateInfo {
3863         self.inner
3864     }
3865 }
3866 #[repr(C)]
3867 #[cfg_attr(feature = "debug", derive(Debug))]
3868 #[derive(Copy, Clone, Default)]
3869 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCopy.html>"]
3870 pub struct BufferCopy {
3871     pub src_offset: DeviceSize,
3872     pub dst_offset: DeviceSize,
3873     pub size: DeviceSize,
3874 }
3875 impl BufferCopy {
builder<'a>() -> BufferCopyBuilder<'a>3876     pub fn builder<'a>() -> BufferCopyBuilder<'a> {
3877         BufferCopyBuilder {
3878             inner: Self::default(),
3879             marker: ::std::marker::PhantomData,
3880         }
3881     }
3882 }
3883 #[repr(transparent)]
3884 pub struct BufferCopyBuilder<'a> {
3885     inner: BufferCopy,
3886     marker: ::std::marker::PhantomData<&'a ()>,
3887 }
3888 impl<'a> ::std::ops::Deref for BufferCopyBuilder<'a> {
3889     type Target = BufferCopy;
deref(&self) -> &Self::Target3890     fn deref(&self) -> &Self::Target {
3891         &self.inner
3892     }
3893 }
3894 impl<'a> ::std::ops::DerefMut for BufferCopyBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target3895     fn deref_mut(&mut self) -> &mut Self::Target {
3896         &mut self.inner
3897     }
3898 }
3899 impl<'a> BufferCopyBuilder<'a> {
3900     #[inline]
src_offset(mut self, src_offset: DeviceSize) -> Self3901     pub fn src_offset(mut self, src_offset: DeviceSize) -> Self {
3902         self.inner.src_offset = src_offset;
3903         self
3904     }
3905     #[inline]
dst_offset(mut self, dst_offset: DeviceSize) -> Self3906     pub fn dst_offset(mut self, dst_offset: DeviceSize) -> Self {
3907         self.inner.dst_offset = dst_offset;
3908         self
3909     }
3910     #[inline]
size(mut self, size: DeviceSize) -> Self3911     pub fn size(mut self, size: DeviceSize) -> Self {
3912         self.inner.size = size;
3913         self
3914     }
3915     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3916     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3917     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferCopy3918     pub fn build(self) -> BufferCopy {
3919         self.inner
3920     }
3921 }
3922 #[repr(C)]
3923 #[cfg_attr(feature = "debug", derive(Debug))]
3924 #[derive(Copy, Clone, Default)]
3925 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseMemoryBind.html>"]
3926 pub struct SparseMemoryBind {
3927     pub resource_offset: DeviceSize,
3928     pub size: DeviceSize,
3929     pub memory: DeviceMemory,
3930     pub memory_offset: DeviceSize,
3931     pub flags: SparseMemoryBindFlags,
3932 }
3933 impl SparseMemoryBind {
builder<'a>() -> SparseMemoryBindBuilder<'a>3934     pub fn builder<'a>() -> SparseMemoryBindBuilder<'a> {
3935         SparseMemoryBindBuilder {
3936             inner: Self::default(),
3937             marker: ::std::marker::PhantomData,
3938         }
3939     }
3940 }
3941 #[repr(transparent)]
3942 pub struct SparseMemoryBindBuilder<'a> {
3943     inner: SparseMemoryBind,
3944     marker: ::std::marker::PhantomData<&'a ()>,
3945 }
3946 impl<'a> ::std::ops::Deref for SparseMemoryBindBuilder<'a> {
3947     type Target = SparseMemoryBind;
deref(&self) -> &Self::Target3948     fn deref(&self) -> &Self::Target {
3949         &self.inner
3950     }
3951 }
3952 impl<'a> ::std::ops::DerefMut for SparseMemoryBindBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target3953     fn deref_mut(&mut self) -> &mut Self::Target {
3954         &mut self.inner
3955     }
3956 }
3957 impl<'a> SparseMemoryBindBuilder<'a> {
3958     #[inline]
resource_offset(mut self, resource_offset: DeviceSize) -> Self3959     pub fn resource_offset(mut self, resource_offset: DeviceSize) -> Self {
3960         self.inner.resource_offset = resource_offset;
3961         self
3962     }
3963     #[inline]
size(mut self, size: DeviceSize) -> Self3964     pub fn size(mut self, size: DeviceSize) -> Self {
3965         self.inner.size = size;
3966         self
3967     }
3968     #[inline]
memory(mut self, memory: DeviceMemory) -> Self3969     pub fn memory(mut self, memory: DeviceMemory) -> Self {
3970         self.inner.memory = memory;
3971         self
3972     }
3973     #[inline]
memory_offset(mut self, memory_offset: DeviceSize) -> Self3974     pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self {
3975         self.inner.memory_offset = memory_offset;
3976         self
3977     }
3978     #[inline]
flags(mut self, flags: SparseMemoryBindFlags) -> Self3979     pub fn flags(mut self, flags: SparseMemoryBindFlags) -> Self {
3980         self.inner.flags = flags;
3981         self
3982     }
3983     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3984     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3985     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SparseMemoryBind3986     pub fn build(self) -> SparseMemoryBind {
3987         self.inner
3988     }
3989 }
3990 #[repr(C)]
3991 #[cfg_attr(feature = "debug", derive(Debug))]
3992 #[derive(Copy, Clone, Default)]
3993 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageMemoryBind.html>"]
3994 pub struct SparseImageMemoryBind {
3995     pub subresource: ImageSubresource,
3996     pub offset: Offset3D,
3997     pub extent: Extent3D,
3998     pub memory: DeviceMemory,
3999     pub memory_offset: DeviceSize,
4000     pub flags: SparseMemoryBindFlags,
4001 }
4002 impl SparseImageMemoryBind {
builder<'a>() -> SparseImageMemoryBindBuilder<'a>4003     pub fn builder<'a>() -> SparseImageMemoryBindBuilder<'a> {
4004         SparseImageMemoryBindBuilder {
4005             inner: Self::default(),
4006             marker: ::std::marker::PhantomData,
4007         }
4008     }
4009 }
4010 #[repr(transparent)]
4011 pub struct SparseImageMemoryBindBuilder<'a> {
4012     inner: SparseImageMemoryBind,
4013     marker: ::std::marker::PhantomData<&'a ()>,
4014 }
4015 impl<'a> ::std::ops::Deref for SparseImageMemoryBindBuilder<'a> {
4016     type Target = SparseImageMemoryBind;
deref(&self) -> &Self::Target4017     fn deref(&self) -> &Self::Target {
4018         &self.inner
4019     }
4020 }
4021 impl<'a> ::std::ops::DerefMut for SparseImageMemoryBindBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target4022     fn deref_mut(&mut self) -> &mut Self::Target {
4023         &mut self.inner
4024     }
4025 }
4026 impl<'a> SparseImageMemoryBindBuilder<'a> {
4027     #[inline]
subresource(mut self, subresource: ImageSubresource) -> Self4028     pub fn subresource(mut self, subresource: ImageSubresource) -> Self {
4029         self.inner.subresource = subresource;
4030         self
4031     }
4032     #[inline]
offset(mut self, offset: Offset3D) -> Self4033     pub fn offset(mut self, offset: Offset3D) -> Self {
4034         self.inner.offset = offset;
4035         self
4036     }
4037     #[inline]
extent(mut self, extent: Extent3D) -> Self4038     pub fn extent(mut self, extent: Extent3D) -> Self {
4039         self.inner.extent = extent;
4040         self
4041     }
4042     #[inline]
memory(mut self, memory: DeviceMemory) -> Self4043     pub fn memory(mut self, memory: DeviceMemory) -> Self {
4044         self.inner.memory = memory;
4045         self
4046     }
4047     #[inline]
memory_offset(mut self, memory_offset: DeviceSize) -> Self4048     pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self {
4049         self.inner.memory_offset = memory_offset;
4050         self
4051     }
4052     #[inline]
flags(mut self, flags: SparseMemoryBindFlags) -> Self4053     pub fn flags(mut self, flags: SparseMemoryBindFlags) -> Self {
4054         self.inner.flags = flags;
4055         self
4056     }
4057     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4058     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4059     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SparseImageMemoryBind4060     pub fn build(self) -> SparseImageMemoryBind {
4061         self.inner
4062     }
4063 }
4064 #[repr(C)]
4065 #[cfg_attr(feature = "debug", derive(Debug))]
4066 #[derive(Copy, Clone)]
4067 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseBufferMemoryBindInfo.html>"]
4068 pub struct SparseBufferMemoryBindInfo {
4069     pub buffer: Buffer,
4070     pub bind_count: u32,
4071     pub p_binds: *const SparseMemoryBind,
4072 }
4073 impl ::std::default::Default for SparseBufferMemoryBindInfo {
4074     #[inline]
default() -> Self4075     fn default() -> Self {
4076         Self {
4077             buffer: Buffer::default(),
4078             bind_count: u32::default(),
4079             p_binds: ::std::ptr::null(),
4080         }
4081     }
4082 }
4083 impl SparseBufferMemoryBindInfo {
builder<'a>() -> SparseBufferMemoryBindInfoBuilder<'a>4084     pub fn builder<'a>() -> SparseBufferMemoryBindInfoBuilder<'a> {
4085         SparseBufferMemoryBindInfoBuilder {
4086             inner: Self::default(),
4087             marker: ::std::marker::PhantomData,
4088         }
4089     }
4090 }
4091 #[repr(transparent)]
4092 pub struct SparseBufferMemoryBindInfoBuilder<'a> {
4093     inner: SparseBufferMemoryBindInfo,
4094     marker: ::std::marker::PhantomData<&'a ()>,
4095 }
4096 impl<'a> ::std::ops::Deref for SparseBufferMemoryBindInfoBuilder<'a> {
4097     type Target = SparseBufferMemoryBindInfo;
deref(&self) -> &Self::Target4098     fn deref(&self) -> &Self::Target {
4099         &self.inner
4100     }
4101 }
4102 impl<'a> ::std::ops::DerefMut for SparseBufferMemoryBindInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target4103     fn deref_mut(&mut self) -> &mut Self::Target {
4104         &mut self.inner
4105     }
4106 }
4107 impl<'a> SparseBufferMemoryBindInfoBuilder<'a> {
4108     #[inline]
buffer(mut self, buffer: Buffer) -> Self4109     pub fn buffer(mut self, buffer: Buffer) -> Self {
4110         self.inner.buffer = buffer;
4111         self
4112     }
4113     #[inline]
binds(mut self, binds: &'a [SparseMemoryBind]) -> Self4114     pub fn binds(mut self, binds: &'a [SparseMemoryBind]) -> Self {
4115         self.inner.bind_count = binds.len() as _;
4116         self.inner.p_binds = binds.as_ptr();
4117         self
4118     }
4119     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4120     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4121     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SparseBufferMemoryBindInfo4122     pub fn build(self) -> SparseBufferMemoryBindInfo {
4123         self.inner
4124     }
4125 }
4126 #[repr(C)]
4127 #[cfg_attr(feature = "debug", derive(Debug))]
4128 #[derive(Copy, Clone)]
4129 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageOpaqueMemoryBindInfo.html>"]
4130 pub struct SparseImageOpaqueMemoryBindInfo {
4131     pub image: Image,
4132     pub bind_count: u32,
4133     pub p_binds: *const SparseMemoryBind,
4134 }
4135 impl ::std::default::Default for SparseImageOpaqueMemoryBindInfo {
4136     #[inline]
default() -> Self4137     fn default() -> Self {
4138         Self {
4139             image: Image::default(),
4140             bind_count: u32::default(),
4141             p_binds: ::std::ptr::null(),
4142         }
4143     }
4144 }
4145 impl SparseImageOpaqueMemoryBindInfo {
builder<'a>() -> SparseImageOpaqueMemoryBindInfoBuilder<'a>4146     pub fn builder<'a>() -> SparseImageOpaqueMemoryBindInfoBuilder<'a> {
4147         SparseImageOpaqueMemoryBindInfoBuilder {
4148             inner: Self::default(),
4149             marker: ::std::marker::PhantomData,
4150         }
4151     }
4152 }
4153 #[repr(transparent)]
4154 pub struct SparseImageOpaqueMemoryBindInfoBuilder<'a> {
4155     inner: SparseImageOpaqueMemoryBindInfo,
4156     marker: ::std::marker::PhantomData<&'a ()>,
4157 }
4158 impl<'a> ::std::ops::Deref for SparseImageOpaqueMemoryBindInfoBuilder<'a> {
4159     type Target = SparseImageOpaqueMemoryBindInfo;
deref(&self) -> &Self::Target4160     fn deref(&self) -> &Self::Target {
4161         &self.inner
4162     }
4163 }
4164 impl<'a> ::std::ops::DerefMut for SparseImageOpaqueMemoryBindInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target4165     fn deref_mut(&mut self) -> &mut Self::Target {
4166         &mut self.inner
4167     }
4168 }
4169 impl<'a> SparseImageOpaqueMemoryBindInfoBuilder<'a> {
4170     #[inline]
image(mut self, image: Image) -> Self4171     pub fn image(mut self, image: Image) -> Self {
4172         self.inner.image = image;
4173         self
4174     }
4175     #[inline]
binds(mut self, binds: &'a [SparseMemoryBind]) -> Self4176     pub fn binds(mut self, binds: &'a [SparseMemoryBind]) -> Self {
4177         self.inner.bind_count = binds.len() as _;
4178         self.inner.p_binds = binds.as_ptr();
4179         self
4180     }
4181     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4182     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4183     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SparseImageOpaqueMemoryBindInfo4184     pub fn build(self) -> SparseImageOpaqueMemoryBindInfo {
4185         self.inner
4186     }
4187 }
4188 #[repr(C)]
4189 #[cfg_attr(feature = "debug", derive(Debug))]
4190 #[derive(Copy, Clone)]
4191 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageMemoryBindInfo.html>"]
4192 pub struct SparseImageMemoryBindInfo {
4193     pub image: Image,
4194     pub bind_count: u32,
4195     pub p_binds: *const SparseImageMemoryBind,
4196 }
4197 impl ::std::default::Default for SparseImageMemoryBindInfo {
4198     #[inline]
default() -> Self4199     fn default() -> Self {
4200         Self {
4201             image: Image::default(),
4202             bind_count: u32::default(),
4203             p_binds: ::std::ptr::null(),
4204         }
4205     }
4206 }
4207 impl SparseImageMemoryBindInfo {
builder<'a>() -> SparseImageMemoryBindInfoBuilder<'a>4208     pub fn builder<'a>() -> SparseImageMemoryBindInfoBuilder<'a> {
4209         SparseImageMemoryBindInfoBuilder {
4210             inner: Self::default(),
4211             marker: ::std::marker::PhantomData,
4212         }
4213     }
4214 }
4215 #[repr(transparent)]
4216 pub struct SparseImageMemoryBindInfoBuilder<'a> {
4217     inner: SparseImageMemoryBindInfo,
4218     marker: ::std::marker::PhantomData<&'a ()>,
4219 }
4220 impl<'a> ::std::ops::Deref for SparseImageMemoryBindInfoBuilder<'a> {
4221     type Target = SparseImageMemoryBindInfo;
deref(&self) -> &Self::Target4222     fn deref(&self) -> &Self::Target {
4223         &self.inner
4224     }
4225 }
4226 impl<'a> ::std::ops::DerefMut for SparseImageMemoryBindInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target4227     fn deref_mut(&mut self) -> &mut Self::Target {
4228         &mut self.inner
4229     }
4230 }
4231 impl<'a> SparseImageMemoryBindInfoBuilder<'a> {
4232     #[inline]
image(mut self, image: Image) -> Self4233     pub fn image(mut self, image: Image) -> Self {
4234         self.inner.image = image;
4235         self
4236     }
4237     #[inline]
binds(mut self, binds: &'a [SparseImageMemoryBind]) -> Self4238     pub fn binds(mut self, binds: &'a [SparseImageMemoryBind]) -> Self {
4239         self.inner.bind_count = binds.len() as _;
4240         self.inner.p_binds = binds.as_ptr();
4241         self
4242     }
4243     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4244     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4245     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SparseImageMemoryBindInfo4246     pub fn build(self) -> SparseImageMemoryBindInfo {
4247         self.inner
4248     }
4249 }
4250 #[repr(C)]
4251 #[cfg_attr(feature = "debug", derive(Debug))]
4252 #[derive(Copy, Clone)]
4253 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindSparseInfo.html>"]
4254 pub struct BindSparseInfo {
4255     pub s_type: StructureType,
4256     pub p_next: *const c_void,
4257     pub wait_semaphore_count: u32,
4258     pub p_wait_semaphores: *const Semaphore,
4259     pub buffer_bind_count: u32,
4260     pub p_buffer_binds: *const SparseBufferMemoryBindInfo,
4261     pub image_opaque_bind_count: u32,
4262     pub p_image_opaque_binds: *const SparseImageOpaqueMemoryBindInfo,
4263     pub image_bind_count: u32,
4264     pub p_image_binds: *const SparseImageMemoryBindInfo,
4265     pub signal_semaphore_count: u32,
4266     pub p_signal_semaphores: *const Semaphore,
4267 }
4268 impl ::std::default::Default for BindSparseInfo {
4269     #[inline]
default() -> Self4270     fn default() -> Self {
4271         Self {
4272             s_type: Self::STRUCTURE_TYPE,
4273             p_next: ::std::ptr::null(),
4274             wait_semaphore_count: u32::default(),
4275             p_wait_semaphores: ::std::ptr::null(),
4276             buffer_bind_count: u32::default(),
4277             p_buffer_binds: ::std::ptr::null(),
4278             image_opaque_bind_count: u32::default(),
4279             p_image_opaque_binds: ::std::ptr::null(),
4280             image_bind_count: u32::default(),
4281             p_image_binds: ::std::ptr::null(),
4282             signal_semaphore_count: u32::default(),
4283             p_signal_semaphores: ::std::ptr::null(),
4284         }
4285     }
4286 }
4287 unsafe impl TaggedStructure for BindSparseInfo {
4288     const STRUCTURE_TYPE: StructureType = StructureType::BIND_SPARSE_INFO;
4289 }
4290 impl BindSparseInfo {
builder<'a>() -> BindSparseInfoBuilder<'a>4291     pub fn builder<'a>() -> BindSparseInfoBuilder<'a> {
4292         BindSparseInfoBuilder {
4293             inner: Self::default(),
4294             marker: ::std::marker::PhantomData,
4295         }
4296     }
4297 }
4298 #[repr(transparent)]
4299 pub struct BindSparseInfoBuilder<'a> {
4300     inner: BindSparseInfo,
4301     marker: ::std::marker::PhantomData<&'a ()>,
4302 }
4303 pub unsafe trait ExtendsBindSparseInfo {}
4304 impl<'a> ::std::ops::Deref for BindSparseInfoBuilder<'a> {
4305     type Target = BindSparseInfo;
deref(&self) -> &Self::Target4306     fn deref(&self) -> &Self::Target {
4307         &self.inner
4308     }
4309 }
4310 impl<'a> ::std::ops::DerefMut for BindSparseInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target4311     fn deref_mut(&mut self) -> &mut Self::Target {
4312         &mut self.inner
4313     }
4314 }
4315 impl<'a> BindSparseInfoBuilder<'a> {
4316     #[inline]
wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> Self4317     pub fn wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> Self {
4318         self.inner.wait_semaphore_count = wait_semaphores.len() as _;
4319         self.inner.p_wait_semaphores = wait_semaphores.as_ptr();
4320         self
4321     }
4322     #[inline]
buffer_binds(mut self, buffer_binds: &'a [SparseBufferMemoryBindInfo]) -> Self4323     pub fn buffer_binds(mut self, buffer_binds: &'a [SparseBufferMemoryBindInfo]) -> Self {
4324         self.inner.buffer_bind_count = buffer_binds.len() as _;
4325         self.inner.p_buffer_binds = buffer_binds.as_ptr();
4326         self
4327     }
4328     #[inline]
image_opaque_binds( mut self, image_opaque_binds: &'a [SparseImageOpaqueMemoryBindInfo], ) -> Self4329     pub fn image_opaque_binds(
4330         mut self,
4331         image_opaque_binds: &'a [SparseImageOpaqueMemoryBindInfo],
4332     ) -> Self {
4333         self.inner.image_opaque_bind_count = image_opaque_binds.len() as _;
4334         self.inner.p_image_opaque_binds = image_opaque_binds.as_ptr();
4335         self
4336     }
4337     #[inline]
image_binds(mut self, image_binds: &'a [SparseImageMemoryBindInfo]) -> Self4338     pub fn image_binds(mut self, image_binds: &'a [SparseImageMemoryBindInfo]) -> Self {
4339         self.inner.image_bind_count = image_binds.len() as _;
4340         self.inner.p_image_binds = image_binds.as_ptr();
4341         self
4342     }
4343     #[inline]
signal_semaphores(mut self, signal_semaphores: &'a [Semaphore]) -> Self4344     pub fn signal_semaphores(mut self, signal_semaphores: &'a [Semaphore]) -> Self {
4345         self.inner.signal_semaphore_count = signal_semaphores.len() as _;
4346         self.inner.p_signal_semaphores = signal_semaphores.as_ptr();
4347         self
4348     }
4349     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
4350     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
4351     #[doc = r" valid extension structs can be pushed into the chain."]
4352     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
4353     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsBindSparseInfo>(mut self, next: &'a mut T) -> Self4354     pub fn push_next<T: ExtendsBindSparseInfo>(mut self, next: &'a mut T) -> Self {
4355         unsafe {
4356             let next_ptr = <*const T>::cast(next);
4357             let last_next = ptr_chain_iter(next).last().unwrap();
4358             (*last_next).p_next = self.inner.p_next as _;
4359             self.inner.p_next = next_ptr;
4360         }
4361         self
4362     }
4363     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4364     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4365     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BindSparseInfo4366     pub fn build(self) -> BindSparseInfo {
4367         self.inner
4368     }
4369 }
4370 #[repr(C)]
4371 #[cfg_attr(feature = "debug", derive(Debug))]
4372 #[derive(Copy, Clone, Default)]
4373 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCopy.html>"]
4374 pub struct ImageCopy {
4375     pub src_subresource: ImageSubresourceLayers,
4376     pub src_offset: Offset3D,
4377     pub dst_subresource: ImageSubresourceLayers,
4378     pub dst_offset: Offset3D,
4379     pub extent: Extent3D,
4380 }
4381 impl ImageCopy {
builder<'a>() -> ImageCopyBuilder<'a>4382     pub fn builder<'a>() -> ImageCopyBuilder<'a> {
4383         ImageCopyBuilder {
4384             inner: Self::default(),
4385             marker: ::std::marker::PhantomData,
4386         }
4387     }
4388 }
4389 #[repr(transparent)]
4390 pub struct ImageCopyBuilder<'a> {
4391     inner: ImageCopy,
4392     marker: ::std::marker::PhantomData<&'a ()>,
4393 }
4394 impl<'a> ::std::ops::Deref for ImageCopyBuilder<'a> {
4395     type Target = ImageCopy;
deref(&self) -> &Self::Target4396     fn deref(&self) -> &Self::Target {
4397         &self.inner
4398     }
4399 }
4400 impl<'a> ::std::ops::DerefMut for ImageCopyBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target4401     fn deref_mut(&mut self) -> &mut Self::Target {
4402         &mut self.inner
4403     }
4404 }
4405 impl<'a> ImageCopyBuilder<'a> {
4406     #[inline]
src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self4407     pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self {
4408         self.inner.src_subresource = src_subresource;
4409         self
4410     }
4411     #[inline]
src_offset(mut self, src_offset: Offset3D) -> Self4412     pub fn src_offset(mut self, src_offset: Offset3D) -> Self {
4413         self.inner.src_offset = src_offset;
4414         self
4415     }
4416     #[inline]
dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self4417     pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self {
4418         self.inner.dst_subresource = dst_subresource;
4419         self
4420     }
4421     #[inline]
dst_offset(mut self, dst_offset: Offset3D) -> Self4422     pub fn dst_offset(mut self, dst_offset: Offset3D) -> Self {
4423         self.inner.dst_offset = dst_offset;
4424         self
4425     }
4426     #[inline]
extent(mut self, extent: Extent3D) -> Self4427     pub fn extent(mut self, extent: Extent3D) -> Self {
4428         self.inner.extent = extent;
4429         self
4430     }
4431     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4432     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4433     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageCopy4434     pub fn build(self) -> ImageCopy {
4435         self.inner
4436     }
4437 }
4438 #[repr(C)]
4439 #[cfg_attr(feature = "debug", derive(Debug))]
4440 #[derive(Copy, Clone)]
4441 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageBlit.html>"]
4442 pub struct ImageBlit {
4443     pub src_subresource: ImageSubresourceLayers,
4444     pub src_offsets: [Offset3D; 2],
4445     pub dst_subresource: ImageSubresourceLayers,
4446     pub dst_offsets: [Offset3D; 2],
4447 }
4448 impl ::std::default::Default for ImageBlit {
4449     #[inline]
default() -> Self4450     fn default() -> Self {
4451         Self {
4452             src_subresource: ImageSubresourceLayers::default(),
4453             src_offsets: unsafe { ::std::mem::zeroed() },
4454             dst_subresource: ImageSubresourceLayers::default(),
4455             dst_offsets: unsafe { ::std::mem::zeroed() },
4456         }
4457     }
4458 }
4459 impl ImageBlit {
builder<'a>() -> ImageBlitBuilder<'a>4460     pub fn builder<'a>() -> ImageBlitBuilder<'a> {
4461         ImageBlitBuilder {
4462             inner: Self::default(),
4463             marker: ::std::marker::PhantomData,
4464         }
4465     }
4466 }
4467 #[repr(transparent)]
4468 pub struct ImageBlitBuilder<'a> {
4469     inner: ImageBlit,
4470     marker: ::std::marker::PhantomData<&'a ()>,
4471 }
4472 impl<'a> ::std::ops::Deref for ImageBlitBuilder<'a> {
4473     type Target = ImageBlit;
deref(&self) -> &Self::Target4474     fn deref(&self) -> &Self::Target {
4475         &self.inner
4476     }
4477 }
4478 impl<'a> ::std::ops::DerefMut for ImageBlitBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target4479     fn deref_mut(&mut self) -> &mut Self::Target {
4480         &mut self.inner
4481     }
4482 }
4483 impl<'a> ImageBlitBuilder<'a> {
4484     #[inline]
src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self4485     pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self {
4486         self.inner.src_subresource = src_subresource;
4487         self
4488     }
4489     #[inline]
src_offsets(mut self, src_offsets: [Offset3D; 2]) -> Self4490     pub fn src_offsets(mut self, src_offsets: [Offset3D; 2]) -> Self {
4491         self.inner.src_offsets = src_offsets;
4492         self
4493     }
4494     #[inline]
dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self4495     pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self {
4496         self.inner.dst_subresource = dst_subresource;
4497         self
4498     }
4499     #[inline]
dst_offsets(mut self, dst_offsets: [Offset3D; 2]) -> Self4500     pub fn dst_offsets(mut self, dst_offsets: [Offset3D; 2]) -> Self {
4501         self.inner.dst_offsets = dst_offsets;
4502         self
4503     }
4504     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4505     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4506     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageBlit4507     pub fn build(self) -> ImageBlit {
4508         self.inner
4509     }
4510 }
4511 #[repr(C)]
4512 #[cfg_attr(feature = "debug", derive(Debug))]
4513 #[derive(Copy, Clone, Default)]
4514 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferImageCopy.html>"]
4515 pub struct BufferImageCopy {
4516     pub buffer_offset: DeviceSize,
4517     pub buffer_row_length: u32,
4518     pub buffer_image_height: u32,
4519     pub image_subresource: ImageSubresourceLayers,
4520     pub image_offset: Offset3D,
4521     pub image_extent: Extent3D,
4522 }
4523 impl BufferImageCopy {
builder<'a>() -> BufferImageCopyBuilder<'a>4524     pub fn builder<'a>() -> BufferImageCopyBuilder<'a> {
4525         BufferImageCopyBuilder {
4526             inner: Self::default(),
4527             marker: ::std::marker::PhantomData,
4528         }
4529     }
4530 }
4531 #[repr(transparent)]
4532 pub struct BufferImageCopyBuilder<'a> {
4533     inner: BufferImageCopy,
4534     marker: ::std::marker::PhantomData<&'a ()>,
4535 }
4536 impl<'a> ::std::ops::Deref for BufferImageCopyBuilder<'a> {
4537     type Target = BufferImageCopy;
deref(&self) -> &Self::Target4538     fn deref(&self) -> &Self::Target {
4539         &self.inner
4540     }
4541 }
4542 impl<'a> ::std::ops::DerefMut for BufferImageCopyBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target4543     fn deref_mut(&mut self) -> &mut Self::Target {
4544         &mut self.inner
4545     }
4546 }
4547 impl<'a> BufferImageCopyBuilder<'a> {
4548     #[inline]
buffer_offset(mut self, buffer_offset: DeviceSize) -> Self4549     pub fn buffer_offset(mut self, buffer_offset: DeviceSize) -> Self {
4550         self.inner.buffer_offset = buffer_offset;
4551         self
4552     }
4553     #[inline]
buffer_row_length(mut self, buffer_row_length: u32) -> Self4554     pub fn buffer_row_length(mut self, buffer_row_length: u32) -> Self {
4555         self.inner.buffer_row_length = buffer_row_length;
4556         self
4557     }
4558     #[inline]
buffer_image_height(mut self, buffer_image_height: u32) -> Self4559     pub fn buffer_image_height(mut self, buffer_image_height: u32) -> Self {
4560         self.inner.buffer_image_height = buffer_image_height;
4561         self
4562     }
4563     #[inline]
image_subresource(mut self, image_subresource: ImageSubresourceLayers) -> Self4564     pub fn image_subresource(mut self, image_subresource: ImageSubresourceLayers) -> Self {
4565         self.inner.image_subresource = image_subresource;
4566         self
4567     }
4568     #[inline]
image_offset(mut self, image_offset: Offset3D) -> Self4569     pub fn image_offset(mut self, image_offset: Offset3D) -> Self {
4570         self.inner.image_offset = image_offset;
4571         self
4572     }
4573     #[inline]
image_extent(mut self, image_extent: Extent3D) -> Self4574     pub fn image_extent(mut self, image_extent: Extent3D) -> Self {
4575         self.inner.image_extent = image_extent;
4576         self
4577     }
4578     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4579     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4580     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferImageCopy4581     pub fn build(self) -> BufferImageCopy {
4582         self.inner
4583     }
4584 }
4585 #[repr(C)]
4586 #[cfg_attr(feature = "debug", derive(Debug))]
4587 #[derive(Copy, Clone, Default)]
4588 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyMemoryIndirectCommandNV.html>"]
4589 pub struct CopyMemoryIndirectCommandNV {
4590     pub src_address: DeviceAddress,
4591     pub dst_address: DeviceAddress,
4592     pub size: DeviceSize,
4593 }
4594 impl CopyMemoryIndirectCommandNV {
builder<'a>() -> CopyMemoryIndirectCommandNVBuilder<'a>4595     pub fn builder<'a>() -> CopyMemoryIndirectCommandNVBuilder<'a> {
4596         CopyMemoryIndirectCommandNVBuilder {
4597             inner: Self::default(),
4598             marker: ::std::marker::PhantomData,
4599         }
4600     }
4601 }
4602 #[repr(transparent)]
4603 pub struct CopyMemoryIndirectCommandNVBuilder<'a> {
4604     inner: CopyMemoryIndirectCommandNV,
4605     marker: ::std::marker::PhantomData<&'a ()>,
4606 }
4607 impl<'a> ::std::ops::Deref for CopyMemoryIndirectCommandNVBuilder<'a> {
4608     type Target = CopyMemoryIndirectCommandNV;
deref(&self) -> &Self::Target4609     fn deref(&self) -> &Self::Target {
4610         &self.inner
4611     }
4612 }
4613 impl<'a> ::std::ops::DerefMut for CopyMemoryIndirectCommandNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target4614     fn deref_mut(&mut self) -> &mut Self::Target {
4615         &mut self.inner
4616     }
4617 }
4618 impl<'a> CopyMemoryIndirectCommandNVBuilder<'a> {
4619     #[inline]
src_address(mut self, src_address: DeviceAddress) -> Self4620     pub fn src_address(mut self, src_address: DeviceAddress) -> Self {
4621         self.inner.src_address = src_address;
4622         self
4623     }
4624     #[inline]
dst_address(mut self, dst_address: DeviceAddress) -> Self4625     pub fn dst_address(mut self, dst_address: DeviceAddress) -> Self {
4626         self.inner.dst_address = dst_address;
4627         self
4628     }
4629     #[inline]
size(mut self, size: DeviceSize) -> Self4630     pub fn size(mut self, size: DeviceSize) -> Self {
4631         self.inner.size = size;
4632         self
4633     }
4634     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4635     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4636     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CopyMemoryIndirectCommandNV4637     pub fn build(self) -> CopyMemoryIndirectCommandNV {
4638         self.inner
4639     }
4640 }
4641 #[repr(C)]
4642 #[cfg_attr(feature = "debug", derive(Debug))]
4643 #[derive(Copy, Clone, Default)]
4644 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyMemoryToImageIndirectCommandNV.html>"]
4645 pub struct CopyMemoryToImageIndirectCommandNV {
4646     pub src_address: DeviceAddress,
4647     pub buffer_row_length: u32,
4648     pub buffer_image_height: u32,
4649     pub image_subresource: ImageSubresourceLayers,
4650     pub image_offset: Offset3D,
4651     pub image_extent: Extent3D,
4652 }
4653 impl CopyMemoryToImageIndirectCommandNV {
builder<'a>() -> CopyMemoryToImageIndirectCommandNVBuilder<'a>4654     pub fn builder<'a>() -> CopyMemoryToImageIndirectCommandNVBuilder<'a> {
4655         CopyMemoryToImageIndirectCommandNVBuilder {
4656             inner: Self::default(),
4657             marker: ::std::marker::PhantomData,
4658         }
4659     }
4660 }
4661 #[repr(transparent)]
4662 pub struct CopyMemoryToImageIndirectCommandNVBuilder<'a> {
4663     inner: CopyMemoryToImageIndirectCommandNV,
4664     marker: ::std::marker::PhantomData<&'a ()>,
4665 }
4666 impl<'a> ::std::ops::Deref for CopyMemoryToImageIndirectCommandNVBuilder<'a> {
4667     type Target = CopyMemoryToImageIndirectCommandNV;
deref(&self) -> &Self::Target4668     fn deref(&self) -> &Self::Target {
4669         &self.inner
4670     }
4671 }
4672 impl<'a> ::std::ops::DerefMut for CopyMemoryToImageIndirectCommandNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target4673     fn deref_mut(&mut self) -> &mut Self::Target {
4674         &mut self.inner
4675     }
4676 }
4677 impl<'a> CopyMemoryToImageIndirectCommandNVBuilder<'a> {
4678     #[inline]
src_address(mut self, src_address: DeviceAddress) -> Self4679     pub fn src_address(mut self, src_address: DeviceAddress) -> Self {
4680         self.inner.src_address = src_address;
4681         self
4682     }
4683     #[inline]
buffer_row_length(mut self, buffer_row_length: u32) -> Self4684     pub fn buffer_row_length(mut self, buffer_row_length: u32) -> Self {
4685         self.inner.buffer_row_length = buffer_row_length;
4686         self
4687     }
4688     #[inline]
buffer_image_height(mut self, buffer_image_height: u32) -> Self4689     pub fn buffer_image_height(mut self, buffer_image_height: u32) -> Self {
4690         self.inner.buffer_image_height = buffer_image_height;
4691         self
4692     }
4693     #[inline]
image_subresource(mut self, image_subresource: ImageSubresourceLayers) -> Self4694     pub fn image_subresource(mut self, image_subresource: ImageSubresourceLayers) -> Self {
4695         self.inner.image_subresource = image_subresource;
4696         self
4697     }
4698     #[inline]
image_offset(mut self, image_offset: Offset3D) -> Self4699     pub fn image_offset(mut self, image_offset: Offset3D) -> Self {
4700         self.inner.image_offset = image_offset;
4701         self
4702     }
4703     #[inline]
image_extent(mut self, image_extent: Extent3D) -> Self4704     pub fn image_extent(mut self, image_extent: Extent3D) -> Self {
4705         self.inner.image_extent = image_extent;
4706         self
4707     }
4708     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4709     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4710     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CopyMemoryToImageIndirectCommandNV4711     pub fn build(self) -> CopyMemoryToImageIndirectCommandNV {
4712         self.inner
4713     }
4714 }
4715 #[repr(C)]
4716 #[cfg_attr(feature = "debug", derive(Debug))]
4717 #[derive(Copy, Clone, Default)]
4718 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageResolve.html>"]
4719 pub struct ImageResolve {
4720     pub src_subresource: ImageSubresourceLayers,
4721     pub src_offset: Offset3D,
4722     pub dst_subresource: ImageSubresourceLayers,
4723     pub dst_offset: Offset3D,
4724     pub extent: Extent3D,
4725 }
4726 impl ImageResolve {
builder<'a>() -> ImageResolveBuilder<'a>4727     pub fn builder<'a>() -> ImageResolveBuilder<'a> {
4728         ImageResolveBuilder {
4729             inner: Self::default(),
4730             marker: ::std::marker::PhantomData,
4731         }
4732     }
4733 }
4734 #[repr(transparent)]
4735 pub struct ImageResolveBuilder<'a> {
4736     inner: ImageResolve,
4737     marker: ::std::marker::PhantomData<&'a ()>,
4738 }
4739 impl<'a> ::std::ops::Deref for ImageResolveBuilder<'a> {
4740     type Target = ImageResolve;
deref(&self) -> &Self::Target4741     fn deref(&self) -> &Self::Target {
4742         &self.inner
4743     }
4744 }
4745 impl<'a> ::std::ops::DerefMut for ImageResolveBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target4746     fn deref_mut(&mut self) -> &mut Self::Target {
4747         &mut self.inner
4748     }
4749 }
4750 impl<'a> ImageResolveBuilder<'a> {
4751     #[inline]
src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self4752     pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self {
4753         self.inner.src_subresource = src_subresource;
4754         self
4755     }
4756     #[inline]
src_offset(mut self, src_offset: Offset3D) -> Self4757     pub fn src_offset(mut self, src_offset: Offset3D) -> Self {
4758         self.inner.src_offset = src_offset;
4759         self
4760     }
4761     #[inline]
dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self4762     pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self {
4763         self.inner.dst_subresource = dst_subresource;
4764         self
4765     }
4766     #[inline]
dst_offset(mut self, dst_offset: Offset3D) -> Self4767     pub fn dst_offset(mut self, dst_offset: Offset3D) -> Self {
4768         self.inner.dst_offset = dst_offset;
4769         self
4770     }
4771     #[inline]
extent(mut self, extent: Extent3D) -> Self4772     pub fn extent(mut self, extent: Extent3D) -> Self {
4773         self.inner.extent = extent;
4774         self
4775     }
4776     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4777     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4778     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageResolve4779     pub fn build(self) -> ImageResolve {
4780         self.inner
4781     }
4782 }
4783 #[repr(C)]
4784 #[cfg_attr(feature = "debug", derive(Debug))]
4785 #[derive(Copy, Clone)]
4786 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderModuleCreateInfo.html>"]
4787 pub struct ShaderModuleCreateInfo {
4788     pub s_type: StructureType,
4789     pub p_next: *const c_void,
4790     pub flags: ShaderModuleCreateFlags,
4791     pub code_size: usize,
4792     pub p_code: *const u32,
4793 }
4794 impl ::std::default::Default for ShaderModuleCreateInfo {
4795     #[inline]
default() -> Self4796     fn default() -> Self {
4797         Self {
4798             s_type: Self::STRUCTURE_TYPE,
4799             p_next: ::std::ptr::null(),
4800             flags: ShaderModuleCreateFlags::default(),
4801             code_size: usize::default(),
4802             p_code: ::std::ptr::null(),
4803         }
4804     }
4805 }
4806 unsafe impl TaggedStructure for ShaderModuleCreateInfo {
4807     const STRUCTURE_TYPE: StructureType = StructureType::SHADER_MODULE_CREATE_INFO;
4808 }
4809 impl ShaderModuleCreateInfo {
builder<'a>() -> ShaderModuleCreateInfoBuilder<'a>4810     pub fn builder<'a>() -> ShaderModuleCreateInfoBuilder<'a> {
4811         ShaderModuleCreateInfoBuilder {
4812             inner: Self::default(),
4813             marker: ::std::marker::PhantomData,
4814         }
4815     }
4816 }
4817 #[repr(transparent)]
4818 pub struct ShaderModuleCreateInfoBuilder<'a> {
4819     inner: ShaderModuleCreateInfo,
4820     marker: ::std::marker::PhantomData<&'a ()>,
4821 }
4822 unsafe impl ExtendsPipelineShaderStageCreateInfo for ShaderModuleCreateInfoBuilder<'_> {}
4823 unsafe impl ExtendsPipelineShaderStageCreateInfo for ShaderModuleCreateInfo {}
4824 pub unsafe trait ExtendsShaderModuleCreateInfo {}
4825 impl<'a> ::std::ops::Deref for ShaderModuleCreateInfoBuilder<'a> {
4826     type Target = ShaderModuleCreateInfo;
deref(&self) -> &Self::Target4827     fn deref(&self) -> &Self::Target {
4828         &self.inner
4829     }
4830 }
4831 impl<'a> ::std::ops::DerefMut for ShaderModuleCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target4832     fn deref_mut(&mut self) -> &mut Self::Target {
4833         &mut self.inner
4834     }
4835 }
4836 impl<'a> ShaderModuleCreateInfoBuilder<'a> {
4837     #[inline]
flags(mut self, flags: ShaderModuleCreateFlags) -> Self4838     pub fn flags(mut self, flags: ShaderModuleCreateFlags) -> Self {
4839         self.inner.flags = flags;
4840         self
4841     }
4842     #[inline]
code(mut self, code: &'a [u32]) -> Self4843     pub fn code(mut self, code: &'a [u32]) -> Self {
4844         self.inner.code_size = code.len() * 4;
4845         self.inner.p_code = code.as_ptr();
4846         self
4847     }
4848     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
4849     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
4850     #[doc = r" valid extension structs can be pushed into the chain."]
4851     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
4852     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsShaderModuleCreateInfo>(mut self, next: &'a mut T) -> Self4853     pub fn push_next<T: ExtendsShaderModuleCreateInfo>(mut self, next: &'a mut T) -> Self {
4854         unsafe {
4855             let next_ptr = <*const T>::cast(next);
4856             let last_next = ptr_chain_iter(next).last().unwrap();
4857             (*last_next).p_next = self.inner.p_next as _;
4858             self.inner.p_next = next_ptr;
4859         }
4860         self
4861     }
4862     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4863     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4864     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ShaderModuleCreateInfo4865     pub fn build(self) -> ShaderModuleCreateInfo {
4866         self.inner
4867     }
4868 }
4869 #[repr(C)]
4870 #[cfg_attr(feature = "debug", derive(Debug))]
4871 #[derive(Copy, Clone)]
4872 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutBinding.html>"]
4873 pub struct DescriptorSetLayoutBinding {
4874     pub binding: u32,
4875     pub descriptor_type: DescriptorType,
4876     pub descriptor_count: u32,
4877     pub stage_flags: ShaderStageFlags,
4878     pub p_immutable_samplers: *const Sampler,
4879 }
4880 impl ::std::default::Default for DescriptorSetLayoutBinding {
4881     #[inline]
default() -> Self4882     fn default() -> Self {
4883         Self {
4884             binding: u32::default(),
4885             descriptor_type: DescriptorType::default(),
4886             descriptor_count: u32::default(),
4887             stage_flags: ShaderStageFlags::default(),
4888             p_immutable_samplers: ::std::ptr::null(),
4889         }
4890     }
4891 }
4892 impl DescriptorSetLayoutBinding {
builder<'a>() -> DescriptorSetLayoutBindingBuilder<'a>4893     pub fn builder<'a>() -> DescriptorSetLayoutBindingBuilder<'a> {
4894         DescriptorSetLayoutBindingBuilder {
4895             inner: Self::default(),
4896             marker: ::std::marker::PhantomData,
4897         }
4898     }
4899 }
4900 #[repr(transparent)]
4901 pub struct DescriptorSetLayoutBindingBuilder<'a> {
4902     inner: DescriptorSetLayoutBinding,
4903     marker: ::std::marker::PhantomData<&'a ()>,
4904 }
4905 impl<'a> ::std::ops::Deref for DescriptorSetLayoutBindingBuilder<'a> {
4906     type Target = DescriptorSetLayoutBinding;
deref(&self) -> &Self::Target4907     fn deref(&self) -> &Self::Target {
4908         &self.inner
4909     }
4910 }
4911 impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutBindingBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target4912     fn deref_mut(&mut self) -> &mut Self::Target {
4913         &mut self.inner
4914     }
4915 }
4916 impl<'a> DescriptorSetLayoutBindingBuilder<'a> {
4917     #[inline]
binding(mut self, binding: u32) -> Self4918     pub fn binding(mut self, binding: u32) -> Self {
4919         self.inner.binding = binding;
4920         self
4921     }
4922     #[inline]
descriptor_type(mut self, descriptor_type: DescriptorType) -> Self4923     pub fn descriptor_type(mut self, descriptor_type: DescriptorType) -> Self {
4924         self.inner.descriptor_type = descriptor_type;
4925         self
4926     }
4927     #[inline]
descriptor_count(mut self, descriptor_count: u32) -> Self4928     pub fn descriptor_count(mut self, descriptor_count: u32) -> Self {
4929         self.inner.descriptor_count = descriptor_count;
4930         self
4931     }
4932     #[inline]
stage_flags(mut self, stage_flags: ShaderStageFlags) -> Self4933     pub fn stage_flags(mut self, stage_flags: ShaderStageFlags) -> Self {
4934         self.inner.stage_flags = stage_flags;
4935         self
4936     }
4937     #[inline]
immutable_samplers(mut self, immutable_samplers: &'a [Sampler]) -> Self4938     pub fn immutable_samplers(mut self, immutable_samplers: &'a [Sampler]) -> Self {
4939         self.inner.descriptor_count = immutable_samplers.len() as _;
4940         self.inner.p_immutable_samplers = immutable_samplers.as_ptr();
4941         self
4942     }
4943     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4944     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4945     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorSetLayoutBinding4946     pub fn build(self) -> DescriptorSetLayoutBinding {
4947         self.inner
4948     }
4949 }
4950 #[repr(C)]
4951 #[cfg_attr(feature = "debug", derive(Debug))]
4952 #[derive(Copy, Clone)]
4953 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutCreateInfo.html>"]
4954 pub struct DescriptorSetLayoutCreateInfo {
4955     pub s_type: StructureType,
4956     pub p_next: *const c_void,
4957     pub flags: DescriptorSetLayoutCreateFlags,
4958     pub binding_count: u32,
4959     pub p_bindings: *const DescriptorSetLayoutBinding,
4960 }
4961 impl ::std::default::Default for DescriptorSetLayoutCreateInfo {
4962     #[inline]
default() -> Self4963     fn default() -> Self {
4964         Self {
4965             s_type: Self::STRUCTURE_TYPE,
4966             p_next: ::std::ptr::null(),
4967             flags: DescriptorSetLayoutCreateFlags::default(),
4968             binding_count: u32::default(),
4969             p_bindings: ::std::ptr::null(),
4970         }
4971     }
4972 }
4973 unsafe impl TaggedStructure for DescriptorSetLayoutCreateInfo {
4974     const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
4975 }
4976 impl DescriptorSetLayoutCreateInfo {
builder<'a>() -> DescriptorSetLayoutCreateInfoBuilder<'a>4977     pub fn builder<'a>() -> DescriptorSetLayoutCreateInfoBuilder<'a> {
4978         DescriptorSetLayoutCreateInfoBuilder {
4979             inner: Self::default(),
4980             marker: ::std::marker::PhantomData,
4981         }
4982     }
4983 }
4984 #[repr(transparent)]
4985 pub struct DescriptorSetLayoutCreateInfoBuilder<'a> {
4986     inner: DescriptorSetLayoutCreateInfo,
4987     marker: ::std::marker::PhantomData<&'a ()>,
4988 }
4989 pub unsafe trait ExtendsDescriptorSetLayoutCreateInfo {}
4990 impl<'a> ::std::ops::Deref for DescriptorSetLayoutCreateInfoBuilder<'a> {
4991     type Target = DescriptorSetLayoutCreateInfo;
deref(&self) -> &Self::Target4992     fn deref(&self) -> &Self::Target {
4993         &self.inner
4994     }
4995 }
4996 impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target4997     fn deref_mut(&mut self) -> &mut Self::Target {
4998         &mut self.inner
4999     }
5000 }
5001 impl<'a> DescriptorSetLayoutCreateInfoBuilder<'a> {
5002     #[inline]
flags(mut self, flags: DescriptorSetLayoutCreateFlags) -> Self5003     pub fn flags(mut self, flags: DescriptorSetLayoutCreateFlags) -> Self {
5004         self.inner.flags = flags;
5005         self
5006     }
5007     #[inline]
bindings(mut self, bindings: &'a [DescriptorSetLayoutBinding]) -> Self5008     pub fn bindings(mut self, bindings: &'a [DescriptorSetLayoutBinding]) -> Self {
5009         self.inner.binding_count = bindings.len() as _;
5010         self.inner.p_bindings = bindings.as_ptr();
5011         self
5012     }
5013     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
5014     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
5015     #[doc = r" valid extension structs can be pushed into the chain."]
5016     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
5017     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDescriptorSetLayoutCreateInfo>(mut self, next: &'a mut T) -> Self5018     pub fn push_next<T: ExtendsDescriptorSetLayoutCreateInfo>(mut self, next: &'a mut T) -> Self {
5019         unsafe {
5020             let next_ptr = <*const T>::cast(next);
5021             let last_next = ptr_chain_iter(next).last().unwrap();
5022             (*last_next).p_next = self.inner.p_next as _;
5023             self.inner.p_next = next_ptr;
5024         }
5025         self
5026     }
5027     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5028     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5029     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorSetLayoutCreateInfo5030     pub fn build(self) -> DescriptorSetLayoutCreateInfo {
5031         self.inner
5032     }
5033 }
5034 #[repr(C)]
5035 #[cfg_attr(feature = "debug", derive(Debug))]
5036 #[derive(Copy, Clone, Default)]
5037 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPoolSize.html>"]
5038 pub struct DescriptorPoolSize {
5039     pub ty: DescriptorType,
5040     pub descriptor_count: u32,
5041 }
5042 impl DescriptorPoolSize {
builder<'a>() -> DescriptorPoolSizeBuilder<'a>5043     pub fn builder<'a>() -> DescriptorPoolSizeBuilder<'a> {
5044         DescriptorPoolSizeBuilder {
5045             inner: Self::default(),
5046             marker: ::std::marker::PhantomData,
5047         }
5048     }
5049 }
5050 #[repr(transparent)]
5051 pub struct DescriptorPoolSizeBuilder<'a> {
5052     inner: DescriptorPoolSize,
5053     marker: ::std::marker::PhantomData<&'a ()>,
5054 }
5055 impl<'a> ::std::ops::Deref for DescriptorPoolSizeBuilder<'a> {
5056     type Target = DescriptorPoolSize;
deref(&self) -> &Self::Target5057     fn deref(&self) -> &Self::Target {
5058         &self.inner
5059     }
5060 }
5061 impl<'a> ::std::ops::DerefMut for DescriptorPoolSizeBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target5062     fn deref_mut(&mut self) -> &mut Self::Target {
5063         &mut self.inner
5064     }
5065 }
5066 impl<'a> DescriptorPoolSizeBuilder<'a> {
5067     #[inline]
ty(mut self, ty: DescriptorType) -> Self5068     pub fn ty(mut self, ty: DescriptorType) -> Self {
5069         self.inner.ty = ty;
5070         self
5071     }
5072     #[inline]
descriptor_count(mut self, descriptor_count: u32) -> Self5073     pub fn descriptor_count(mut self, descriptor_count: u32) -> Self {
5074         self.inner.descriptor_count = descriptor_count;
5075         self
5076     }
5077     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5078     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5079     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorPoolSize5080     pub fn build(self) -> DescriptorPoolSize {
5081         self.inner
5082     }
5083 }
5084 #[repr(C)]
5085 #[cfg_attr(feature = "debug", derive(Debug))]
5086 #[derive(Copy, Clone)]
5087 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPoolCreateInfo.html>"]
5088 pub struct DescriptorPoolCreateInfo {
5089     pub s_type: StructureType,
5090     pub p_next: *const c_void,
5091     pub flags: DescriptorPoolCreateFlags,
5092     pub max_sets: u32,
5093     pub pool_size_count: u32,
5094     pub p_pool_sizes: *const DescriptorPoolSize,
5095 }
5096 impl ::std::default::Default for DescriptorPoolCreateInfo {
5097     #[inline]
default() -> Self5098     fn default() -> Self {
5099         Self {
5100             s_type: Self::STRUCTURE_TYPE,
5101             p_next: ::std::ptr::null(),
5102             flags: DescriptorPoolCreateFlags::default(),
5103             max_sets: u32::default(),
5104             pool_size_count: u32::default(),
5105             p_pool_sizes: ::std::ptr::null(),
5106         }
5107     }
5108 }
5109 unsafe impl TaggedStructure for DescriptorPoolCreateInfo {
5110     const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_POOL_CREATE_INFO;
5111 }
5112 impl DescriptorPoolCreateInfo {
builder<'a>() -> DescriptorPoolCreateInfoBuilder<'a>5113     pub fn builder<'a>() -> DescriptorPoolCreateInfoBuilder<'a> {
5114         DescriptorPoolCreateInfoBuilder {
5115             inner: Self::default(),
5116             marker: ::std::marker::PhantomData,
5117         }
5118     }
5119 }
5120 #[repr(transparent)]
5121 pub struct DescriptorPoolCreateInfoBuilder<'a> {
5122     inner: DescriptorPoolCreateInfo,
5123     marker: ::std::marker::PhantomData<&'a ()>,
5124 }
5125 pub unsafe trait ExtendsDescriptorPoolCreateInfo {}
5126 impl<'a> ::std::ops::Deref for DescriptorPoolCreateInfoBuilder<'a> {
5127     type Target = DescriptorPoolCreateInfo;
deref(&self) -> &Self::Target5128     fn deref(&self) -> &Self::Target {
5129         &self.inner
5130     }
5131 }
5132 impl<'a> ::std::ops::DerefMut for DescriptorPoolCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target5133     fn deref_mut(&mut self) -> &mut Self::Target {
5134         &mut self.inner
5135     }
5136 }
5137 impl<'a> DescriptorPoolCreateInfoBuilder<'a> {
5138     #[inline]
flags(mut self, flags: DescriptorPoolCreateFlags) -> Self5139     pub fn flags(mut self, flags: DescriptorPoolCreateFlags) -> Self {
5140         self.inner.flags = flags;
5141         self
5142     }
5143     #[inline]
max_sets(mut self, max_sets: u32) -> Self5144     pub fn max_sets(mut self, max_sets: u32) -> Self {
5145         self.inner.max_sets = max_sets;
5146         self
5147     }
5148     #[inline]
pool_sizes(mut self, pool_sizes: &'a [DescriptorPoolSize]) -> Self5149     pub fn pool_sizes(mut self, pool_sizes: &'a [DescriptorPoolSize]) -> Self {
5150         self.inner.pool_size_count = pool_sizes.len() as _;
5151         self.inner.p_pool_sizes = pool_sizes.as_ptr();
5152         self
5153     }
5154     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
5155     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
5156     #[doc = r" valid extension structs can be pushed into the chain."]
5157     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
5158     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDescriptorPoolCreateInfo>(mut self, next: &'a mut T) -> Self5159     pub fn push_next<T: ExtendsDescriptorPoolCreateInfo>(mut self, next: &'a mut T) -> Self {
5160         unsafe {
5161             let next_ptr = <*const T>::cast(next);
5162             let last_next = ptr_chain_iter(next).last().unwrap();
5163             (*last_next).p_next = self.inner.p_next as _;
5164             self.inner.p_next = next_ptr;
5165         }
5166         self
5167     }
5168     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5169     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5170     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorPoolCreateInfo5171     pub fn build(self) -> DescriptorPoolCreateInfo {
5172         self.inner
5173     }
5174 }
5175 #[repr(C)]
5176 #[cfg_attr(feature = "debug", derive(Debug))]
5177 #[derive(Copy, Clone)]
5178 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetAllocateInfo.html>"]
5179 pub struct DescriptorSetAllocateInfo {
5180     pub s_type: StructureType,
5181     pub p_next: *const c_void,
5182     pub descriptor_pool: DescriptorPool,
5183     pub descriptor_set_count: u32,
5184     pub p_set_layouts: *const DescriptorSetLayout,
5185 }
5186 impl ::std::default::Default for DescriptorSetAllocateInfo {
5187     #[inline]
default() -> Self5188     fn default() -> Self {
5189         Self {
5190             s_type: Self::STRUCTURE_TYPE,
5191             p_next: ::std::ptr::null(),
5192             descriptor_pool: DescriptorPool::default(),
5193             descriptor_set_count: u32::default(),
5194             p_set_layouts: ::std::ptr::null(),
5195         }
5196     }
5197 }
5198 unsafe impl TaggedStructure for DescriptorSetAllocateInfo {
5199     const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_SET_ALLOCATE_INFO;
5200 }
5201 impl DescriptorSetAllocateInfo {
builder<'a>() -> DescriptorSetAllocateInfoBuilder<'a>5202     pub fn builder<'a>() -> DescriptorSetAllocateInfoBuilder<'a> {
5203         DescriptorSetAllocateInfoBuilder {
5204             inner: Self::default(),
5205             marker: ::std::marker::PhantomData,
5206         }
5207     }
5208 }
5209 #[repr(transparent)]
5210 pub struct DescriptorSetAllocateInfoBuilder<'a> {
5211     inner: DescriptorSetAllocateInfo,
5212     marker: ::std::marker::PhantomData<&'a ()>,
5213 }
5214 pub unsafe trait ExtendsDescriptorSetAllocateInfo {}
5215 impl<'a> ::std::ops::Deref for DescriptorSetAllocateInfoBuilder<'a> {
5216     type Target = DescriptorSetAllocateInfo;
deref(&self) -> &Self::Target5217     fn deref(&self) -> &Self::Target {
5218         &self.inner
5219     }
5220 }
5221 impl<'a> ::std::ops::DerefMut for DescriptorSetAllocateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target5222     fn deref_mut(&mut self) -> &mut Self::Target {
5223         &mut self.inner
5224     }
5225 }
5226 impl<'a> DescriptorSetAllocateInfoBuilder<'a> {
5227     #[inline]
descriptor_pool(mut self, descriptor_pool: DescriptorPool) -> Self5228     pub fn descriptor_pool(mut self, descriptor_pool: DescriptorPool) -> Self {
5229         self.inner.descriptor_pool = descriptor_pool;
5230         self
5231     }
5232     #[inline]
set_layouts(mut self, set_layouts: &'a [DescriptorSetLayout]) -> Self5233     pub fn set_layouts(mut self, set_layouts: &'a [DescriptorSetLayout]) -> Self {
5234         self.inner.descriptor_set_count = set_layouts.len() as _;
5235         self.inner.p_set_layouts = set_layouts.as_ptr();
5236         self
5237     }
5238     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
5239     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
5240     #[doc = r" valid extension structs can be pushed into the chain."]
5241     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
5242     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDescriptorSetAllocateInfo>(mut self, next: &'a mut T) -> Self5243     pub fn push_next<T: ExtendsDescriptorSetAllocateInfo>(mut self, next: &'a mut T) -> Self {
5244         unsafe {
5245             let next_ptr = <*const T>::cast(next);
5246             let last_next = ptr_chain_iter(next).last().unwrap();
5247             (*last_next).p_next = self.inner.p_next as _;
5248             self.inner.p_next = next_ptr;
5249         }
5250         self
5251     }
5252     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5253     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5254     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorSetAllocateInfo5255     pub fn build(self) -> DescriptorSetAllocateInfo {
5256         self.inner
5257     }
5258 }
5259 #[repr(C)]
5260 #[cfg_attr(feature = "debug", derive(Debug))]
5261 #[derive(Copy, Clone, Default)]
5262 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSpecializationMapEntry.html>"]
5263 pub struct SpecializationMapEntry {
5264     pub constant_id: u32,
5265     pub offset: u32,
5266     pub size: usize,
5267 }
5268 impl SpecializationMapEntry {
builder<'a>() -> SpecializationMapEntryBuilder<'a>5269     pub fn builder<'a>() -> SpecializationMapEntryBuilder<'a> {
5270         SpecializationMapEntryBuilder {
5271             inner: Self::default(),
5272             marker: ::std::marker::PhantomData,
5273         }
5274     }
5275 }
5276 #[repr(transparent)]
5277 pub struct SpecializationMapEntryBuilder<'a> {
5278     inner: SpecializationMapEntry,
5279     marker: ::std::marker::PhantomData<&'a ()>,
5280 }
5281 impl<'a> ::std::ops::Deref for SpecializationMapEntryBuilder<'a> {
5282     type Target = SpecializationMapEntry;
deref(&self) -> &Self::Target5283     fn deref(&self) -> &Self::Target {
5284         &self.inner
5285     }
5286 }
5287 impl<'a> ::std::ops::DerefMut for SpecializationMapEntryBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target5288     fn deref_mut(&mut self) -> &mut Self::Target {
5289         &mut self.inner
5290     }
5291 }
5292 impl<'a> SpecializationMapEntryBuilder<'a> {
5293     #[inline]
constant_id(mut self, constant_id: u32) -> Self5294     pub fn constant_id(mut self, constant_id: u32) -> Self {
5295         self.inner.constant_id = constant_id;
5296         self
5297     }
5298     #[inline]
offset(mut self, offset: u32) -> Self5299     pub fn offset(mut self, offset: u32) -> Self {
5300         self.inner.offset = offset;
5301         self
5302     }
5303     #[inline]
size(mut self, size: usize) -> Self5304     pub fn size(mut self, size: usize) -> Self {
5305         self.inner.size = size;
5306         self
5307     }
5308     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5309     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5310     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SpecializationMapEntry5311     pub fn build(self) -> SpecializationMapEntry {
5312         self.inner
5313     }
5314 }
5315 #[repr(C)]
5316 #[cfg_attr(feature = "debug", derive(Debug))]
5317 #[derive(Copy, Clone)]
5318 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSpecializationInfo.html>"]
5319 pub struct SpecializationInfo {
5320     pub map_entry_count: u32,
5321     pub p_map_entries: *const SpecializationMapEntry,
5322     pub data_size: usize,
5323     pub p_data: *const c_void,
5324 }
5325 impl ::std::default::Default for SpecializationInfo {
5326     #[inline]
default() -> Self5327     fn default() -> Self {
5328         Self {
5329             map_entry_count: u32::default(),
5330             p_map_entries: ::std::ptr::null(),
5331             data_size: usize::default(),
5332             p_data: ::std::ptr::null(),
5333         }
5334     }
5335 }
5336 impl SpecializationInfo {
builder<'a>() -> SpecializationInfoBuilder<'a>5337     pub fn builder<'a>() -> SpecializationInfoBuilder<'a> {
5338         SpecializationInfoBuilder {
5339             inner: Self::default(),
5340             marker: ::std::marker::PhantomData,
5341         }
5342     }
5343 }
5344 #[repr(transparent)]
5345 pub struct SpecializationInfoBuilder<'a> {
5346     inner: SpecializationInfo,
5347     marker: ::std::marker::PhantomData<&'a ()>,
5348 }
5349 impl<'a> ::std::ops::Deref for SpecializationInfoBuilder<'a> {
5350     type Target = SpecializationInfo;
deref(&self) -> &Self::Target5351     fn deref(&self) -> &Self::Target {
5352         &self.inner
5353     }
5354 }
5355 impl<'a> ::std::ops::DerefMut for SpecializationInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target5356     fn deref_mut(&mut self) -> &mut Self::Target {
5357         &mut self.inner
5358     }
5359 }
5360 impl<'a> SpecializationInfoBuilder<'a> {
5361     #[inline]
map_entries(mut self, map_entries: &'a [SpecializationMapEntry]) -> Self5362     pub fn map_entries(mut self, map_entries: &'a [SpecializationMapEntry]) -> Self {
5363         self.inner.map_entry_count = map_entries.len() as _;
5364         self.inner.p_map_entries = map_entries.as_ptr();
5365         self
5366     }
5367     #[inline]
data(mut self, data: &'a [u8]) -> Self5368     pub fn data(mut self, data: &'a [u8]) -> Self {
5369         self.inner.data_size = data.len();
5370         self.inner.p_data = data.as_ptr().cast();
5371         self
5372     }
5373     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5374     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5375     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SpecializationInfo5376     pub fn build(self) -> SpecializationInfo {
5377         self.inner
5378     }
5379 }
5380 #[repr(C)]
5381 #[cfg_attr(feature = "debug", derive(Debug))]
5382 #[derive(Copy, Clone)]
5383 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineShaderStageCreateInfo.html>"]
5384 pub struct PipelineShaderStageCreateInfo {
5385     pub s_type: StructureType,
5386     pub p_next: *const c_void,
5387     pub flags: PipelineShaderStageCreateFlags,
5388     pub stage: ShaderStageFlags,
5389     pub module: ShaderModule,
5390     pub p_name: *const c_char,
5391     pub p_specialization_info: *const SpecializationInfo,
5392 }
5393 impl ::std::default::Default for PipelineShaderStageCreateInfo {
5394     #[inline]
default() -> Self5395     fn default() -> Self {
5396         Self {
5397             s_type: Self::STRUCTURE_TYPE,
5398             p_next: ::std::ptr::null(),
5399             flags: PipelineShaderStageCreateFlags::default(),
5400             stage: ShaderStageFlags::default(),
5401             module: ShaderModule::default(),
5402             p_name: ::std::ptr::null(),
5403             p_specialization_info: ::std::ptr::null(),
5404         }
5405     }
5406 }
5407 unsafe impl TaggedStructure for PipelineShaderStageCreateInfo {
5408     const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_SHADER_STAGE_CREATE_INFO;
5409 }
5410 impl PipelineShaderStageCreateInfo {
builder<'a>() -> PipelineShaderStageCreateInfoBuilder<'a>5411     pub fn builder<'a>() -> PipelineShaderStageCreateInfoBuilder<'a> {
5412         PipelineShaderStageCreateInfoBuilder {
5413             inner: Self::default(),
5414             marker: ::std::marker::PhantomData,
5415         }
5416     }
5417 }
5418 #[repr(transparent)]
5419 pub struct PipelineShaderStageCreateInfoBuilder<'a> {
5420     inner: PipelineShaderStageCreateInfo,
5421     marker: ::std::marker::PhantomData<&'a ()>,
5422 }
5423 pub unsafe trait ExtendsPipelineShaderStageCreateInfo {}
5424 impl<'a> ::std::ops::Deref for PipelineShaderStageCreateInfoBuilder<'a> {
5425     type Target = PipelineShaderStageCreateInfo;
deref(&self) -> &Self::Target5426     fn deref(&self) -> &Self::Target {
5427         &self.inner
5428     }
5429 }
5430 impl<'a> ::std::ops::DerefMut for PipelineShaderStageCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target5431     fn deref_mut(&mut self) -> &mut Self::Target {
5432         &mut self.inner
5433     }
5434 }
5435 impl<'a> PipelineShaderStageCreateInfoBuilder<'a> {
5436     #[inline]
flags(mut self, flags: PipelineShaderStageCreateFlags) -> Self5437     pub fn flags(mut self, flags: PipelineShaderStageCreateFlags) -> Self {
5438         self.inner.flags = flags;
5439         self
5440     }
5441     #[inline]
stage(mut self, stage: ShaderStageFlags) -> Self5442     pub fn stage(mut self, stage: ShaderStageFlags) -> Self {
5443         self.inner.stage = stage;
5444         self
5445     }
5446     #[inline]
module(mut self, module: ShaderModule) -> Self5447     pub fn module(mut self, module: ShaderModule) -> Self {
5448         self.inner.module = module;
5449         self
5450     }
5451     #[inline]
name(mut self, name: &'a ::std::ffi::CStr) -> Self5452     pub fn name(mut self, name: &'a ::std::ffi::CStr) -> Self {
5453         self.inner.p_name = name.as_ptr();
5454         self
5455     }
5456     #[inline]
specialization_info(mut self, specialization_info: &'a SpecializationInfo) -> Self5457     pub fn specialization_info(mut self, specialization_info: &'a SpecializationInfo) -> Self {
5458         self.inner.p_specialization_info = specialization_info;
5459         self
5460     }
5461     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
5462     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
5463     #[doc = r" valid extension structs can be pushed into the chain."]
5464     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
5465     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPipelineShaderStageCreateInfo>(mut self, next: &'a mut T) -> Self5466     pub fn push_next<T: ExtendsPipelineShaderStageCreateInfo>(mut self, next: &'a mut T) -> Self {
5467         unsafe {
5468             let next_ptr = <*const T>::cast(next);
5469             let last_next = ptr_chain_iter(next).last().unwrap();
5470             (*last_next).p_next = self.inner.p_next as _;
5471             self.inner.p_next = next_ptr;
5472         }
5473         self
5474     }
5475     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5476     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5477     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineShaderStageCreateInfo5478     pub fn build(self) -> PipelineShaderStageCreateInfo {
5479         self.inner
5480     }
5481 }
5482 #[repr(C)]
5483 #[cfg_attr(feature = "debug", derive(Debug))]
5484 #[derive(Copy, Clone)]
5485 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkComputePipelineCreateInfo.html>"]
5486 pub struct ComputePipelineCreateInfo {
5487     pub s_type: StructureType,
5488     pub p_next: *const c_void,
5489     pub flags: PipelineCreateFlags,
5490     pub stage: PipelineShaderStageCreateInfo,
5491     pub layout: PipelineLayout,
5492     pub base_pipeline_handle: Pipeline,
5493     pub base_pipeline_index: i32,
5494 }
5495 impl ::std::default::Default for ComputePipelineCreateInfo {
5496     #[inline]
default() -> Self5497     fn default() -> Self {
5498         Self {
5499             s_type: Self::STRUCTURE_TYPE,
5500             p_next: ::std::ptr::null(),
5501             flags: PipelineCreateFlags::default(),
5502             stage: PipelineShaderStageCreateInfo::default(),
5503             layout: PipelineLayout::default(),
5504             base_pipeline_handle: Pipeline::default(),
5505             base_pipeline_index: i32::default(),
5506         }
5507     }
5508 }
5509 unsafe impl TaggedStructure for ComputePipelineCreateInfo {
5510     const STRUCTURE_TYPE: StructureType = StructureType::COMPUTE_PIPELINE_CREATE_INFO;
5511 }
5512 impl ComputePipelineCreateInfo {
builder<'a>() -> ComputePipelineCreateInfoBuilder<'a>5513     pub fn builder<'a>() -> ComputePipelineCreateInfoBuilder<'a> {
5514         ComputePipelineCreateInfoBuilder {
5515             inner: Self::default(),
5516             marker: ::std::marker::PhantomData,
5517         }
5518     }
5519 }
5520 #[repr(transparent)]
5521 pub struct ComputePipelineCreateInfoBuilder<'a> {
5522     inner: ComputePipelineCreateInfo,
5523     marker: ::std::marker::PhantomData<&'a ()>,
5524 }
5525 pub unsafe trait ExtendsComputePipelineCreateInfo {}
5526 impl<'a> ::std::ops::Deref for ComputePipelineCreateInfoBuilder<'a> {
5527     type Target = ComputePipelineCreateInfo;
deref(&self) -> &Self::Target5528     fn deref(&self) -> &Self::Target {
5529         &self.inner
5530     }
5531 }
5532 impl<'a> ::std::ops::DerefMut for ComputePipelineCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target5533     fn deref_mut(&mut self) -> &mut Self::Target {
5534         &mut self.inner
5535     }
5536 }
5537 impl<'a> ComputePipelineCreateInfoBuilder<'a> {
5538     #[inline]
flags(mut self, flags: PipelineCreateFlags) -> Self5539     pub fn flags(mut self, flags: PipelineCreateFlags) -> Self {
5540         self.inner.flags = flags;
5541         self
5542     }
5543     #[inline]
stage(mut self, stage: PipelineShaderStageCreateInfo) -> Self5544     pub fn stage(mut self, stage: PipelineShaderStageCreateInfo) -> Self {
5545         self.inner.stage = stage;
5546         self
5547     }
5548     #[inline]
layout(mut self, layout: PipelineLayout) -> Self5549     pub fn layout(mut self, layout: PipelineLayout) -> Self {
5550         self.inner.layout = layout;
5551         self
5552     }
5553     #[inline]
base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self5554     pub fn base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self {
5555         self.inner.base_pipeline_handle = base_pipeline_handle;
5556         self
5557     }
5558     #[inline]
base_pipeline_index(mut self, base_pipeline_index: i32) -> Self5559     pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self {
5560         self.inner.base_pipeline_index = base_pipeline_index;
5561         self
5562     }
5563     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
5564     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
5565     #[doc = r" valid extension structs can be pushed into the chain."]
5566     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
5567     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsComputePipelineCreateInfo>(mut self, next: &'a mut T) -> Self5568     pub fn push_next<T: ExtendsComputePipelineCreateInfo>(mut self, next: &'a mut T) -> Self {
5569         unsafe {
5570             let next_ptr = <*const T>::cast(next);
5571             let last_next = ptr_chain_iter(next).last().unwrap();
5572             (*last_next).p_next = self.inner.p_next as _;
5573             self.inner.p_next = next_ptr;
5574         }
5575         self
5576     }
5577     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5578     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5579     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ComputePipelineCreateInfo5580     pub fn build(self) -> ComputePipelineCreateInfo {
5581         self.inner
5582     }
5583 }
5584 #[repr(C)]
5585 #[cfg_attr(feature = "debug", derive(Debug))]
5586 #[derive(Copy, Clone, Default)]
5587 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVertexInputBindingDescription.html>"]
5588 pub struct VertexInputBindingDescription {
5589     pub binding: u32,
5590     pub stride: u32,
5591     pub input_rate: VertexInputRate,
5592 }
5593 impl VertexInputBindingDescription {
builder<'a>() -> VertexInputBindingDescriptionBuilder<'a>5594     pub fn builder<'a>() -> VertexInputBindingDescriptionBuilder<'a> {
5595         VertexInputBindingDescriptionBuilder {
5596             inner: Self::default(),
5597             marker: ::std::marker::PhantomData,
5598         }
5599     }
5600 }
5601 #[repr(transparent)]
5602 pub struct VertexInputBindingDescriptionBuilder<'a> {
5603     inner: VertexInputBindingDescription,
5604     marker: ::std::marker::PhantomData<&'a ()>,
5605 }
5606 impl<'a> ::std::ops::Deref for VertexInputBindingDescriptionBuilder<'a> {
5607     type Target = VertexInputBindingDescription;
deref(&self) -> &Self::Target5608     fn deref(&self) -> &Self::Target {
5609         &self.inner
5610     }
5611 }
5612 impl<'a> ::std::ops::DerefMut for VertexInputBindingDescriptionBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target5613     fn deref_mut(&mut self) -> &mut Self::Target {
5614         &mut self.inner
5615     }
5616 }
5617 impl<'a> VertexInputBindingDescriptionBuilder<'a> {
5618     #[inline]
binding(mut self, binding: u32) -> Self5619     pub fn binding(mut self, binding: u32) -> Self {
5620         self.inner.binding = binding;
5621         self
5622     }
5623     #[inline]
stride(mut self, stride: u32) -> Self5624     pub fn stride(mut self, stride: u32) -> Self {
5625         self.inner.stride = stride;
5626         self
5627     }
5628     #[inline]
input_rate(mut self, input_rate: VertexInputRate) -> Self5629     pub fn input_rate(mut self, input_rate: VertexInputRate) -> Self {
5630         self.inner.input_rate = input_rate;
5631         self
5632     }
5633     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5634     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5635     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VertexInputBindingDescription5636     pub fn build(self) -> VertexInputBindingDescription {
5637         self.inner
5638     }
5639 }
5640 #[repr(C)]
5641 #[cfg_attr(feature = "debug", derive(Debug))]
5642 #[derive(Copy, Clone, Default)]
5643 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVertexInputAttributeDescription.html>"]
5644 pub struct VertexInputAttributeDescription {
5645     pub location: u32,
5646     pub binding: u32,
5647     pub format: Format,
5648     pub offset: u32,
5649 }
5650 impl VertexInputAttributeDescription {
builder<'a>() -> VertexInputAttributeDescriptionBuilder<'a>5651     pub fn builder<'a>() -> VertexInputAttributeDescriptionBuilder<'a> {
5652         VertexInputAttributeDescriptionBuilder {
5653             inner: Self::default(),
5654             marker: ::std::marker::PhantomData,
5655         }
5656     }
5657 }
5658 #[repr(transparent)]
5659 pub struct VertexInputAttributeDescriptionBuilder<'a> {
5660     inner: VertexInputAttributeDescription,
5661     marker: ::std::marker::PhantomData<&'a ()>,
5662 }
5663 impl<'a> ::std::ops::Deref for VertexInputAttributeDescriptionBuilder<'a> {
5664     type Target = VertexInputAttributeDescription;
deref(&self) -> &Self::Target5665     fn deref(&self) -> &Self::Target {
5666         &self.inner
5667     }
5668 }
5669 impl<'a> ::std::ops::DerefMut for VertexInputAttributeDescriptionBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target5670     fn deref_mut(&mut self) -> &mut Self::Target {
5671         &mut self.inner
5672     }
5673 }
5674 impl<'a> VertexInputAttributeDescriptionBuilder<'a> {
5675     #[inline]
location(mut self, location: u32) -> Self5676     pub fn location(mut self, location: u32) -> Self {
5677         self.inner.location = location;
5678         self
5679     }
5680     #[inline]
binding(mut self, binding: u32) -> Self5681     pub fn binding(mut self, binding: u32) -> Self {
5682         self.inner.binding = binding;
5683         self
5684     }
5685     #[inline]
format(mut self, format: Format) -> Self5686     pub fn format(mut self, format: Format) -> Self {
5687         self.inner.format = format;
5688         self
5689     }
5690     #[inline]
offset(mut self, offset: u32) -> Self5691     pub fn offset(mut self, offset: u32) -> Self {
5692         self.inner.offset = offset;
5693         self
5694     }
5695     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5696     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5697     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VertexInputAttributeDescription5698     pub fn build(self) -> VertexInputAttributeDescription {
5699         self.inner
5700     }
5701 }
5702 #[repr(C)]
5703 #[cfg_attr(feature = "debug", derive(Debug))]
5704 #[derive(Copy, Clone)]
5705 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineVertexInputStateCreateInfo.html>"]
5706 pub struct PipelineVertexInputStateCreateInfo {
5707     pub s_type: StructureType,
5708     pub p_next: *const c_void,
5709     pub flags: PipelineVertexInputStateCreateFlags,
5710     pub vertex_binding_description_count: u32,
5711     pub p_vertex_binding_descriptions: *const VertexInputBindingDescription,
5712     pub vertex_attribute_description_count: u32,
5713     pub p_vertex_attribute_descriptions: *const VertexInputAttributeDescription,
5714 }
5715 impl ::std::default::Default for PipelineVertexInputStateCreateInfo {
5716     #[inline]
default() -> Self5717     fn default() -> Self {
5718         Self {
5719             s_type: Self::STRUCTURE_TYPE,
5720             p_next: ::std::ptr::null(),
5721             flags: PipelineVertexInputStateCreateFlags::default(),
5722             vertex_binding_description_count: u32::default(),
5723             p_vertex_binding_descriptions: ::std::ptr::null(),
5724             vertex_attribute_description_count: u32::default(),
5725             p_vertex_attribute_descriptions: ::std::ptr::null(),
5726         }
5727     }
5728 }
5729 unsafe impl TaggedStructure for PipelineVertexInputStateCreateInfo {
5730     const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
5731 }
5732 impl PipelineVertexInputStateCreateInfo {
builder<'a>() -> PipelineVertexInputStateCreateInfoBuilder<'a>5733     pub fn builder<'a>() -> PipelineVertexInputStateCreateInfoBuilder<'a> {
5734         PipelineVertexInputStateCreateInfoBuilder {
5735             inner: Self::default(),
5736             marker: ::std::marker::PhantomData,
5737         }
5738     }
5739 }
5740 #[repr(transparent)]
5741 pub struct PipelineVertexInputStateCreateInfoBuilder<'a> {
5742     inner: PipelineVertexInputStateCreateInfo,
5743     marker: ::std::marker::PhantomData<&'a ()>,
5744 }
5745 pub unsafe trait ExtendsPipelineVertexInputStateCreateInfo {}
5746 impl<'a> ::std::ops::Deref for PipelineVertexInputStateCreateInfoBuilder<'a> {
5747     type Target = PipelineVertexInputStateCreateInfo;
deref(&self) -> &Self::Target5748     fn deref(&self) -> &Self::Target {
5749         &self.inner
5750     }
5751 }
5752 impl<'a> ::std::ops::DerefMut for PipelineVertexInputStateCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target5753     fn deref_mut(&mut self) -> &mut Self::Target {
5754         &mut self.inner
5755     }
5756 }
5757 impl<'a> PipelineVertexInputStateCreateInfoBuilder<'a> {
5758     #[inline]
flags(mut self, flags: PipelineVertexInputStateCreateFlags) -> Self5759     pub fn flags(mut self, flags: PipelineVertexInputStateCreateFlags) -> Self {
5760         self.inner.flags = flags;
5761         self
5762     }
5763     #[inline]
vertex_binding_descriptions( mut self, vertex_binding_descriptions: &'a [VertexInputBindingDescription], ) -> Self5764     pub fn vertex_binding_descriptions(
5765         mut self,
5766         vertex_binding_descriptions: &'a [VertexInputBindingDescription],
5767     ) -> Self {
5768         self.inner.vertex_binding_description_count = vertex_binding_descriptions.len() as _;
5769         self.inner.p_vertex_binding_descriptions = vertex_binding_descriptions.as_ptr();
5770         self
5771     }
5772     #[inline]
vertex_attribute_descriptions( mut self, vertex_attribute_descriptions: &'a [VertexInputAttributeDescription], ) -> Self5773     pub fn vertex_attribute_descriptions(
5774         mut self,
5775         vertex_attribute_descriptions: &'a [VertexInputAttributeDescription],
5776     ) -> Self {
5777         self.inner.vertex_attribute_description_count = vertex_attribute_descriptions.len() as _;
5778         self.inner.p_vertex_attribute_descriptions = vertex_attribute_descriptions.as_ptr();
5779         self
5780     }
5781     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
5782     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
5783     #[doc = r" valid extension structs can be pushed into the chain."]
5784     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
5785     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPipelineVertexInputStateCreateInfo>( mut self, next: &'a mut T, ) -> Self5786     pub fn push_next<T: ExtendsPipelineVertexInputStateCreateInfo>(
5787         mut self,
5788         next: &'a mut T,
5789     ) -> Self {
5790         unsafe {
5791             let next_ptr = <*const T>::cast(next);
5792             let last_next = ptr_chain_iter(next).last().unwrap();
5793             (*last_next).p_next = self.inner.p_next as _;
5794             self.inner.p_next = next_ptr;
5795         }
5796         self
5797     }
5798     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5799     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5800     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineVertexInputStateCreateInfo5801     pub fn build(self) -> PipelineVertexInputStateCreateInfo {
5802         self.inner
5803     }
5804 }
5805 #[repr(C)]
5806 #[cfg_attr(feature = "debug", derive(Debug))]
5807 #[derive(Copy, Clone)]
5808 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineInputAssemblyStateCreateInfo.html>"]
5809 pub struct PipelineInputAssemblyStateCreateInfo {
5810     pub s_type: StructureType,
5811     pub p_next: *const c_void,
5812     pub flags: PipelineInputAssemblyStateCreateFlags,
5813     pub topology: PrimitiveTopology,
5814     pub primitive_restart_enable: Bool32,
5815 }
5816 impl ::std::default::Default for PipelineInputAssemblyStateCreateInfo {
5817     #[inline]
default() -> Self5818     fn default() -> Self {
5819         Self {
5820             s_type: Self::STRUCTURE_TYPE,
5821             p_next: ::std::ptr::null(),
5822             flags: PipelineInputAssemblyStateCreateFlags::default(),
5823             topology: PrimitiveTopology::default(),
5824             primitive_restart_enable: Bool32::default(),
5825         }
5826     }
5827 }
5828 unsafe impl TaggedStructure for PipelineInputAssemblyStateCreateInfo {
5829     const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
5830 }
5831 impl PipelineInputAssemblyStateCreateInfo {
builder<'a>() -> PipelineInputAssemblyStateCreateInfoBuilder<'a>5832     pub fn builder<'a>() -> PipelineInputAssemblyStateCreateInfoBuilder<'a> {
5833         PipelineInputAssemblyStateCreateInfoBuilder {
5834             inner: Self::default(),
5835             marker: ::std::marker::PhantomData,
5836         }
5837     }
5838 }
5839 #[repr(transparent)]
5840 pub struct PipelineInputAssemblyStateCreateInfoBuilder<'a> {
5841     inner: PipelineInputAssemblyStateCreateInfo,
5842     marker: ::std::marker::PhantomData<&'a ()>,
5843 }
5844 impl<'a> ::std::ops::Deref for PipelineInputAssemblyStateCreateInfoBuilder<'a> {
5845     type Target = PipelineInputAssemblyStateCreateInfo;
deref(&self) -> &Self::Target5846     fn deref(&self) -> &Self::Target {
5847         &self.inner
5848     }
5849 }
5850 impl<'a> ::std::ops::DerefMut for PipelineInputAssemblyStateCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target5851     fn deref_mut(&mut self) -> &mut Self::Target {
5852         &mut self.inner
5853     }
5854 }
5855 impl<'a> PipelineInputAssemblyStateCreateInfoBuilder<'a> {
5856     #[inline]
flags(mut self, flags: PipelineInputAssemblyStateCreateFlags) -> Self5857     pub fn flags(mut self, flags: PipelineInputAssemblyStateCreateFlags) -> Self {
5858         self.inner.flags = flags;
5859         self
5860     }
5861     #[inline]
topology(mut self, topology: PrimitiveTopology) -> Self5862     pub fn topology(mut self, topology: PrimitiveTopology) -> Self {
5863         self.inner.topology = topology;
5864         self
5865     }
5866     #[inline]
primitive_restart_enable(mut self, primitive_restart_enable: bool) -> Self5867     pub fn primitive_restart_enable(mut self, primitive_restart_enable: bool) -> Self {
5868         self.inner.primitive_restart_enable = primitive_restart_enable.into();
5869         self
5870     }
5871     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5872     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5873     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineInputAssemblyStateCreateInfo5874     pub fn build(self) -> PipelineInputAssemblyStateCreateInfo {
5875         self.inner
5876     }
5877 }
5878 #[repr(C)]
5879 #[cfg_attr(feature = "debug", derive(Debug))]
5880 #[derive(Copy, Clone)]
5881 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineTessellationStateCreateInfo.html>"]
5882 pub struct PipelineTessellationStateCreateInfo {
5883     pub s_type: StructureType,
5884     pub p_next: *const c_void,
5885     pub flags: PipelineTessellationStateCreateFlags,
5886     pub patch_control_points: u32,
5887 }
5888 impl ::std::default::Default for PipelineTessellationStateCreateInfo {
5889     #[inline]
default() -> Self5890     fn default() -> Self {
5891         Self {
5892             s_type: Self::STRUCTURE_TYPE,
5893             p_next: ::std::ptr::null(),
5894             flags: PipelineTessellationStateCreateFlags::default(),
5895             patch_control_points: u32::default(),
5896         }
5897     }
5898 }
5899 unsafe impl TaggedStructure for PipelineTessellationStateCreateInfo {
5900     const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_TESSELLATION_STATE_CREATE_INFO;
5901 }
5902 impl PipelineTessellationStateCreateInfo {
builder<'a>() -> PipelineTessellationStateCreateInfoBuilder<'a>5903     pub fn builder<'a>() -> PipelineTessellationStateCreateInfoBuilder<'a> {
5904         PipelineTessellationStateCreateInfoBuilder {
5905             inner: Self::default(),
5906             marker: ::std::marker::PhantomData,
5907         }
5908     }
5909 }
5910 #[repr(transparent)]
5911 pub struct PipelineTessellationStateCreateInfoBuilder<'a> {
5912     inner: PipelineTessellationStateCreateInfo,
5913     marker: ::std::marker::PhantomData<&'a ()>,
5914 }
5915 pub unsafe trait ExtendsPipelineTessellationStateCreateInfo {}
5916 impl<'a> ::std::ops::Deref for PipelineTessellationStateCreateInfoBuilder<'a> {
5917     type Target = PipelineTessellationStateCreateInfo;
deref(&self) -> &Self::Target5918     fn deref(&self) -> &Self::Target {
5919         &self.inner
5920     }
5921 }
5922 impl<'a> ::std::ops::DerefMut for PipelineTessellationStateCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target5923     fn deref_mut(&mut self) -> &mut Self::Target {
5924         &mut self.inner
5925     }
5926 }
5927 impl<'a> PipelineTessellationStateCreateInfoBuilder<'a> {
5928     #[inline]
flags(mut self, flags: PipelineTessellationStateCreateFlags) -> Self5929     pub fn flags(mut self, flags: PipelineTessellationStateCreateFlags) -> Self {
5930         self.inner.flags = flags;
5931         self
5932     }
5933     #[inline]
patch_control_points(mut self, patch_control_points: u32) -> Self5934     pub fn patch_control_points(mut self, patch_control_points: u32) -> Self {
5935         self.inner.patch_control_points = patch_control_points;
5936         self
5937     }
5938     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
5939     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
5940     #[doc = r" valid extension structs can be pushed into the chain."]
5941     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
5942     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPipelineTessellationStateCreateInfo>( mut self, next: &'a mut T, ) -> Self5943     pub fn push_next<T: ExtendsPipelineTessellationStateCreateInfo>(
5944         mut self,
5945         next: &'a mut T,
5946     ) -> Self {
5947         unsafe {
5948             let next_ptr = <*const T>::cast(next);
5949             let last_next = ptr_chain_iter(next).last().unwrap();
5950             (*last_next).p_next = self.inner.p_next as _;
5951             self.inner.p_next = next_ptr;
5952         }
5953         self
5954     }
5955     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5956     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5957     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineTessellationStateCreateInfo5958     pub fn build(self) -> PipelineTessellationStateCreateInfo {
5959         self.inner
5960     }
5961 }
5962 #[repr(C)]
5963 #[cfg_attr(feature = "debug", derive(Debug))]
5964 #[derive(Copy, Clone)]
5965 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportStateCreateInfo.html>"]
5966 pub struct PipelineViewportStateCreateInfo {
5967     pub s_type: StructureType,
5968     pub p_next: *const c_void,
5969     pub flags: PipelineViewportStateCreateFlags,
5970     pub viewport_count: u32,
5971     pub p_viewports: *const Viewport,
5972     pub scissor_count: u32,
5973     pub p_scissors: *const Rect2D,
5974 }
5975 impl ::std::default::Default for PipelineViewportStateCreateInfo {
5976     #[inline]
default() -> Self5977     fn default() -> Self {
5978         Self {
5979             s_type: Self::STRUCTURE_TYPE,
5980             p_next: ::std::ptr::null(),
5981             flags: PipelineViewportStateCreateFlags::default(),
5982             viewport_count: u32::default(),
5983             p_viewports: ::std::ptr::null(),
5984             scissor_count: u32::default(),
5985             p_scissors: ::std::ptr::null(),
5986         }
5987     }
5988 }
5989 unsafe impl TaggedStructure for PipelineViewportStateCreateInfo {
5990     const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_VIEWPORT_STATE_CREATE_INFO;
5991 }
5992 impl PipelineViewportStateCreateInfo {
builder<'a>() -> PipelineViewportStateCreateInfoBuilder<'a>5993     pub fn builder<'a>() -> PipelineViewportStateCreateInfoBuilder<'a> {
5994         PipelineViewportStateCreateInfoBuilder {
5995             inner: Self::default(),
5996             marker: ::std::marker::PhantomData,
5997         }
5998     }
5999 }
6000 #[repr(transparent)]
6001 pub struct PipelineViewportStateCreateInfoBuilder<'a> {
6002     inner: PipelineViewportStateCreateInfo,
6003     marker: ::std::marker::PhantomData<&'a ()>,
6004 }
6005 pub unsafe trait ExtendsPipelineViewportStateCreateInfo {}
6006 impl<'a> ::std::ops::Deref for PipelineViewportStateCreateInfoBuilder<'a> {
6007     type Target = PipelineViewportStateCreateInfo;
deref(&self) -> &Self::Target6008     fn deref(&self) -> &Self::Target {
6009         &self.inner
6010     }
6011 }
6012 impl<'a> ::std::ops::DerefMut for PipelineViewportStateCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target6013     fn deref_mut(&mut self) -> &mut Self::Target {
6014         &mut self.inner
6015     }
6016 }
6017 impl<'a> PipelineViewportStateCreateInfoBuilder<'a> {
6018     #[inline]
flags(mut self, flags: PipelineViewportStateCreateFlags) -> Self6019     pub fn flags(mut self, flags: PipelineViewportStateCreateFlags) -> Self {
6020         self.inner.flags = flags;
6021         self
6022     }
6023     #[inline]
viewport_count(mut self, viewport_count: u32) -> Self6024     pub fn viewport_count(mut self, viewport_count: u32) -> Self {
6025         self.inner.viewport_count = viewport_count;
6026         self
6027     }
6028     #[inline]
viewports(mut self, viewports: &'a [Viewport]) -> Self6029     pub fn viewports(mut self, viewports: &'a [Viewport]) -> Self {
6030         self.inner.viewport_count = viewports.len() as _;
6031         self.inner.p_viewports = viewports.as_ptr();
6032         self
6033     }
6034     #[inline]
scissor_count(mut self, scissor_count: u32) -> Self6035     pub fn scissor_count(mut self, scissor_count: u32) -> Self {
6036         self.inner.scissor_count = scissor_count;
6037         self
6038     }
6039     #[inline]
scissors(mut self, scissors: &'a [Rect2D]) -> Self6040     pub fn scissors(mut self, scissors: &'a [Rect2D]) -> Self {
6041         self.inner.scissor_count = scissors.len() as _;
6042         self.inner.p_scissors = scissors.as_ptr();
6043         self
6044     }
6045     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
6046     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
6047     #[doc = r" valid extension structs can be pushed into the chain."]
6048     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
6049     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPipelineViewportStateCreateInfo>(mut self, next: &'a mut T) -> Self6050     pub fn push_next<T: ExtendsPipelineViewportStateCreateInfo>(mut self, next: &'a mut T) -> Self {
6051         unsafe {
6052             let next_ptr = <*const T>::cast(next);
6053             let last_next = ptr_chain_iter(next).last().unwrap();
6054             (*last_next).p_next = self.inner.p_next as _;
6055             self.inner.p_next = next_ptr;
6056         }
6057         self
6058     }
6059     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6060     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6061     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineViewportStateCreateInfo6062     pub fn build(self) -> PipelineViewportStateCreateInfo {
6063         self.inner
6064     }
6065 }
6066 #[repr(C)]
6067 #[cfg_attr(feature = "debug", derive(Debug))]
6068 #[derive(Copy, Clone)]
6069 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationStateCreateInfo.html>"]
6070 pub struct PipelineRasterizationStateCreateInfo {
6071     pub s_type: StructureType,
6072     pub p_next: *const c_void,
6073     pub flags: PipelineRasterizationStateCreateFlags,
6074     pub depth_clamp_enable: Bool32,
6075     pub rasterizer_discard_enable: Bool32,
6076     pub polygon_mode: PolygonMode,
6077     pub cull_mode: CullModeFlags,
6078     pub front_face: FrontFace,
6079     pub depth_bias_enable: Bool32,
6080     pub depth_bias_constant_factor: f32,
6081     pub depth_bias_clamp: f32,
6082     pub depth_bias_slope_factor: f32,
6083     pub line_width: f32,
6084 }
6085 impl ::std::default::Default for PipelineRasterizationStateCreateInfo {
6086     #[inline]
default() -> Self6087     fn default() -> Self {
6088         Self {
6089             s_type: Self::STRUCTURE_TYPE,
6090             p_next: ::std::ptr::null(),
6091             flags: PipelineRasterizationStateCreateFlags::default(),
6092             depth_clamp_enable: Bool32::default(),
6093             rasterizer_discard_enable: Bool32::default(),
6094             polygon_mode: PolygonMode::default(),
6095             cull_mode: CullModeFlags::default(),
6096             front_face: FrontFace::default(),
6097             depth_bias_enable: Bool32::default(),
6098             depth_bias_constant_factor: f32::default(),
6099             depth_bias_clamp: f32::default(),
6100             depth_bias_slope_factor: f32::default(),
6101             line_width: f32::default(),
6102         }
6103     }
6104 }
6105 unsafe impl TaggedStructure for PipelineRasterizationStateCreateInfo {
6106     const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
6107 }
6108 impl PipelineRasterizationStateCreateInfo {
builder<'a>() -> PipelineRasterizationStateCreateInfoBuilder<'a>6109     pub fn builder<'a>() -> PipelineRasterizationStateCreateInfoBuilder<'a> {
6110         PipelineRasterizationStateCreateInfoBuilder {
6111             inner: Self::default(),
6112             marker: ::std::marker::PhantomData,
6113         }
6114     }
6115 }
6116 #[repr(transparent)]
6117 pub struct PipelineRasterizationStateCreateInfoBuilder<'a> {
6118     inner: PipelineRasterizationStateCreateInfo,
6119     marker: ::std::marker::PhantomData<&'a ()>,
6120 }
6121 pub unsafe trait ExtendsPipelineRasterizationStateCreateInfo {}
6122 impl<'a> ::std::ops::Deref for PipelineRasterizationStateCreateInfoBuilder<'a> {
6123     type Target = PipelineRasterizationStateCreateInfo;
deref(&self) -> &Self::Target6124     fn deref(&self) -> &Self::Target {
6125         &self.inner
6126     }
6127 }
6128 impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target6129     fn deref_mut(&mut self) -> &mut Self::Target {
6130         &mut self.inner
6131     }
6132 }
6133 impl<'a> PipelineRasterizationStateCreateInfoBuilder<'a> {
6134     #[inline]
flags(mut self, flags: PipelineRasterizationStateCreateFlags) -> Self6135     pub fn flags(mut self, flags: PipelineRasterizationStateCreateFlags) -> Self {
6136         self.inner.flags = flags;
6137         self
6138     }
6139     #[inline]
depth_clamp_enable(mut self, depth_clamp_enable: bool) -> Self6140     pub fn depth_clamp_enable(mut self, depth_clamp_enable: bool) -> Self {
6141         self.inner.depth_clamp_enable = depth_clamp_enable.into();
6142         self
6143     }
6144     #[inline]
rasterizer_discard_enable(mut self, rasterizer_discard_enable: bool) -> Self6145     pub fn rasterizer_discard_enable(mut self, rasterizer_discard_enable: bool) -> Self {
6146         self.inner.rasterizer_discard_enable = rasterizer_discard_enable.into();
6147         self
6148     }
6149     #[inline]
polygon_mode(mut self, polygon_mode: PolygonMode) -> Self6150     pub fn polygon_mode(mut self, polygon_mode: PolygonMode) -> Self {
6151         self.inner.polygon_mode = polygon_mode;
6152         self
6153     }
6154     #[inline]
cull_mode(mut self, cull_mode: CullModeFlags) -> Self6155     pub fn cull_mode(mut self, cull_mode: CullModeFlags) -> Self {
6156         self.inner.cull_mode = cull_mode;
6157         self
6158     }
6159     #[inline]
front_face(mut self, front_face: FrontFace) -> Self6160     pub fn front_face(mut self, front_face: FrontFace) -> Self {
6161         self.inner.front_face = front_face;
6162         self
6163     }
6164     #[inline]
depth_bias_enable(mut self, depth_bias_enable: bool) -> Self6165     pub fn depth_bias_enable(mut self, depth_bias_enable: bool) -> Self {
6166         self.inner.depth_bias_enable = depth_bias_enable.into();
6167         self
6168     }
6169     #[inline]
depth_bias_constant_factor(mut self, depth_bias_constant_factor: f32) -> Self6170     pub fn depth_bias_constant_factor(mut self, depth_bias_constant_factor: f32) -> Self {
6171         self.inner.depth_bias_constant_factor = depth_bias_constant_factor;
6172         self
6173     }
6174     #[inline]
depth_bias_clamp(mut self, depth_bias_clamp: f32) -> Self6175     pub fn depth_bias_clamp(mut self, depth_bias_clamp: f32) -> Self {
6176         self.inner.depth_bias_clamp = depth_bias_clamp;
6177         self
6178     }
6179     #[inline]
depth_bias_slope_factor(mut self, depth_bias_slope_factor: f32) -> Self6180     pub fn depth_bias_slope_factor(mut self, depth_bias_slope_factor: f32) -> Self {
6181         self.inner.depth_bias_slope_factor = depth_bias_slope_factor;
6182         self
6183     }
6184     #[inline]
line_width(mut self, line_width: f32) -> Self6185     pub fn line_width(mut self, line_width: f32) -> Self {
6186         self.inner.line_width = line_width;
6187         self
6188     }
6189     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
6190     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
6191     #[doc = r" valid extension structs can be pushed into the chain."]
6192     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
6193     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPipelineRasterizationStateCreateInfo>( mut self, next: &'a mut T, ) -> Self6194     pub fn push_next<T: ExtendsPipelineRasterizationStateCreateInfo>(
6195         mut self,
6196         next: &'a mut T,
6197     ) -> Self {
6198         unsafe {
6199             let next_ptr = <*const T>::cast(next);
6200             let last_next = ptr_chain_iter(next).last().unwrap();
6201             (*last_next).p_next = self.inner.p_next as _;
6202             self.inner.p_next = next_ptr;
6203         }
6204         self
6205     }
6206     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6207     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6208     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineRasterizationStateCreateInfo6209     pub fn build(self) -> PipelineRasterizationStateCreateInfo {
6210         self.inner
6211     }
6212 }
6213 #[repr(C)]
6214 #[cfg_attr(feature = "debug", derive(Debug))]
6215 #[derive(Copy, Clone)]
6216 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineMultisampleStateCreateInfo.html>"]
6217 pub struct PipelineMultisampleStateCreateInfo {
6218     pub s_type: StructureType,
6219     pub p_next: *const c_void,
6220     pub flags: PipelineMultisampleStateCreateFlags,
6221     pub rasterization_samples: SampleCountFlags,
6222     pub sample_shading_enable: Bool32,
6223     pub min_sample_shading: f32,
6224     pub p_sample_mask: *const SampleMask,
6225     pub alpha_to_coverage_enable: Bool32,
6226     pub alpha_to_one_enable: Bool32,
6227 }
6228 impl ::std::default::Default for PipelineMultisampleStateCreateInfo {
6229     #[inline]
default() -> Self6230     fn default() -> Self {
6231         Self {
6232             s_type: Self::STRUCTURE_TYPE,
6233             p_next: ::std::ptr::null(),
6234             flags: PipelineMultisampleStateCreateFlags::default(),
6235             rasterization_samples: SampleCountFlags::default(),
6236             sample_shading_enable: Bool32::default(),
6237             min_sample_shading: f32::default(),
6238             p_sample_mask: ::std::ptr::null(),
6239             alpha_to_coverage_enable: Bool32::default(),
6240             alpha_to_one_enable: Bool32::default(),
6241         }
6242     }
6243 }
6244 unsafe impl TaggedStructure for PipelineMultisampleStateCreateInfo {
6245     const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
6246 }
6247 impl PipelineMultisampleStateCreateInfo {
builder<'a>() -> PipelineMultisampleStateCreateInfoBuilder<'a>6248     pub fn builder<'a>() -> PipelineMultisampleStateCreateInfoBuilder<'a> {
6249         PipelineMultisampleStateCreateInfoBuilder {
6250             inner: Self::default(),
6251             marker: ::std::marker::PhantomData,
6252         }
6253     }
6254 }
6255 #[repr(transparent)]
6256 pub struct PipelineMultisampleStateCreateInfoBuilder<'a> {
6257     inner: PipelineMultisampleStateCreateInfo,
6258     marker: ::std::marker::PhantomData<&'a ()>,
6259 }
6260 pub unsafe trait ExtendsPipelineMultisampleStateCreateInfo {}
6261 impl<'a> ::std::ops::Deref for PipelineMultisampleStateCreateInfoBuilder<'a> {
6262     type Target = PipelineMultisampleStateCreateInfo;
deref(&self) -> &Self::Target6263     fn deref(&self) -> &Self::Target {
6264         &self.inner
6265     }
6266 }
6267 impl<'a> ::std::ops::DerefMut for PipelineMultisampleStateCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target6268     fn deref_mut(&mut self) -> &mut Self::Target {
6269         &mut self.inner
6270     }
6271 }
6272 impl<'a> PipelineMultisampleStateCreateInfoBuilder<'a> {
6273     #[inline]
flags(mut self, flags: PipelineMultisampleStateCreateFlags) -> Self6274     pub fn flags(mut self, flags: PipelineMultisampleStateCreateFlags) -> Self {
6275         self.inner.flags = flags;
6276         self
6277     }
6278     #[inline]
rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self6279     pub fn rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self {
6280         self.inner.rasterization_samples = rasterization_samples;
6281         self
6282     }
6283     #[inline]
sample_shading_enable(mut self, sample_shading_enable: bool) -> Self6284     pub fn sample_shading_enable(mut self, sample_shading_enable: bool) -> Self {
6285         self.inner.sample_shading_enable = sample_shading_enable.into();
6286         self
6287     }
6288     #[inline]
min_sample_shading(mut self, min_sample_shading: f32) -> Self6289     pub fn min_sample_shading(mut self, min_sample_shading: f32) -> Self {
6290         self.inner.min_sample_shading = min_sample_shading;
6291         self
6292     }
6293     #[doc = r" Sets `p_sample_mask` to `null` if the slice is empty. The mask will"]
6294     #[doc = r" be treated as if it has all bits set to `1`."]
6295     #[doc = r""]
6296     #[doc = r" See <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineMultisampleStateCreateInfo.html#_description>"]
6297     #[doc = r" for more details."]
6298     #[inline]
sample_mask(mut self, sample_mask: &'a [SampleMask]) -> Self6299     pub fn sample_mask(mut self, sample_mask: &'a [SampleMask]) -> Self {
6300         self.inner.p_sample_mask = if sample_mask.is_empty() {
6301             std::ptr::null()
6302         } else {
6303             sample_mask.as_ptr()
6304         };
6305         self
6306     }
6307     #[inline]
alpha_to_coverage_enable(mut self, alpha_to_coverage_enable: bool) -> Self6308     pub fn alpha_to_coverage_enable(mut self, alpha_to_coverage_enable: bool) -> Self {
6309         self.inner.alpha_to_coverage_enable = alpha_to_coverage_enable.into();
6310         self
6311     }
6312     #[inline]
alpha_to_one_enable(mut self, alpha_to_one_enable: bool) -> Self6313     pub fn alpha_to_one_enable(mut self, alpha_to_one_enable: bool) -> Self {
6314         self.inner.alpha_to_one_enable = alpha_to_one_enable.into();
6315         self
6316     }
6317     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
6318     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
6319     #[doc = r" valid extension structs can be pushed into the chain."]
6320     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
6321     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPipelineMultisampleStateCreateInfo>( mut self, next: &'a mut T, ) -> Self6322     pub fn push_next<T: ExtendsPipelineMultisampleStateCreateInfo>(
6323         mut self,
6324         next: &'a mut T,
6325     ) -> Self {
6326         unsafe {
6327             let next_ptr = <*const T>::cast(next);
6328             let last_next = ptr_chain_iter(next).last().unwrap();
6329             (*last_next).p_next = self.inner.p_next as _;
6330             self.inner.p_next = next_ptr;
6331         }
6332         self
6333     }
6334     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6335     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6336     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineMultisampleStateCreateInfo6337     pub fn build(self) -> PipelineMultisampleStateCreateInfo {
6338         self.inner
6339     }
6340 }
6341 #[repr(C)]
6342 #[cfg_attr(feature = "debug", derive(Debug))]
6343 #[derive(Copy, Clone, Default)]
6344 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineColorBlendAttachmentState.html>"]
6345 pub struct PipelineColorBlendAttachmentState {
6346     pub blend_enable: Bool32,
6347     pub src_color_blend_factor: BlendFactor,
6348     pub dst_color_blend_factor: BlendFactor,
6349     pub color_blend_op: BlendOp,
6350     pub src_alpha_blend_factor: BlendFactor,
6351     pub dst_alpha_blend_factor: BlendFactor,
6352     pub alpha_blend_op: BlendOp,
6353     pub color_write_mask: ColorComponentFlags,
6354 }
6355 impl PipelineColorBlendAttachmentState {
builder<'a>() -> PipelineColorBlendAttachmentStateBuilder<'a>6356     pub fn builder<'a>() -> PipelineColorBlendAttachmentStateBuilder<'a> {
6357         PipelineColorBlendAttachmentStateBuilder {
6358             inner: Self::default(),
6359             marker: ::std::marker::PhantomData,
6360         }
6361     }
6362 }
6363 #[repr(transparent)]
6364 pub struct PipelineColorBlendAttachmentStateBuilder<'a> {
6365     inner: PipelineColorBlendAttachmentState,
6366     marker: ::std::marker::PhantomData<&'a ()>,
6367 }
6368 impl<'a> ::std::ops::Deref for PipelineColorBlendAttachmentStateBuilder<'a> {
6369     type Target = PipelineColorBlendAttachmentState;
deref(&self) -> &Self::Target6370     fn deref(&self) -> &Self::Target {
6371         &self.inner
6372     }
6373 }
6374 impl<'a> ::std::ops::DerefMut for PipelineColorBlendAttachmentStateBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target6375     fn deref_mut(&mut self) -> &mut Self::Target {
6376         &mut self.inner
6377     }
6378 }
6379 impl<'a> PipelineColorBlendAttachmentStateBuilder<'a> {
6380     #[inline]
blend_enable(mut self, blend_enable: bool) -> Self6381     pub fn blend_enable(mut self, blend_enable: bool) -> Self {
6382         self.inner.blend_enable = blend_enable.into();
6383         self
6384     }
6385     #[inline]
src_color_blend_factor(mut self, src_color_blend_factor: BlendFactor) -> Self6386     pub fn src_color_blend_factor(mut self, src_color_blend_factor: BlendFactor) -> Self {
6387         self.inner.src_color_blend_factor = src_color_blend_factor;
6388         self
6389     }
6390     #[inline]
dst_color_blend_factor(mut self, dst_color_blend_factor: BlendFactor) -> Self6391     pub fn dst_color_blend_factor(mut self, dst_color_blend_factor: BlendFactor) -> Self {
6392         self.inner.dst_color_blend_factor = dst_color_blend_factor;
6393         self
6394     }
6395     #[inline]
color_blend_op(mut self, color_blend_op: BlendOp) -> Self6396     pub fn color_blend_op(mut self, color_blend_op: BlendOp) -> Self {
6397         self.inner.color_blend_op = color_blend_op;
6398         self
6399     }
6400     #[inline]
src_alpha_blend_factor(mut self, src_alpha_blend_factor: BlendFactor) -> Self6401     pub fn src_alpha_blend_factor(mut self, src_alpha_blend_factor: BlendFactor) -> Self {
6402         self.inner.src_alpha_blend_factor = src_alpha_blend_factor;
6403         self
6404     }
6405     #[inline]
dst_alpha_blend_factor(mut self, dst_alpha_blend_factor: BlendFactor) -> Self6406     pub fn dst_alpha_blend_factor(mut self, dst_alpha_blend_factor: BlendFactor) -> Self {
6407         self.inner.dst_alpha_blend_factor = dst_alpha_blend_factor;
6408         self
6409     }
6410     #[inline]
alpha_blend_op(mut self, alpha_blend_op: BlendOp) -> Self6411     pub fn alpha_blend_op(mut self, alpha_blend_op: BlendOp) -> Self {
6412         self.inner.alpha_blend_op = alpha_blend_op;
6413         self
6414     }
6415     #[inline]
color_write_mask(mut self, color_write_mask: ColorComponentFlags) -> Self6416     pub fn color_write_mask(mut self, color_write_mask: ColorComponentFlags) -> Self {
6417         self.inner.color_write_mask = color_write_mask;
6418         self
6419     }
6420     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6421     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6422     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineColorBlendAttachmentState6423     pub fn build(self) -> PipelineColorBlendAttachmentState {
6424         self.inner
6425     }
6426 }
6427 #[repr(C)]
6428 #[cfg_attr(feature = "debug", derive(Debug))]
6429 #[derive(Copy, Clone)]
6430 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineColorBlendStateCreateInfo.html>"]
6431 pub struct PipelineColorBlendStateCreateInfo {
6432     pub s_type: StructureType,
6433     pub p_next: *const c_void,
6434     pub flags: PipelineColorBlendStateCreateFlags,
6435     pub logic_op_enable: Bool32,
6436     pub logic_op: LogicOp,
6437     pub attachment_count: u32,
6438     pub p_attachments: *const PipelineColorBlendAttachmentState,
6439     pub blend_constants: [f32; 4],
6440 }
6441 impl ::std::default::Default for PipelineColorBlendStateCreateInfo {
6442     #[inline]
default() -> Self6443     fn default() -> Self {
6444         Self {
6445             s_type: Self::STRUCTURE_TYPE,
6446             p_next: ::std::ptr::null(),
6447             flags: PipelineColorBlendStateCreateFlags::default(),
6448             logic_op_enable: Bool32::default(),
6449             logic_op: LogicOp::default(),
6450             attachment_count: u32::default(),
6451             p_attachments: ::std::ptr::null(),
6452             blend_constants: unsafe { ::std::mem::zeroed() },
6453         }
6454     }
6455 }
6456 unsafe impl TaggedStructure for PipelineColorBlendStateCreateInfo {
6457     const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
6458 }
6459 impl PipelineColorBlendStateCreateInfo {
builder<'a>() -> PipelineColorBlendStateCreateInfoBuilder<'a>6460     pub fn builder<'a>() -> PipelineColorBlendStateCreateInfoBuilder<'a> {
6461         PipelineColorBlendStateCreateInfoBuilder {
6462             inner: Self::default(),
6463             marker: ::std::marker::PhantomData,
6464         }
6465     }
6466 }
6467 #[repr(transparent)]
6468 pub struct PipelineColorBlendStateCreateInfoBuilder<'a> {
6469     inner: PipelineColorBlendStateCreateInfo,
6470     marker: ::std::marker::PhantomData<&'a ()>,
6471 }
6472 pub unsafe trait ExtendsPipelineColorBlendStateCreateInfo {}
6473 impl<'a> ::std::ops::Deref for PipelineColorBlendStateCreateInfoBuilder<'a> {
6474     type Target = PipelineColorBlendStateCreateInfo;
deref(&self) -> &Self::Target6475     fn deref(&self) -> &Self::Target {
6476         &self.inner
6477     }
6478 }
6479 impl<'a> ::std::ops::DerefMut for PipelineColorBlendStateCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target6480     fn deref_mut(&mut self) -> &mut Self::Target {
6481         &mut self.inner
6482     }
6483 }
6484 impl<'a> PipelineColorBlendStateCreateInfoBuilder<'a> {
6485     #[inline]
flags(mut self, flags: PipelineColorBlendStateCreateFlags) -> Self6486     pub fn flags(mut self, flags: PipelineColorBlendStateCreateFlags) -> Self {
6487         self.inner.flags = flags;
6488         self
6489     }
6490     #[inline]
logic_op_enable(mut self, logic_op_enable: bool) -> Self6491     pub fn logic_op_enable(mut self, logic_op_enable: bool) -> Self {
6492         self.inner.logic_op_enable = logic_op_enable.into();
6493         self
6494     }
6495     #[inline]
logic_op(mut self, logic_op: LogicOp) -> Self6496     pub fn logic_op(mut self, logic_op: LogicOp) -> Self {
6497         self.inner.logic_op = logic_op;
6498         self
6499     }
6500     #[inline]
attachments(mut self, attachments: &'a [PipelineColorBlendAttachmentState]) -> Self6501     pub fn attachments(mut self, attachments: &'a [PipelineColorBlendAttachmentState]) -> Self {
6502         self.inner.attachment_count = attachments.len() as _;
6503         self.inner.p_attachments = attachments.as_ptr();
6504         self
6505     }
6506     #[inline]
blend_constants(mut self, blend_constants: [f32; 4]) -> Self6507     pub fn blend_constants(mut self, blend_constants: [f32; 4]) -> Self {
6508         self.inner.blend_constants = blend_constants;
6509         self
6510     }
6511     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
6512     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
6513     #[doc = r" valid extension structs can be pushed into the chain."]
6514     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
6515     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPipelineColorBlendStateCreateInfo>( mut self, next: &'a mut T, ) -> Self6516     pub fn push_next<T: ExtendsPipelineColorBlendStateCreateInfo>(
6517         mut self,
6518         next: &'a mut T,
6519     ) -> Self {
6520         unsafe {
6521             let next_ptr = <*const T>::cast(next);
6522             let last_next = ptr_chain_iter(next).last().unwrap();
6523             (*last_next).p_next = self.inner.p_next as _;
6524             self.inner.p_next = next_ptr;
6525         }
6526         self
6527     }
6528     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6529     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6530     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineColorBlendStateCreateInfo6531     pub fn build(self) -> PipelineColorBlendStateCreateInfo {
6532         self.inner
6533     }
6534 }
6535 #[repr(C)]
6536 #[cfg_attr(feature = "debug", derive(Debug))]
6537 #[derive(Copy, Clone)]
6538 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDynamicStateCreateInfo.html>"]
6539 pub struct PipelineDynamicStateCreateInfo {
6540     pub s_type: StructureType,
6541     pub p_next: *const c_void,
6542     pub flags: PipelineDynamicStateCreateFlags,
6543     pub dynamic_state_count: u32,
6544     pub p_dynamic_states: *const DynamicState,
6545 }
6546 impl ::std::default::Default for PipelineDynamicStateCreateInfo {
6547     #[inline]
default() -> Self6548     fn default() -> Self {
6549         Self {
6550             s_type: Self::STRUCTURE_TYPE,
6551             p_next: ::std::ptr::null(),
6552             flags: PipelineDynamicStateCreateFlags::default(),
6553             dynamic_state_count: u32::default(),
6554             p_dynamic_states: ::std::ptr::null(),
6555         }
6556     }
6557 }
6558 unsafe impl TaggedStructure for PipelineDynamicStateCreateInfo {
6559     const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_DYNAMIC_STATE_CREATE_INFO;
6560 }
6561 impl PipelineDynamicStateCreateInfo {
builder<'a>() -> PipelineDynamicStateCreateInfoBuilder<'a>6562     pub fn builder<'a>() -> PipelineDynamicStateCreateInfoBuilder<'a> {
6563         PipelineDynamicStateCreateInfoBuilder {
6564             inner: Self::default(),
6565             marker: ::std::marker::PhantomData,
6566         }
6567     }
6568 }
6569 #[repr(transparent)]
6570 pub struct PipelineDynamicStateCreateInfoBuilder<'a> {
6571     inner: PipelineDynamicStateCreateInfo,
6572     marker: ::std::marker::PhantomData<&'a ()>,
6573 }
6574 impl<'a> ::std::ops::Deref for PipelineDynamicStateCreateInfoBuilder<'a> {
6575     type Target = PipelineDynamicStateCreateInfo;
deref(&self) -> &Self::Target6576     fn deref(&self) -> &Self::Target {
6577         &self.inner
6578     }
6579 }
6580 impl<'a> ::std::ops::DerefMut for PipelineDynamicStateCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target6581     fn deref_mut(&mut self) -> &mut Self::Target {
6582         &mut self.inner
6583     }
6584 }
6585 impl<'a> PipelineDynamicStateCreateInfoBuilder<'a> {
6586     #[inline]
flags(mut self, flags: PipelineDynamicStateCreateFlags) -> Self6587     pub fn flags(mut self, flags: PipelineDynamicStateCreateFlags) -> Self {
6588         self.inner.flags = flags;
6589         self
6590     }
6591     #[inline]
dynamic_states(mut self, dynamic_states: &'a [DynamicState]) -> Self6592     pub fn dynamic_states(mut self, dynamic_states: &'a [DynamicState]) -> Self {
6593         self.inner.dynamic_state_count = dynamic_states.len() as _;
6594         self.inner.p_dynamic_states = dynamic_states.as_ptr();
6595         self
6596     }
6597     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6598     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6599     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineDynamicStateCreateInfo6600     pub fn build(self) -> PipelineDynamicStateCreateInfo {
6601         self.inner
6602     }
6603 }
6604 #[repr(C)]
6605 #[cfg_attr(feature = "debug", derive(Debug))]
6606 #[derive(Copy, Clone, Default)]
6607 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkStencilOpState.html>"]
6608 pub struct StencilOpState {
6609     pub fail_op: StencilOp,
6610     pub pass_op: StencilOp,
6611     pub depth_fail_op: StencilOp,
6612     pub compare_op: CompareOp,
6613     pub compare_mask: u32,
6614     pub write_mask: u32,
6615     pub reference: u32,
6616 }
6617 impl StencilOpState {
builder<'a>() -> StencilOpStateBuilder<'a>6618     pub fn builder<'a>() -> StencilOpStateBuilder<'a> {
6619         StencilOpStateBuilder {
6620             inner: Self::default(),
6621             marker: ::std::marker::PhantomData,
6622         }
6623     }
6624 }
6625 #[repr(transparent)]
6626 pub struct StencilOpStateBuilder<'a> {
6627     inner: StencilOpState,
6628     marker: ::std::marker::PhantomData<&'a ()>,
6629 }
6630 impl<'a> ::std::ops::Deref for StencilOpStateBuilder<'a> {
6631     type Target = StencilOpState;
deref(&self) -> &Self::Target6632     fn deref(&self) -> &Self::Target {
6633         &self.inner
6634     }
6635 }
6636 impl<'a> ::std::ops::DerefMut for StencilOpStateBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target6637     fn deref_mut(&mut self) -> &mut Self::Target {
6638         &mut self.inner
6639     }
6640 }
6641 impl<'a> StencilOpStateBuilder<'a> {
6642     #[inline]
fail_op(mut self, fail_op: StencilOp) -> Self6643     pub fn fail_op(mut self, fail_op: StencilOp) -> Self {
6644         self.inner.fail_op = fail_op;
6645         self
6646     }
6647     #[inline]
pass_op(mut self, pass_op: StencilOp) -> Self6648     pub fn pass_op(mut self, pass_op: StencilOp) -> Self {
6649         self.inner.pass_op = pass_op;
6650         self
6651     }
6652     #[inline]
depth_fail_op(mut self, depth_fail_op: StencilOp) -> Self6653     pub fn depth_fail_op(mut self, depth_fail_op: StencilOp) -> Self {
6654         self.inner.depth_fail_op = depth_fail_op;
6655         self
6656     }
6657     #[inline]
compare_op(mut self, compare_op: CompareOp) -> Self6658     pub fn compare_op(mut self, compare_op: CompareOp) -> Self {
6659         self.inner.compare_op = compare_op;
6660         self
6661     }
6662     #[inline]
compare_mask(mut self, compare_mask: u32) -> Self6663     pub fn compare_mask(mut self, compare_mask: u32) -> Self {
6664         self.inner.compare_mask = compare_mask;
6665         self
6666     }
6667     #[inline]
write_mask(mut self, write_mask: u32) -> Self6668     pub fn write_mask(mut self, write_mask: u32) -> Self {
6669         self.inner.write_mask = write_mask;
6670         self
6671     }
6672     #[inline]
reference(mut self, reference: u32) -> Self6673     pub fn reference(mut self, reference: u32) -> Self {
6674         self.inner.reference = reference;
6675         self
6676     }
6677     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6678     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6679     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> StencilOpState6680     pub fn build(self) -> StencilOpState {
6681         self.inner
6682     }
6683 }
6684 #[repr(C)]
6685 #[cfg_attr(feature = "debug", derive(Debug))]
6686 #[derive(Copy, Clone)]
6687 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDepthStencilStateCreateInfo.html>"]
6688 pub struct PipelineDepthStencilStateCreateInfo {
6689     pub s_type: StructureType,
6690     pub p_next: *const c_void,
6691     pub flags: PipelineDepthStencilStateCreateFlags,
6692     pub depth_test_enable: Bool32,
6693     pub depth_write_enable: Bool32,
6694     pub depth_compare_op: CompareOp,
6695     pub depth_bounds_test_enable: Bool32,
6696     pub stencil_test_enable: Bool32,
6697     pub front: StencilOpState,
6698     pub back: StencilOpState,
6699     pub min_depth_bounds: f32,
6700     pub max_depth_bounds: f32,
6701 }
6702 impl ::std::default::Default for PipelineDepthStencilStateCreateInfo {
6703     #[inline]
default() -> Self6704     fn default() -> Self {
6705         Self {
6706             s_type: Self::STRUCTURE_TYPE,
6707             p_next: ::std::ptr::null(),
6708             flags: PipelineDepthStencilStateCreateFlags::default(),
6709             depth_test_enable: Bool32::default(),
6710             depth_write_enable: Bool32::default(),
6711             depth_compare_op: CompareOp::default(),
6712             depth_bounds_test_enable: Bool32::default(),
6713             stencil_test_enable: Bool32::default(),
6714             front: StencilOpState::default(),
6715             back: StencilOpState::default(),
6716             min_depth_bounds: f32::default(),
6717             max_depth_bounds: f32::default(),
6718         }
6719     }
6720 }
6721 unsafe impl TaggedStructure for PipelineDepthStencilStateCreateInfo {
6722     const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
6723 }
6724 impl PipelineDepthStencilStateCreateInfo {
builder<'a>() -> PipelineDepthStencilStateCreateInfoBuilder<'a>6725     pub fn builder<'a>() -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
6726         PipelineDepthStencilStateCreateInfoBuilder {
6727             inner: Self::default(),
6728             marker: ::std::marker::PhantomData,
6729         }
6730     }
6731 }
6732 #[repr(transparent)]
6733 pub struct PipelineDepthStencilStateCreateInfoBuilder<'a> {
6734     inner: PipelineDepthStencilStateCreateInfo,
6735     marker: ::std::marker::PhantomData<&'a ()>,
6736 }
6737 impl<'a> ::std::ops::Deref for PipelineDepthStencilStateCreateInfoBuilder<'a> {
6738     type Target = PipelineDepthStencilStateCreateInfo;
deref(&self) -> &Self::Target6739     fn deref(&self) -> &Self::Target {
6740         &self.inner
6741     }
6742 }
6743 impl<'a> ::std::ops::DerefMut for PipelineDepthStencilStateCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target6744     fn deref_mut(&mut self) -> &mut Self::Target {
6745         &mut self.inner
6746     }
6747 }
6748 impl<'a> PipelineDepthStencilStateCreateInfoBuilder<'a> {
6749     #[inline]
flags(mut self, flags: PipelineDepthStencilStateCreateFlags) -> Self6750     pub fn flags(mut self, flags: PipelineDepthStencilStateCreateFlags) -> Self {
6751         self.inner.flags = flags;
6752         self
6753     }
6754     #[inline]
depth_test_enable(mut self, depth_test_enable: bool) -> Self6755     pub fn depth_test_enable(mut self, depth_test_enable: bool) -> Self {
6756         self.inner.depth_test_enable = depth_test_enable.into();
6757         self
6758     }
6759     #[inline]
depth_write_enable(mut self, depth_write_enable: bool) -> Self6760     pub fn depth_write_enable(mut self, depth_write_enable: bool) -> Self {
6761         self.inner.depth_write_enable = depth_write_enable.into();
6762         self
6763     }
6764     #[inline]
depth_compare_op(mut self, depth_compare_op: CompareOp) -> Self6765     pub fn depth_compare_op(mut self, depth_compare_op: CompareOp) -> Self {
6766         self.inner.depth_compare_op = depth_compare_op;
6767         self
6768     }
6769     #[inline]
depth_bounds_test_enable(mut self, depth_bounds_test_enable: bool) -> Self6770     pub fn depth_bounds_test_enable(mut self, depth_bounds_test_enable: bool) -> Self {
6771         self.inner.depth_bounds_test_enable = depth_bounds_test_enable.into();
6772         self
6773     }
6774     #[inline]
stencil_test_enable(mut self, stencil_test_enable: bool) -> Self6775     pub fn stencil_test_enable(mut self, stencil_test_enable: bool) -> Self {
6776         self.inner.stencil_test_enable = stencil_test_enable.into();
6777         self
6778     }
6779     #[inline]
front(mut self, front: StencilOpState) -> Self6780     pub fn front(mut self, front: StencilOpState) -> Self {
6781         self.inner.front = front;
6782         self
6783     }
6784     #[inline]
back(mut self, back: StencilOpState) -> Self6785     pub fn back(mut self, back: StencilOpState) -> Self {
6786         self.inner.back = back;
6787         self
6788     }
6789     #[inline]
min_depth_bounds(mut self, min_depth_bounds: f32) -> Self6790     pub fn min_depth_bounds(mut self, min_depth_bounds: f32) -> Self {
6791         self.inner.min_depth_bounds = min_depth_bounds;
6792         self
6793     }
6794     #[inline]
max_depth_bounds(mut self, max_depth_bounds: f32) -> Self6795     pub fn max_depth_bounds(mut self, max_depth_bounds: f32) -> Self {
6796         self.inner.max_depth_bounds = max_depth_bounds;
6797         self
6798     }
6799     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6800     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6801     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineDepthStencilStateCreateInfo6802     pub fn build(self) -> PipelineDepthStencilStateCreateInfo {
6803         self.inner
6804     }
6805 }
6806 #[repr(C)]
6807 #[cfg_attr(feature = "debug", derive(Debug))]
6808 #[derive(Copy, Clone)]
6809 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGraphicsPipelineCreateInfo.html>"]
6810 pub struct GraphicsPipelineCreateInfo {
6811     pub s_type: StructureType,
6812     pub p_next: *const c_void,
6813     pub flags: PipelineCreateFlags,
6814     pub stage_count: u32,
6815     pub p_stages: *const PipelineShaderStageCreateInfo,
6816     pub p_vertex_input_state: *const PipelineVertexInputStateCreateInfo,
6817     pub p_input_assembly_state: *const PipelineInputAssemblyStateCreateInfo,
6818     pub p_tessellation_state: *const PipelineTessellationStateCreateInfo,
6819     pub p_viewport_state: *const PipelineViewportStateCreateInfo,
6820     pub p_rasterization_state: *const PipelineRasterizationStateCreateInfo,
6821     pub p_multisample_state: *const PipelineMultisampleStateCreateInfo,
6822     pub p_depth_stencil_state: *const PipelineDepthStencilStateCreateInfo,
6823     pub p_color_blend_state: *const PipelineColorBlendStateCreateInfo,
6824     pub p_dynamic_state: *const PipelineDynamicStateCreateInfo,
6825     pub layout: PipelineLayout,
6826     pub render_pass: RenderPass,
6827     pub subpass: u32,
6828     pub base_pipeline_handle: Pipeline,
6829     pub base_pipeline_index: i32,
6830 }
6831 impl ::std::default::Default for GraphicsPipelineCreateInfo {
6832     #[inline]
default() -> Self6833     fn default() -> Self {
6834         Self {
6835             s_type: Self::STRUCTURE_TYPE,
6836             p_next: ::std::ptr::null(),
6837             flags: PipelineCreateFlags::default(),
6838             stage_count: u32::default(),
6839             p_stages: ::std::ptr::null(),
6840             p_vertex_input_state: ::std::ptr::null(),
6841             p_input_assembly_state: ::std::ptr::null(),
6842             p_tessellation_state: ::std::ptr::null(),
6843             p_viewport_state: ::std::ptr::null(),
6844             p_rasterization_state: ::std::ptr::null(),
6845             p_multisample_state: ::std::ptr::null(),
6846             p_depth_stencil_state: ::std::ptr::null(),
6847             p_color_blend_state: ::std::ptr::null(),
6848             p_dynamic_state: ::std::ptr::null(),
6849             layout: PipelineLayout::default(),
6850             render_pass: RenderPass::default(),
6851             subpass: u32::default(),
6852             base_pipeline_handle: Pipeline::default(),
6853             base_pipeline_index: i32::default(),
6854         }
6855     }
6856 }
6857 unsafe impl TaggedStructure for GraphicsPipelineCreateInfo {
6858     const STRUCTURE_TYPE: StructureType = StructureType::GRAPHICS_PIPELINE_CREATE_INFO;
6859 }
6860 impl GraphicsPipelineCreateInfo {
builder<'a>() -> GraphicsPipelineCreateInfoBuilder<'a>6861     pub fn builder<'a>() -> GraphicsPipelineCreateInfoBuilder<'a> {
6862         GraphicsPipelineCreateInfoBuilder {
6863             inner: Self::default(),
6864             marker: ::std::marker::PhantomData,
6865         }
6866     }
6867 }
6868 #[repr(transparent)]
6869 pub struct GraphicsPipelineCreateInfoBuilder<'a> {
6870     inner: GraphicsPipelineCreateInfo,
6871     marker: ::std::marker::PhantomData<&'a ()>,
6872 }
6873 pub unsafe trait ExtendsGraphicsPipelineCreateInfo {}
6874 impl<'a> ::std::ops::Deref for GraphicsPipelineCreateInfoBuilder<'a> {
6875     type Target = GraphicsPipelineCreateInfo;
deref(&self) -> &Self::Target6876     fn deref(&self) -> &Self::Target {
6877         &self.inner
6878     }
6879 }
6880 impl<'a> ::std::ops::DerefMut for GraphicsPipelineCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target6881     fn deref_mut(&mut self) -> &mut Self::Target {
6882         &mut self.inner
6883     }
6884 }
6885 impl<'a> GraphicsPipelineCreateInfoBuilder<'a> {
6886     #[inline]
flags(mut self, flags: PipelineCreateFlags) -> Self6887     pub fn flags(mut self, flags: PipelineCreateFlags) -> Self {
6888         self.inner.flags = flags;
6889         self
6890     }
6891     #[inline]
stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self6892     pub fn stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self {
6893         self.inner.stage_count = stages.len() as _;
6894         self.inner.p_stages = stages.as_ptr();
6895         self
6896     }
6897     #[inline]
vertex_input_state( mut self, vertex_input_state: &'a PipelineVertexInputStateCreateInfo, ) -> Self6898     pub fn vertex_input_state(
6899         mut self,
6900         vertex_input_state: &'a PipelineVertexInputStateCreateInfo,
6901     ) -> Self {
6902         self.inner.p_vertex_input_state = vertex_input_state;
6903         self
6904     }
6905     #[inline]
input_assembly_state( mut self, input_assembly_state: &'a PipelineInputAssemblyStateCreateInfo, ) -> Self6906     pub fn input_assembly_state(
6907         mut self,
6908         input_assembly_state: &'a PipelineInputAssemblyStateCreateInfo,
6909     ) -> Self {
6910         self.inner.p_input_assembly_state = input_assembly_state;
6911         self
6912     }
6913     #[inline]
tessellation_state( mut self, tessellation_state: &'a PipelineTessellationStateCreateInfo, ) -> Self6914     pub fn tessellation_state(
6915         mut self,
6916         tessellation_state: &'a PipelineTessellationStateCreateInfo,
6917     ) -> Self {
6918         self.inner.p_tessellation_state = tessellation_state;
6919         self
6920     }
6921     #[inline]
viewport_state(mut self, viewport_state: &'a PipelineViewportStateCreateInfo) -> Self6922     pub fn viewport_state(mut self, viewport_state: &'a PipelineViewportStateCreateInfo) -> Self {
6923         self.inner.p_viewport_state = viewport_state;
6924         self
6925     }
6926     #[inline]
rasterization_state( mut self, rasterization_state: &'a PipelineRasterizationStateCreateInfo, ) -> Self6927     pub fn rasterization_state(
6928         mut self,
6929         rasterization_state: &'a PipelineRasterizationStateCreateInfo,
6930     ) -> Self {
6931         self.inner.p_rasterization_state = rasterization_state;
6932         self
6933     }
6934     #[inline]
multisample_state( mut self, multisample_state: &'a PipelineMultisampleStateCreateInfo, ) -> Self6935     pub fn multisample_state(
6936         mut self,
6937         multisample_state: &'a PipelineMultisampleStateCreateInfo,
6938     ) -> Self {
6939         self.inner.p_multisample_state = multisample_state;
6940         self
6941     }
6942     #[inline]
depth_stencil_state( mut self, depth_stencil_state: &'a PipelineDepthStencilStateCreateInfo, ) -> Self6943     pub fn depth_stencil_state(
6944         mut self,
6945         depth_stencil_state: &'a PipelineDepthStencilStateCreateInfo,
6946     ) -> Self {
6947         self.inner.p_depth_stencil_state = depth_stencil_state;
6948         self
6949     }
6950     #[inline]
color_blend_state( mut self, color_blend_state: &'a PipelineColorBlendStateCreateInfo, ) -> Self6951     pub fn color_blend_state(
6952         mut self,
6953         color_blend_state: &'a PipelineColorBlendStateCreateInfo,
6954     ) -> Self {
6955         self.inner.p_color_blend_state = color_blend_state;
6956         self
6957     }
6958     #[inline]
dynamic_state(mut self, dynamic_state: &'a PipelineDynamicStateCreateInfo) -> Self6959     pub fn dynamic_state(mut self, dynamic_state: &'a PipelineDynamicStateCreateInfo) -> Self {
6960         self.inner.p_dynamic_state = dynamic_state;
6961         self
6962     }
6963     #[inline]
layout(mut self, layout: PipelineLayout) -> Self6964     pub fn layout(mut self, layout: PipelineLayout) -> Self {
6965         self.inner.layout = layout;
6966         self
6967     }
6968     #[inline]
render_pass(mut self, render_pass: RenderPass) -> Self6969     pub fn render_pass(mut self, render_pass: RenderPass) -> Self {
6970         self.inner.render_pass = render_pass;
6971         self
6972     }
6973     #[inline]
subpass(mut self, subpass: u32) -> Self6974     pub fn subpass(mut self, subpass: u32) -> Self {
6975         self.inner.subpass = subpass;
6976         self
6977     }
6978     #[inline]
base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self6979     pub fn base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self {
6980         self.inner.base_pipeline_handle = base_pipeline_handle;
6981         self
6982     }
6983     #[inline]
base_pipeline_index(mut self, base_pipeline_index: i32) -> Self6984     pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self {
6985         self.inner.base_pipeline_index = base_pipeline_index;
6986         self
6987     }
6988     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
6989     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
6990     #[doc = r" valid extension structs can be pushed into the chain."]
6991     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
6992     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsGraphicsPipelineCreateInfo>(mut self, next: &'a mut T) -> Self6993     pub fn push_next<T: ExtendsGraphicsPipelineCreateInfo>(mut self, next: &'a mut T) -> Self {
6994         unsafe {
6995             let next_ptr = <*const T>::cast(next);
6996             let last_next = ptr_chain_iter(next).last().unwrap();
6997             (*last_next).p_next = self.inner.p_next as _;
6998             self.inner.p_next = next_ptr;
6999         }
7000         self
7001     }
7002     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7003     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7004     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> GraphicsPipelineCreateInfo7005     pub fn build(self) -> GraphicsPipelineCreateInfo {
7006         self.inner
7007     }
7008 }
7009 #[repr(C)]
7010 #[cfg_attr(feature = "debug", derive(Debug))]
7011 #[derive(Copy, Clone)]
7012 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCacheCreateInfo.html>"]
7013 pub struct PipelineCacheCreateInfo {
7014     pub s_type: StructureType,
7015     pub p_next: *const c_void,
7016     pub flags: PipelineCacheCreateFlags,
7017     pub initial_data_size: usize,
7018     pub p_initial_data: *const c_void,
7019 }
7020 impl ::std::default::Default for PipelineCacheCreateInfo {
7021     #[inline]
default() -> Self7022     fn default() -> Self {
7023         Self {
7024             s_type: Self::STRUCTURE_TYPE,
7025             p_next: ::std::ptr::null(),
7026             flags: PipelineCacheCreateFlags::default(),
7027             initial_data_size: usize::default(),
7028             p_initial_data: ::std::ptr::null(),
7029         }
7030     }
7031 }
7032 unsafe impl TaggedStructure for PipelineCacheCreateInfo {
7033     const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_CACHE_CREATE_INFO;
7034 }
7035 impl PipelineCacheCreateInfo {
builder<'a>() -> PipelineCacheCreateInfoBuilder<'a>7036     pub fn builder<'a>() -> PipelineCacheCreateInfoBuilder<'a> {
7037         PipelineCacheCreateInfoBuilder {
7038             inner: Self::default(),
7039             marker: ::std::marker::PhantomData,
7040         }
7041     }
7042 }
7043 #[repr(transparent)]
7044 pub struct PipelineCacheCreateInfoBuilder<'a> {
7045     inner: PipelineCacheCreateInfo,
7046     marker: ::std::marker::PhantomData<&'a ()>,
7047 }
7048 impl<'a> ::std::ops::Deref for PipelineCacheCreateInfoBuilder<'a> {
7049     type Target = PipelineCacheCreateInfo;
deref(&self) -> &Self::Target7050     fn deref(&self) -> &Self::Target {
7051         &self.inner
7052     }
7053 }
7054 impl<'a> ::std::ops::DerefMut for PipelineCacheCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target7055     fn deref_mut(&mut self) -> &mut Self::Target {
7056         &mut self.inner
7057     }
7058 }
7059 impl<'a> PipelineCacheCreateInfoBuilder<'a> {
7060     #[inline]
flags(mut self, flags: PipelineCacheCreateFlags) -> Self7061     pub fn flags(mut self, flags: PipelineCacheCreateFlags) -> Self {
7062         self.inner.flags = flags;
7063         self
7064     }
7065     #[inline]
initial_data(mut self, initial_data: &'a [u8]) -> Self7066     pub fn initial_data(mut self, initial_data: &'a [u8]) -> Self {
7067         self.inner.initial_data_size = initial_data.len();
7068         self.inner.p_initial_data = initial_data.as_ptr().cast();
7069         self
7070     }
7071     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7072     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7073     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineCacheCreateInfo7074     pub fn build(self) -> PipelineCacheCreateInfo {
7075         self.inner
7076     }
7077 }
7078 #[repr(C)]
7079 #[cfg_attr(feature = "debug", derive(Debug))]
7080 #[derive(Copy, Clone)]
7081 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCacheHeaderVersionOne.html>"]
7082 pub struct PipelineCacheHeaderVersionOne {
7083     pub header_size: u32,
7084     pub header_version: PipelineCacheHeaderVersion,
7085     pub vendor_id: u32,
7086     pub device_id: u32,
7087     pub pipeline_cache_uuid: [u8; UUID_SIZE],
7088 }
7089 impl ::std::default::Default for PipelineCacheHeaderVersionOne {
7090     #[inline]
default() -> Self7091     fn default() -> Self {
7092         Self {
7093             header_size: u32::default(),
7094             header_version: PipelineCacheHeaderVersion::default(),
7095             vendor_id: u32::default(),
7096             device_id: u32::default(),
7097             pipeline_cache_uuid: unsafe { ::std::mem::zeroed() },
7098         }
7099     }
7100 }
7101 impl PipelineCacheHeaderVersionOne {
builder<'a>() -> PipelineCacheHeaderVersionOneBuilder<'a>7102     pub fn builder<'a>() -> PipelineCacheHeaderVersionOneBuilder<'a> {
7103         PipelineCacheHeaderVersionOneBuilder {
7104             inner: Self::default(),
7105             marker: ::std::marker::PhantomData,
7106         }
7107     }
7108 }
7109 #[repr(transparent)]
7110 pub struct PipelineCacheHeaderVersionOneBuilder<'a> {
7111     inner: PipelineCacheHeaderVersionOne,
7112     marker: ::std::marker::PhantomData<&'a ()>,
7113 }
7114 impl<'a> ::std::ops::Deref for PipelineCacheHeaderVersionOneBuilder<'a> {
7115     type Target = PipelineCacheHeaderVersionOne;
deref(&self) -> &Self::Target7116     fn deref(&self) -> &Self::Target {
7117         &self.inner
7118     }
7119 }
7120 impl<'a> ::std::ops::DerefMut for PipelineCacheHeaderVersionOneBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target7121     fn deref_mut(&mut self) -> &mut Self::Target {
7122         &mut self.inner
7123     }
7124 }
7125 impl<'a> PipelineCacheHeaderVersionOneBuilder<'a> {
7126     #[inline]
header_size(mut self, header_size: u32) -> Self7127     pub fn header_size(mut self, header_size: u32) -> Self {
7128         self.inner.header_size = header_size;
7129         self
7130     }
7131     #[inline]
header_version(mut self, header_version: PipelineCacheHeaderVersion) -> Self7132     pub fn header_version(mut self, header_version: PipelineCacheHeaderVersion) -> Self {
7133         self.inner.header_version = header_version;
7134         self
7135     }
7136     #[inline]
vendor_id(mut self, vendor_id: u32) -> Self7137     pub fn vendor_id(mut self, vendor_id: u32) -> Self {
7138         self.inner.vendor_id = vendor_id;
7139         self
7140     }
7141     #[inline]
device_id(mut self, device_id: u32) -> Self7142     pub fn device_id(mut self, device_id: u32) -> Self {
7143         self.inner.device_id = device_id;
7144         self
7145     }
7146     #[inline]
pipeline_cache_uuid(mut self, pipeline_cache_uuid: [u8; UUID_SIZE]) -> Self7147     pub fn pipeline_cache_uuid(mut self, pipeline_cache_uuid: [u8; UUID_SIZE]) -> Self {
7148         self.inner.pipeline_cache_uuid = pipeline_cache_uuid;
7149         self
7150     }
7151     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7152     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7153     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineCacheHeaderVersionOne7154     pub fn build(self) -> PipelineCacheHeaderVersionOne {
7155         self.inner
7156     }
7157 }
7158 #[repr(C)]
7159 #[cfg_attr(feature = "debug", derive(Debug))]
7160 #[derive(Copy, Clone, Default)]
7161 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPushConstantRange.html>"]
7162 pub struct PushConstantRange {
7163     pub stage_flags: ShaderStageFlags,
7164     pub offset: u32,
7165     pub size: u32,
7166 }
7167 impl PushConstantRange {
builder<'a>() -> PushConstantRangeBuilder<'a>7168     pub fn builder<'a>() -> PushConstantRangeBuilder<'a> {
7169         PushConstantRangeBuilder {
7170             inner: Self::default(),
7171             marker: ::std::marker::PhantomData,
7172         }
7173     }
7174 }
7175 #[repr(transparent)]
7176 pub struct PushConstantRangeBuilder<'a> {
7177     inner: PushConstantRange,
7178     marker: ::std::marker::PhantomData<&'a ()>,
7179 }
7180 impl<'a> ::std::ops::Deref for PushConstantRangeBuilder<'a> {
7181     type Target = PushConstantRange;
deref(&self) -> &Self::Target7182     fn deref(&self) -> &Self::Target {
7183         &self.inner
7184     }
7185 }
7186 impl<'a> ::std::ops::DerefMut for PushConstantRangeBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target7187     fn deref_mut(&mut self) -> &mut Self::Target {
7188         &mut self.inner
7189     }
7190 }
7191 impl<'a> PushConstantRangeBuilder<'a> {
7192     #[inline]
stage_flags(mut self, stage_flags: ShaderStageFlags) -> Self7193     pub fn stage_flags(mut self, stage_flags: ShaderStageFlags) -> Self {
7194         self.inner.stage_flags = stage_flags;
7195         self
7196     }
7197     #[inline]
offset(mut self, offset: u32) -> Self7198     pub fn offset(mut self, offset: u32) -> Self {
7199         self.inner.offset = offset;
7200         self
7201     }
7202     #[inline]
size(mut self, size: u32) -> Self7203     pub fn size(mut self, size: u32) -> Self {
7204         self.inner.size = size;
7205         self
7206     }
7207     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7208     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7209     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PushConstantRange7210     pub fn build(self) -> PushConstantRange {
7211         self.inner
7212     }
7213 }
7214 #[repr(C)]
7215 #[cfg_attr(feature = "debug", derive(Debug))]
7216 #[derive(Copy, Clone)]
7217 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineLayoutCreateInfo.html>"]
7218 pub struct PipelineLayoutCreateInfo {
7219     pub s_type: StructureType,
7220     pub p_next: *const c_void,
7221     pub flags: PipelineLayoutCreateFlags,
7222     pub set_layout_count: u32,
7223     pub p_set_layouts: *const DescriptorSetLayout,
7224     pub push_constant_range_count: u32,
7225     pub p_push_constant_ranges: *const PushConstantRange,
7226 }
7227 impl ::std::default::Default for PipelineLayoutCreateInfo {
7228     #[inline]
default() -> Self7229     fn default() -> Self {
7230         Self {
7231             s_type: Self::STRUCTURE_TYPE,
7232             p_next: ::std::ptr::null(),
7233             flags: PipelineLayoutCreateFlags::default(),
7234             set_layout_count: u32::default(),
7235             p_set_layouts: ::std::ptr::null(),
7236             push_constant_range_count: u32::default(),
7237             p_push_constant_ranges: ::std::ptr::null(),
7238         }
7239     }
7240 }
7241 unsafe impl TaggedStructure for PipelineLayoutCreateInfo {
7242     const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_LAYOUT_CREATE_INFO;
7243 }
7244 impl PipelineLayoutCreateInfo {
builder<'a>() -> PipelineLayoutCreateInfoBuilder<'a>7245     pub fn builder<'a>() -> PipelineLayoutCreateInfoBuilder<'a> {
7246         PipelineLayoutCreateInfoBuilder {
7247             inner: Self::default(),
7248             marker: ::std::marker::PhantomData,
7249         }
7250     }
7251 }
7252 #[repr(transparent)]
7253 pub struct PipelineLayoutCreateInfoBuilder<'a> {
7254     inner: PipelineLayoutCreateInfo,
7255     marker: ::std::marker::PhantomData<&'a ()>,
7256 }
7257 impl<'a> ::std::ops::Deref for PipelineLayoutCreateInfoBuilder<'a> {
7258     type Target = PipelineLayoutCreateInfo;
deref(&self) -> &Self::Target7259     fn deref(&self) -> &Self::Target {
7260         &self.inner
7261     }
7262 }
7263 impl<'a> ::std::ops::DerefMut for PipelineLayoutCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target7264     fn deref_mut(&mut self) -> &mut Self::Target {
7265         &mut self.inner
7266     }
7267 }
7268 impl<'a> PipelineLayoutCreateInfoBuilder<'a> {
7269     #[inline]
flags(mut self, flags: PipelineLayoutCreateFlags) -> Self7270     pub fn flags(mut self, flags: PipelineLayoutCreateFlags) -> Self {
7271         self.inner.flags = flags;
7272         self
7273     }
7274     #[inline]
set_layouts(mut self, set_layouts: &'a [DescriptorSetLayout]) -> Self7275     pub fn set_layouts(mut self, set_layouts: &'a [DescriptorSetLayout]) -> Self {
7276         self.inner.set_layout_count = set_layouts.len() as _;
7277         self.inner.p_set_layouts = set_layouts.as_ptr();
7278         self
7279     }
7280     #[inline]
push_constant_ranges(mut self, push_constant_ranges: &'a [PushConstantRange]) -> Self7281     pub fn push_constant_ranges(mut self, push_constant_ranges: &'a [PushConstantRange]) -> Self {
7282         self.inner.push_constant_range_count = push_constant_ranges.len() as _;
7283         self.inner.p_push_constant_ranges = push_constant_ranges.as_ptr();
7284         self
7285     }
7286     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7287     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7288     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineLayoutCreateInfo7289     pub fn build(self) -> PipelineLayoutCreateInfo {
7290         self.inner
7291     }
7292 }
7293 #[repr(C)]
7294 #[cfg_attr(feature = "debug", derive(Debug))]
7295 #[derive(Copy, Clone)]
7296 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerCreateInfo.html>"]
7297 pub struct SamplerCreateInfo {
7298     pub s_type: StructureType,
7299     pub p_next: *const c_void,
7300     pub flags: SamplerCreateFlags,
7301     pub mag_filter: Filter,
7302     pub min_filter: Filter,
7303     pub mipmap_mode: SamplerMipmapMode,
7304     pub address_mode_u: SamplerAddressMode,
7305     pub address_mode_v: SamplerAddressMode,
7306     pub address_mode_w: SamplerAddressMode,
7307     pub mip_lod_bias: f32,
7308     pub anisotropy_enable: Bool32,
7309     pub max_anisotropy: f32,
7310     pub compare_enable: Bool32,
7311     pub compare_op: CompareOp,
7312     pub min_lod: f32,
7313     pub max_lod: f32,
7314     pub border_color: BorderColor,
7315     pub unnormalized_coordinates: Bool32,
7316 }
7317 impl ::std::default::Default for SamplerCreateInfo {
7318     #[inline]
default() -> Self7319     fn default() -> Self {
7320         Self {
7321             s_type: Self::STRUCTURE_TYPE,
7322             p_next: ::std::ptr::null(),
7323             flags: SamplerCreateFlags::default(),
7324             mag_filter: Filter::default(),
7325             min_filter: Filter::default(),
7326             mipmap_mode: SamplerMipmapMode::default(),
7327             address_mode_u: SamplerAddressMode::default(),
7328             address_mode_v: SamplerAddressMode::default(),
7329             address_mode_w: SamplerAddressMode::default(),
7330             mip_lod_bias: f32::default(),
7331             anisotropy_enable: Bool32::default(),
7332             max_anisotropy: f32::default(),
7333             compare_enable: Bool32::default(),
7334             compare_op: CompareOp::default(),
7335             min_lod: f32::default(),
7336             max_lod: f32::default(),
7337             border_color: BorderColor::default(),
7338             unnormalized_coordinates: Bool32::default(),
7339         }
7340     }
7341 }
7342 unsafe impl TaggedStructure for SamplerCreateInfo {
7343     const STRUCTURE_TYPE: StructureType = StructureType::SAMPLER_CREATE_INFO;
7344 }
7345 impl SamplerCreateInfo {
builder<'a>() -> SamplerCreateInfoBuilder<'a>7346     pub fn builder<'a>() -> SamplerCreateInfoBuilder<'a> {
7347         SamplerCreateInfoBuilder {
7348             inner: Self::default(),
7349             marker: ::std::marker::PhantomData,
7350         }
7351     }
7352 }
7353 #[repr(transparent)]
7354 pub struct SamplerCreateInfoBuilder<'a> {
7355     inner: SamplerCreateInfo,
7356     marker: ::std::marker::PhantomData<&'a ()>,
7357 }
7358 pub unsafe trait ExtendsSamplerCreateInfo {}
7359 impl<'a> ::std::ops::Deref for SamplerCreateInfoBuilder<'a> {
7360     type Target = SamplerCreateInfo;
deref(&self) -> &Self::Target7361     fn deref(&self) -> &Self::Target {
7362         &self.inner
7363     }
7364 }
7365 impl<'a> ::std::ops::DerefMut for SamplerCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target7366     fn deref_mut(&mut self) -> &mut Self::Target {
7367         &mut self.inner
7368     }
7369 }
7370 impl<'a> SamplerCreateInfoBuilder<'a> {
7371     #[inline]
flags(mut self, flags: SamplerCreateFlags) -> Self7372     pub fn flags(mut self, flags: SamplerCreateFlags) -> Self {
7373         self.inner.flags = flags;
7374         self
7375     }
7376     #[inline]
mag_filter(mut self, mag_filter: Filter) -> Self7377     pub fn mag_filter(mut self, mag_filter: Filter) -> Self {
7378         self.inner.mag_filter = mag_filter;
7379         self
7380     }
7381     #[inline]
min_filter(mut self, min_filter: Filter) -> Self7382     pub fn min_filter(mut self, min_filter: Filter) -> Self {
7383         self.inner.min_filter = min_filter;
7384         self
7385     }
7386     #[inline]
mipmap_mode(mut self, mipmap_mode: SamplerMipmapMode) -> Self7387     pub fn mipmap_mode(mut self, mipmap_mode: SamplerMipmapMode) -> Self {
7388         self.inner.mipmap_mode = mipmap_mode;
7389         self
7390     }
7391     #[inline]
address_mode_u(mut self, address_mode_u: SamplerAddressMode) -> Self7392     pub fn address_mode_u(mut self, address_mode_u: SamplerAddressMode) -> Self {
7393         self.inner.address_mode_u = address_mode_u;
7394         self
7395     }
7396     #[inline]
address_mode_v(mut self, address_mode_v: SamplerAddressMode) -> Self7397     pub fn address_mode_v(mut self, address_mode_v: SamplerAddressMode) -> Self {
7398         self.inner.address_mode_v = address_mode_v;
7399         self
7400     }
7401     #[inline]
address_mode_w(mut self, address_mode_w: SamplerAddressMode) -> Self7402     pub fn address_mode_w(mut self, address_mode_w: SamplerAddressMode) -> Self {
7403         self.inner.address_mode_w = address_mode_w;
7404         self
7405     }
7406     #[inline]
mip_lod_bias(mut self, mip_lod_bias: f32) -> Self7407     pub fn mip_lod_bias(mut self, mip_lod_bias: f32) -> Self {
7408         self.inner.mip_lod_bias = mip_lod_bias;
7409         self
7410     }
7411     #[inline]
anisotropy_enable(mut self, anisotropy_enable: bool) -> Self7412     pub fn anisotropy_enable(mut self, anisotropy_enable: bool) -> Self {
7413         self.inner.anisotropy_enable = anisotropy_enable.into();
7414         self
7415     }
7416     #[inline]
max_anisotropy(mut self, max_anisotropy: f32) -> Self7417     pub fn max_anisotropy(mut self, max_anisotropy: f32) -> Self {
7418         self.inner.max_anisotropy = max_anisotropy;
7419         self
7420     }
7421     #[inline]
compare_enable(mut self, compare_enable: bool) -> Self7422     pub fn compare_enable(mut self, compare_enable: bool) -> Self {
7423         self.inner.compare_enable = compare_enable.into();
7424         self
7425     }
7426     #[inline]
compare_op(mut self, compare_op: CompareOp) -> Self7427     pub fn compare_op(mut self, compare_op: CompareOp) -> Self {
7428         self.inner.compare_op = compare_op;
7429         self
7430     }
7431     #[inline]
min_lod(mut self, min_lod: f32) -> Self7432     pub fn min_lod(mut self, min_lod: f32) -> Self {
7433         self.inner.min_lod = min_lod;
7434         self
7435     }
7436     #[inline]
max_lod(mut self, max_lod: f32) -> Self7437     pub fn max_lod(mut self, max_lod: f32) -> Self {
7438         self.inner.max_lod = max_lod;
7439         self
7440     }
7441     #[inline]
border_color(mut self, border_color: BorderColor) -> Self7442     pub fn border_color(mut self, border_color: BorderColor) -> Self {
7443         self.inner.border_color = border_color;
7444         self
7445     }
7446     #[inline]
unnormalized_coordinates(mut self, unnormalized_coordinates: bool) -> Self7447     pub fn unnormalized_coordinates(mut self, unnormalized_coordinates: bool) -> Self {
7448         self.inner.unnormalized_coordinates = unnormalized_coordinates.into();
7449         self
7450     }
7451     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
7452     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
7453     #[doc = r" valid extension structs can be pushed into the chain."]
7454     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
7455     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSamplerCreateInfo>(mut self, next: &'a mut T) -> Self7456     pub fn push_next<T: ExtendsSamplerCreateInfo>(mut self, next: &'a mut T) -> Self {
7457         unsafe {
7458             let next_ptr = <*const T>::cast(next);
7459             let last_next = ptr_chain_iter(next).last().unwrap();
7460             (*last_next).p_next = self.inner.p_next as _;
7461             self.inner.p_next = next_ptr;
7462         }
7463         self
7464     }
7465     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7466     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7467     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SamplerCreateInfo7468     pub fn build(self) -> SamplerCreateInfo {
7469         self.inner
7470     }
7471 }
7472 #[repr(C)]
7473 #[cfg_attr(feature = "debug", derive(Debug))]
7474 #[derive(Copy, Clone)]
7475 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandPoolCreateInfo.html>"]
7476 pub struct CommandPoolCreateInfo {
7477     pub s_type: StructureType,
7478     pub p_next: *const c_void,
7479     pub flags: CommandPoolCreateFlags,
7480     pub queue_family_index: u32,
7481 }
7482 impl ::std::default::Default for CommandPoolCreateInfo {
7483     #[inline]
default() -> Self7484     fn default() -> Self {
7485         Self {
7486             s_type: Self::STRUCTURE_TYPE,
7487             p_next: ::std::ptr::null(),
7488             flags: CommandPoolCreateFlags::default(),
7489             queue_family_index: u32::default(),
7490         }
7491     }
7492 }
7493 unsafe impl TaggedStructure for CommandPoolCreateInfo {
7494     const STRUCTURE_TYPE: StructureType = StructureType::COMMAND_POOL_CREATE_INFO;
7495 }
7496 impl CommandPoolCreateInfo {
builder<'a>() -> CommandPoolCreateInfoBuilder<'a>7497     pub fn builder<'a>() -> CommandPoolCreateInfoBuilder<'a> {
7498         CommandPoolCreateInfoBuilder {
7499             inner: Self::default(),
7500             marker: ::std::marker::PhantomData,
7501         }
7502     }
7503 }
7504 #[repr(transparent)]
7505 pub struct CommandPoolCreateInfoBuilder<'a> {
7506     inner: CommandPoolCreateInfo,
7507     marker: ::std::marker::PhantomData<&'a ()>,
7508 }
7509 impl<'a> ::std::ops::Deref for CommandPoolCreateInfoBuilder<'a> {
7510     type Target = CommandPoolCreateInfo;
deref(&self) -> &Self::Target7511     fn deref(&self) -> &Self::Target {
7512         &self.inner
7513     }
7514 }
7515 impl<'a> ::std::ops::DerefMut for CommandPoolCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target7516     fn deref_mut(&mut self) -> &mut Self::Target {
7517         &mut self.inner
7518     }
7519 }
7520 impl<'a> CommandPoolCreateInfoBuilder<'a> {
7521     #[inline]
flags(mut self, flags: CommandPoolCreateFlags) -> Self7522     pub fn flags(mut self, flags: CommandPoolCreateFlags) -> Self {
7523         self.inner.flags = flags;
7524         self
7525     }
7526     #[inline]
queue_family_index(mut self, queue_family_index: u32) -> Self7527     pub fn queue_family_index(mut self, queue_family_index: u32) -> Self {
7528         self.inner.queue_family_index = queue_family_index;
7529         self
7530     }
7531     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7532     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7533     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CommandPoolCreateInfo7534     pub fn build(self) -> CommandPoolCreateInfo {
7535         self.inner
7536     }
7537 }
7538 #[repr(C)]
7539 #[cfg_attr(feature = "debug", derive(Debug))]
7540 #[derive(Copy, Clone)]
7541 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferAllocateInfo.html>"]
7542 pub struct CommandBufferAllocateInfo {
7543     pub s_type: StructureType,
7544     pub p_next: *const c_void,
7545     pub command_pool: CommandPool,
7546     pub level: CommandBufferLevel,
7547     pub command_buffer_count: u32,
7548 }
7549 impl ::std::default::Default for CommandBufferAllocateInfo {
7550     #[inline]
default() -> Self7551     fn default() -> Self {
7552         Self {
7553             s_type: Self::STRUCTURE_TYPE,
7554             p_next: ::std::ptr::null(),
7555             command_pool: CommandPool::default(),
7556             level: CommandBufferLevel::default(),
7557             command_buffer_count: u32::default(),
7558         }
7559     }
7560 }
7561 unsafe impl TaggedStructure for CommandBufferAllocateInfo {
7562     const STRUCTURE_TYPE: StructureType = StructureType::COMMAND_BUFFER_ALLOCATE_INFO;
7563 }
7564 impl CommandBufferAllocateInfo {
builder<'a>() -> CommandBufferAllocateInfoBuilder<'a>7565     pub fn builder<'a>() -> CommandBufferAllocateInfoBuilder<'a> {
7566         CommandBufferAllocateInfoBuilder {
7567             inner: Self::default(),
7568             marker: ::std::marker::PhantomData,
7569         }
7570     }
7571 }
7572 #[repr(transparent)]
7573 pub struct CommandBufferAllocateInfoBuilder<'a> {
7574     inner: CommandBufferAllocateInfo,
7575     marker: ::std::marker::PhantomData<&'a ()>,
7576 }
7577 impl<'a> ::std::ops::Deref for CommandBufferAllocateInfoBuilder<'a> {
7578     type Target = CommandBufferAllocateInfo;
deref(&self) -> &Self::Target7579     fn deref(&self) -> &Self::Target {
7580         &self.inner
7581     }
7582 }
7583 impl<'a> ::std::ops::DerefMut for CommandBufferAllocateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target7584     fn deref_mut(&mut self) -> &mut Self::Target {
7585         &mut self.inner
7586     }
7587 }
7588 impl<'a> CommandBufferAllocateInfoBuilder<'a> {
7589     #[inline]
command_pool(mut self, command_pool: CommandPool) -> Self7590     pub fn command_pool(mut self, command_pool: CommandPool) -> Self {
7591         self.inner.command_pool = command_pool;
7592         self
7593     }
7594     #[inline]
level(mut self, level: CommandBufferLevel) -> Self7595     pub fn level(mut self, level: CommandBufferLevel) -> Self {
7596         self.inner.level = level;
7597         self
7598     }
7599     #[inline]
command_buffer_count(mut self, command_buffer_count: u32) -> Self7600     pub fn command_buffer_count(mut self, command_buffer_count: u32) -> Self {
7601         self.inner.command_buffer_count = command_buffer_count;
7602         self
7603     }
7604     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7605     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7606     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CommandBufferAllocateInfo7607     pub fn build(self) -> CommandBufferAllocateInfo {
7608         self.inner
7609     }
7610 }
7611 #[repr(C)]
7612 #[cfg_attr(feature = "debug", derive(Debug))]
7613 #[derive(Copy, Clone)]
7614 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferInheritanceInfo.html>"]
7615 pub struct CommandBufferInheritanceInfo {
7616     pub s_type: StructureType,
7617     pub p_next: *const c_void,
7618     pub render_pass: RenderPass,
7619     pub subpass: u32,
7620     pub framebuffer: Framebuffer,
7621     pub occlusion_query_enable: Bool32,
7622     pub query_flags: QueryControlFlags,
7623     pub pipeline_statistics: QueryPipelineStatisticFlags,
7624 }
7625 impl ::std::default::Default for CommandBufferInheritanceInfo {
7626     #[inline]
default() -> Self7627     fn default() -> Self {
7628         Self {
7629             s_type: Self::STRUCTURE_TYPE,
7630             p_next: ::std::ptr::null(),
7631             render_pass: RenderPass::default(),
7632             subpass: u32::default(),
7633             framebuffer: Framebuffer::default(),
7634             occlusion_query_enable: Bool32::default(),
7635             query_flags: QueryControlFlags::default(),
7636             pipeline_statistics: QueryPipelineStatisticFlags::default(),
7637         }
7638     }
7639 }
7640 unsafe impl TaggedStructure for CommandBufferInheritanceInfo {
7641     const STRUCTURE_TYPE: StructureType = StructureType::COMMAND_BUFFER_INHERITANCE_INFO;
7642 }
7643 impl CommandBufferInheritanceInfo {
builder<'a>() -> CommandBufferInheritanceInfoBuilder<'a>7644     pub fn builder<'a>() -> CommandBufferInheritanceInfoBuilder<'a> {
7645         CommandBufferInheritanceInfoBuilder {
7646             inner: Self::default(),
7647             marker: ::std::marker::PhantomData,
7648         }
7649     }
7650 }
7651 #[repr(transparent)]
7652 pub struct CommandBufferInheritanceInfoBuilder<'a> {
7653     inner: CommandBufferInheritanceInfo,
7654     marker: ::std::marker::PhantomData<&'a ()>,
7655 }
7656 pub unsafe trait ExtendsCommandBufferInheritanceInfo {}
7657 impl<'a> ::std::ops::Deref for CommandBufferInheritanceInfoBuilder<'a> {
7658     type Target = CommandBufferInheritanceInfo;
deref(&self) -> &Self::Target7659     fn deref(&self) -> &Self::Target {
7660         &self.inner
7661     }
7662 }
7663 impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target7664     fn deref_mut(&mut self) -> &mut Self::Target {
7665         &mut self.inner
7666     }
7667 }
7668 impl<'a> CommandBufferInheritanceInfoBuilder<'a> {
7669     #[inline]
render_pass(mut self, render_pass: RenderPass) -> Self7670     pub fn render_pass(mut self, render_pass: RenderPass) -> Self {
7671         self.inner.render_pass = render_pass;
7672         self
7673     }
7674     #[inline]
subpass(mut self, subpass: u32) -> Self7675     pub fn subpass(mut self, subpass: u32) -> Self {
7676         self.inner.subpass = subpass;
7677         self
7678     }
7679     #[inline]
framebuffer(mut self, framebuffer: Framebuffer) -> Self7680     pub fn framebuffer(mut self, framebuffer: Framebuffer) -> Self {
7681         self.inner.framebuffer = framebuffer;
7682         self
7683     }
7684     #[inline]
occlusion_query_enable(mut self, occlusion_query_enable: bool) -> Self7685     pub fn occlusion_query_enable(mut self, occlusion_query_enable: bool) -> Self {
7686         self.inner.occlusion_query_enable = occlusion_query_enable.into();
7687         self
7688     }
7689     #[inline]
query_flags(mut self, query_flags: QueryControlFlags) -> Self7690     pub fn query_flags(mut self, query_flags: QueryControlFlags) -> Self {
7691         self.inner.query_flags = query_flags;
7692         self
7693     }
7694     #[inline]
pipeline_statistics(mut self, pipeline_statistics: QueryPipelineStatisticFlags) -> Self7695     pub fn pipeline_statistics(mut self, pipeline_statistics: QueryPipelineStatisticFlags) -> Self {
7696         self.inner.pipeline_statistics = pipeline_statistics;
7697         self
7698     }
7699     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
7700     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
7701     #[doc = r" valid extension structs can be pushed into the chain."]
7702     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
7703     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsCommandBufferInheritanceInfo>(mut self, next: &'a mut T) -> Self7704     pub fn push_next<T: ExtendsCommandBufferInheritanceInfo>(mut self, next: &'a mut T) -> Self {
7705         unsafe {
7706             let next_ptr = <*const T>::cast(next);
7707             let last_next = ptr_chain_iter(next).last().unwrap();
7708             (*last_next).p_next = self.inner.p_next as _;
7709             self.inner.p_next = next_ptr;
7710         }
7711         self
7712     }
7713     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7714     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7715     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CommandBufferInheritanceInfo7716     pub fn build(self) -> CommandBufferInheritanceInfo {
7717         self.inner
7718     }
7719 }
7720 #[repr(C)]
7721 #[cfg_attr(feature = "debug", derive(Debug))]
7722 #[derive(Copy, Clone)]
7723 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferBeginInfo.html>"]
7724 pub struct CommandBufferBeginInfo {
7725     pub s_type: StructureType,
7726     pub p_next: *const c_void,
7727     pub flags: CommandBufferUsageFlags,
7728     pub p_inheritance_info: *const CommandBufferInheritanceInfo,
7729 }
7730 impl ::std::default::Default for CommandBufferBeginInfo {
7731     #[inline]
default() -> Self7732     fn default() -> Self {
7733         Self {
7734             s_type: Self::STRUCTURE_TYPE,
7735             p_next: ::std::ptr::null(),
7736             flags: CommandBufferUsageFlags::default(),
7737             p_inheritance_info: ::std::ptr::null(),
7738         }
7739     }
7740 }
7741 unsafe impl TaggedStructure for CommandBufferBeginInfo {
7742     const STRUCTURE_TYPE: StructureType = StructureType::COMMAND_BUFFER_BEGIN_INFO;
7743 }
7744 impl CommandBufferBeginInfo {
builder<'a>() -> CommandBufferBeginInfoBuilder<'a>7745     pub fn builder<'a>() -> CommandBufferBeginInfoBuilder<'a> {
7746         CommandBufferBeginInfoBuilder {
7747             inner: Self::default(),
7748             marker: ::std::marker::PhantomData,
7749         }
7750     }
7751 }
7752 #[repr(transparent)]
7753 pub struct CommandBufferBeginInfoBuilder<'a> {
7754     inner: CommandBufferBeginInfo,
7755     marker: ::std::marker::PhantomData<&'a ()>,
7756 }
7757 pub unsafe trait ExtendsCommandBufferBeginInfo {}
7758 impl<'a> ::std::ops::Deref for CommandBufferBeginInfoBuilder<'a> {
7759     type Target = CommandBufferBeginInfo;
deref(&self) -> &Self::Target7760     fn deref(&self) -> &Self::Target {
7761         &self.inner
7762     }
7763 }
7764 impl<'a> ::std::ops::DerefMut for CommandBufferBeginInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target7765     fn deref_mut(&mut self) -> &mut Self::Target {
7766         &mut self.inner
7767     }
7768 }
7769 impl<'a> CommandBufferBeginInfoBuilder<'a> {
7770     #[inline]
flags(mut self, flags: CommandBufferUsageFlags) -> Self7771     pub fn flags(mut self, flags: CommandBufferUsageFlags) -> Self {
7772         self.inner.flags = flags;
7773         self
7774     }
7775     #[inline]
inheritance_info(mut self, inheritance_info: &'a CommandBufferInheritanceInfo) -> Self7776     pub fn inheritance_info(mut self, inheritance_info: &'a CommandBufferInheritanceInfo) -> Self {
7777         self.inner.p_inheritance_info = inheritance_info;
7778         self
7779     }
7780     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
7781     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
7782     #[doc = r" valid extension structs can be pushed into the chain."]
7783     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
7784     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsCommandBufferBeginInfo>(mut self, next: &'a mut T) -> Self7785     pub fn push_next<T: ExtendsCommandBufferBeginInfo>(mut self, next: &'a mut T) -> Self {
7786         unsafe {
7787             let next_ptr = <*const T>::cast(next);
7788             let last_next = ptr_chain_iter(next).last().unwrap();
7789             (*last_next).p_next = self.inner.p_next as _;
7790             self.inner.p_next = next_ptr;
7791         }
7792         self
7793     }
7794     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7795     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7796     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CommandBufferBeginInfo7797     pub fn build(self) -> CommandBufferBeginInfo {
7798         self.inner
7799     }
7800 }
7801 #[repr(C)]
7802 #[derive(Copy, Clone)]
7803 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassBeginInfo.html>"]
7804 pub struct RenderPassBeginInfo {
7805     pub s_type: StructureType,
7806     pub p_next: *const c_void,
7807     pub render_pass: RenderPass,
7808     pub framebuffer: Framebuffer,
7809     pub render_area: Rect2D,
7810     pub clear_value_count: u32,
7811     pub p_clear_values: *const ClearValue,
7812 }
7813 #[cfg(feature = "debug")]
7814 impl fmt::Debug for RenderPassBeginInfo {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result7815     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
7816         fmt.debug_struct("RenderPassBeginInfo")
7817             .field("s_type", &self.s_type)
7818             .field("p_next", &self.p_next)
7819             .field("render_pass", &self.render_pass)
7820             .field("framebuffer", &self.framebuffer)
7821             .field("render_area", &self.render_area)
7822             .field("clear_value_count", &self.clear_value_count)
7823             .field("p_clear_values", &"union")
7824             .finish()
7825     }
7826 }
7827 impl ::std::default::Default for RenderPassBeginInfo {
7828     #[inline]
default() -> Self7829     fn default() -> Self {
7830         Self {
7831             s_type: Self::STRUCTURE_TYPE,
7832             p_next: ::std::ptr::null(),
7833             render_pass: RenderPass::default(),
7834             framebuffer: Framebuffer::default(),
7835             render_area: Rect2D::default(),
7836             clear_value_count: u32::default(),
7837             p_clear_values: ::std::ptr::null(),
7838         }
7839     }
7840 }
7841 unsafe impl TaggedStructure for RenderPassBeginInfo {
7842     const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_BEGIN_INFO;
7843 }
7844 impl RenderPassBeginInfo {
builder<'a>() -> RenderPassBeginInfoBuilder<'a>7845     pub fn builder<'a>() -> RenderPassBeginInfoBuilder<'a> {
7846         RenderPassBeginInfoBuilder {
7847             inner: Self::default(),
7848             marker: ::std::marker::PhantomData,
7849         }
7850     }
7851 }
7852 #[repr(transparent)]
7853 pub struct RenderPassBeginInfoBuilder<'a> {
7854     inner: RenderPassBeginInfo,
7855     marker: ::std::marker::PhantomData<&'a ()>,
7856 }
7857 pub unsafe trait ExtendsRenderPassBeginInfo {}
7858 impl<'a> ::std::ops::Deref for RenderPassBeginInfoBuilder<'a> {
7859     type Target = RenderPassBeginInfo;
deref(&self) -> &Self::Target7860     fn deref(&self) -> &Self::Target {
7861         &self.inner
7862     }
7863 }
7864 impl<'a> ::std::ops::DerefMut for RenderPassBeginInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target7865     fn deref_mut(&mut self) -> &mut Self::Target {
7866         &mut self.inner
7867     }
7868 }
7869 impl<'a> RenderPassBeginInfoBuilder<'a> {
7870     #[inline]
render_pass(mut self, render_pass: RenderPass) -> Self7871     pub fn render_pass(mut self, render_pass: RenderPass) -> Self {
7872         self.inner.render_pass = render_pass;
7873         self
7874     }
7875     #[inline]
framebuffer(mut self, framebuffer: Framebuffer) -> Self7876     pub fn framebuffer(mut self, framebuffer: Framebuffer) -> Self {
7877         self.inner.framebuffer = framebuffer;
7878         self
7879     }
7880     #[inline]
render_area(mut self, render_area: Rect2D) -> Self7881     pub fn render_area(mut self, render_area: Rect2D) -> Self {
7882         self.inner.render_area = render_area;
7883         self
7884     }
7885     #[inline]
clear_values(mut self, clear_values: &'a [ClearValue]) -> Self7886     pub fn clear_values(mut self, clear_values: &'a [ClearValue]) -> Self {
7887         self.inner.clear_value_count = clear_values.len() as _;
7888         self.inner.p_clear_values = clear_values.as_ptr();
7889         self
7890     }
7891     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
7892     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
7893     #[doc = r" valid extension structs can be pushed into the chain."]
7894     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
7895     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsRenderPassBeginInfo>(mut self, next: &'a mut T) -> Self7896     pub fn push_next<T: ExtendsRenderPassBeginInfo>(mut self, next: &'a mut T) -> Self {
7897         unsafe {
7898             let next_ptr = <*const T>::cast(next);
7899             let last_next = ptr_chain_iter(next).last().unwrap();
7900             (*last_next).p_next = self.inner.p_next as _;
7901             self.inner.p_next = next_ptr;
7902         }
7903         self
7904     }
7905     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7906     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7907     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RenderPassBeginInfo7908     pub fn build(self) -> RenderPassBeginInfo {
7909         self.inner
7910     }
7911 }
7912 #[repr(C)]
7913 #[derive(Copy, Clone)]
7914 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkClearColorValue.html>"]
7915 pub union ClearColorValue {
7916     pub float32: [f32; 4],
7917     pub int32: [i32; 4],
7918     pub uint32: [u32; 4],
7919 }
7920 impl ::std::default::Default for ClearColorValue {
7921     #[inline]
default() -> Self7922     fn default() -> Self {
7923         unsafe { ::std::mem::zeroed() }
7924     }
7925 }
7926 #[repr(C)]
7927 #[cfg_attr(feature = "debug", derive(Debug))]
7928 #[derive(Copy, Clone, Default)]
7929 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkClearDepthStencilValue.html>"]
7930 pub struct ClearDepthStencilValue {
7931     pub depth: f32,
7932     pub stencil: u32,
7933 }
7934 impl ClearDepthStencilValue {
builder<'a>() -> ClearDepthStencilValueBuilder<'a>7935     pub fn builder<'a>() -> ClearDepthStencilValueBuilder<'a> {
7936         ClearDepthStencilValueBuilder {
7937             inner: Self::default(),
7938             marker: ::std::marker::PhantomData,
7939         }
7940     }
7941 }
7942 #[repr(transparent)]
7943 pub struct ClearDepthStencilValueBuilder<'a> {
7944     inner: ClearDepthStencilValue,
7945     marker: ::std::marker::PhantomData<&'a ()>,
7946 }
7947 impl<'a> ::std::ops::Deref for ClearDepthStencilValueBuilder<'a> {
7948     type Target = ClearDepthStencilValue;
deref(&self) -> &Self::Target7949     fn deref(&self) -> &Self::Target {
7950         &self.inner
7951     }
7952 }
7953 impl<'a> ::std::ops::DerefMut for ClearDepthStencilValueBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target7954     fn deref_mut(&mut self) -> &mut Self::Target {
7955         &mut self.inner
7956     }
7957 }
7958 impl<'a> ClearDepthStencilValueBuilder<'a> {
7959     #[inline]
depth(mut self, depth: f32) -> Self7960     pub fn depth(mut self, depth: f32) -> Self {
7961         self.inner.depth = depth;
7962         self
7963     }
7964     #[inline]
stencil(mut self, stencil: u32) -> Self7965     pub fn stencil(mut self, stencil: u32) -> Self {
7966         self.inner.stencil = stencil;
7967         self
7968     }
7969     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7970     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7971     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ClearDepthStencilValue7972     pub fn build(self) -> ClearDepthStencilValue {
7973         self.inner
7974     }
7975 }
7976 #[repr(C)]
7977 #[derive(Copy, Clone)]
7978 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkClearValue.html>"]
7979 pub union ClearValue {
7980     pub color: ClearColorValue,
7981     pub depth_stencil: ClearDepthStencilValue,
7982 }
7983 impl ::std::default::Default for ClearValue {
7984     #[inline]
default() -> Self7985     fn default() -> Self {
7986         unsafe { ::std::mem::zeroed() }
7987     }
7988 }
7989 #[repr(C)]
7990 #[derive(Copy, Clone, Default)]
7991 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkClearAttachment.html>"]
7992 pub struct ClearAttachment {
7993     pub aspect_mask: ImageAspectFlags,
7994     pub color_attachment: u32,
7995     pub clear_value: ClearValue,
7996 }
7997 #[cfg(feature = "debug")]
7998 impl fmt::Debug for ClearAttachment {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result7999     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
8000         fmt.debug_struct("ClearAttachment")
8001             .field("aspect_mask", &self.aspect_mask)
8002             .field("color_attachment", &self.color_attachment)
8003             .field("clear_value", &"union")
8004             .finish()
8005     }
8006 }
8007 impl ClearAttachment {
builder<'a>() -> ClearAttachmentBuilder<'a>8008     pub fn builder<'a>() -> ClearAttachmentBuilder<'a> {
8009         ClearAttachmentBuilder {
8010             inner: Self::default(),
8011             marker: ::std::marker::PhantomData,
8012         }
8013     }
8014 }
8015 #[repr(transparent)]
8016 pub struct ClearAttachmentBuilder<'a> {
8017     inner: ClearAttachment,
8018     marker: ::std::marker::PhantomData<&'a ()>,
8019 }
8020 impl<'a> ::std::ops::Deref for ClearAttachmentBuilder<'a> {
8021     type Target = ClearAttachment;
deref(&self) -> &Self::Target8022     fn deref(&self) -> &Self::Target {
8023         &self.inner
8024     }
8025 }
8026 impl<'a> ::std::ops::DerefMut for ClearAttachmentBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target8027     fn deref_mut(&mut self) -> &mut Self::Target {
8028         &mut self.inner
8029     }
8030 }
8031 impl<'a> ClearAttachmentBuilder<'a> {
8032     #[inline]
aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self8033     pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self {
8034         self.inner.aspect_mask = aspect_mask;
8035         self
8036     }
8037     #[inline]
color_attachment(mut self, color_attachment: u32) -> Self8038     pub fn color_attachment(mut self, color_attachment: u32) -> Self {
8039         self.inner.color_attachment = color_attachment;
8040         self
8041     }
8042     #[inline]
clear_value(mut self, clear_value: ClearValue) -> Self8043     pub fn clear_value(mut self, clear_value: ClearValue) -> Self {
8044         self.inner.clear_value = clear_value;
8045         self
8046     }
8047     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
8048     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
8049     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ClearAttachment8050     pub fn build(self) -> ClearAttachment {
8051         self.inner
8052     }
8053 }
8054 #[repr(C)]
8055 #[cfg_attr(feature = "debug", derive(Debug))]
8056 #[derive(Copy, Clone, Default)]
8057 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentDescription.html>"]
8058 pub struct AttachmentDescription {
8059     pub flags: AttachmentDescriptionFlags,
8060     pub format: Format,
8061     pub samples: SampleCountFlags,
8062     pub load_op: AttachmentLoadOp,
8063     pub store_op: AttachmentStoreOp,
8064     pub stencil_load_op: AttachmentLoadOp,
8065     pub stencil_store_op: AttachmentStoreOp,
8066     pub initial_layout: ImageLayout,
8067     pub final_layout: ImageLayout,
8068 }
8069 impl AttachmentDescription {
builder<'a>() -> AttachmentDescriptionBuilder<'a>8070     pub fn builder<'a>() -> AttachmentDescriptionBuilder<'a> {
8071         AttachmentDescriptionBuilder {
8072             inner: Self::default(),
8073             marker: ::std::marker::PhantomData,
8074         }
8075     }
8076 }
8077 #[repr(transparent)]
8078 pub struct AttachmentDescriptionBuilder<'a> {
8079     inner: AttachmentDescription,
8080     marker: ::std::marker::PhantomData<&'a ()>,
8081 }
8082 impl<'a> ::std::ops::Deref for AttachmentDescriptionBuilder<'a> {
8083     type Target = AttachmentDescription;
deref(&self) -> &Self::Target8084     fn deref(&self) -> &Self::Target {
8085         &self.inner
8086     }
8087 }
8088 impl<'a> ::std::ops::DerefMut for AttachmentDescriptionBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target8089     fn deref_mut(&mut self) -> &mut Self::Target {
8090         &mut self.inner
8091     }
8092 }
8093 impl<'a> AttachmentDescriptionBuilder<'a> {
8094     #[inline]
flags(mut self, flags: AttachmentDescriptionFlags) -> Self8095     pub fn flags(mut self, flags: AttachmentDescriptionFlags) -> Self {
8096         self.inner.flags = flags;
8097         self
8098     }
8099     #[inline]
format(mut self, format: Format) -> Self8100     pub fn format(mut self, format: Format) -> Self {
8101         self.inner.format = format;
8102         self
8103     }
8104     #[inline]
samples(mut self, samples: SampleCountFlags) -> Self8105     pub fn samples(mut self, samples: SampleCountFlags) -> Self {
8106         self.inner.samples = samples;
8107         self
8108     }
8109     #[inline]
load_op(mut self, load_op: AttachmentLoadOp) -> Self8110     pub fn load_op(mut self, load_op: AttachmentLoadOp) -> Self {
8111         self.inner.load_op = load_op;
8112         self
8113     }
8114     #[inline]
store_op(mut self, store_op: AttachmentStoreOp) -> Self8115     pub fn store_op(mut self, store_op: AttachmentStoreOp) -> Self {
8116         self.inner.store_op = store_op;
8117         self
8118     }
8119     #[inline]
stencil_load_op(mut self, stencil_load_op: AttachmentLoadOp) -> Self8120     pub fn stencil_load_op(mut self, stencil_load_op: AttachmentLoadOp) -> Self {
8121         self.inner.stencil_load_op = stencil_load_op;
8122         self
8123     }
8124     #[inline]
stencil_store_op(mut self, stencil_store_op: AttachmentStoreOp) -> Self8125     pub fn stencil_store_op(mut self, stencil_store_op: AttachmentStoreOp) -> Self {
8126         self.inner.stencil_store_op = stencil_store_op;
8127         self
8128     }
8129     #[inline]
initial_layout(mut self, initial_layout: ImageLayout) -> Self8130     pub fn initial_layout(mut self, initial_layout: ImageLayout) -> Self {
8131         self.inner.initial_layout = initial_layout;
8132         self
8133     }
8134     #[inline]
final_layout(mut self, final_layout: ImageLayout) -> Self8135     pub fn final_layout(mut self, final_layout: ImageLayout) -> Self {
8136         self.inner.final_layout = final_layout;
8137         self
8138     }
8139     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
8140     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
8141     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AttachmentDescription8142     pub fn build(self) -> AttachmentDescription {
8143         self.inner
8144     }
8145 }
8146 #[repr(C)]
8147 #[cfg_attr(feature = "debug", derive(Debug))]
8148 #[derive(Copy, Clone, Default)]
8149 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentReference.html>"]
8150 pub struct AttachmentReference {
8151     pub attachment: u32,
8152     pub layout: ImageLayout,
8153 }
8154 impl AttachmentReference {
builder<'a>() -> AttachmentReferenceBuilder<'a>8155     pub fn builder<'a>() -> AttachmentReferenceBuilder<'a> {
8156         AttachmentReferenceBuilder {
8157             inner: Self::default(),
8158             marker: ::std::marker::PhantomData,
8159         }
8160     }
8161 }
8162 #[repr(transparent)]
8163 pub struct AttachmentReferenceBuilder<'a> {
8164     inner: AttachmentReference,
8165     marker: ::std::marker::PhantomData<&'a ()>,
8166 }
8167 impl<'a> ::std::ops::Deref for AttachmentReferenceBuilder<'a> {
8168     type Target = AttachmentReference;
deref(&self) -> &Self::Target8169     fn deref(&self) -> &Self::Target {
8170         &self.inner
8171     }
8172 }
8173 impl<'a> ::std::ops::DerefMut for AttachmentReferenceBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target8174     fn deref_mut(&mut self) -> &mut Self::Target {
8175         &mut self.inner
8176     }
8177 }
8178 impl<'a> AttachmentReferenceBuilder<'a> {
8179     #[inline]
attachment(mut self, attachment: u32) -> Self8180     pub fn attachment(mut self, attachment: u32) -> Self {
8181         self.inner.attachment = attachment;
8182         self
8183     }
8184     #[inline]
layout(mut self, layout: ImageLayout) -> Self8185     pub fn layout(mut self, layout: ImageLayout) -> Self {
8186         self.inner.layout = layout;
8187         self
8188     }
8189     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
8190     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
8191     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AttachmentReference8192     pub fn build(self) -> AttachmentReference {
8193         self.inner
8194     }
8195 }
8196 #[repr(C)]
8197 #[cfg_attr(feature = "debug", derive(Debug))]
8198 #[derive(Copy, Clone)]
8199 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDescription.html>"]
8200 pub struct SubpassDescription {
8201     pub flags: SubpassDescriptionFlags,
8202     pub pipeline_bind_point: PipelineBindPoint,
8203     pub input_attachment_count: u32,
8204     pub p_input_attachments: *const AttachmentReference,
8205     pub color_attachment_count: u32,
8206     pub p_color_attachments: *const AttachmentReference,
8207     pub p_resolve_attachments: *const AttachmentReference,
8208     pub p_depth_stencil_attachment: *const AttachmentReference,
8209     pub preserve_attachment_count: u32,
8210     pub p_preserve_attachments: *const u32,
8211 }
8212 impl ::std::default::Default for SubpassDescription {
8213     #[inline]
default() -> Self8214     fn default() -> Self {
8215         Self {
8216             flags: SubpassDescriptionFlags::default(),
8217             pipeline_bind_point: PipelineBindPoint::default(),
8218             input_attachment_count: u32::default(),
8219             p_input_attachments: ::std::ptr::null(),
8220             color_attachment_count: u32::default(),
8221             p_color_attachments: ::std::ptr::null(),
8222             p_resolve_attachments: ::std::ptr::null(),
8223             p_depth_stencil_attachment: ::std::ptr::null(),
8224             preserve_attachment_count: u32::default(),
8225             p_preserve_attachments: ::std::ptr::null(),
8226         }
8227     }
8228 }
8229 impl SubpassDescription {
builder<'a>() -> SubpassDescriptionBuilder<'a>8230     pub fn builder<'a>() -> SubpassDescriptionBuilder<'a> {
8231         SubpassDescriptionBuilder {
8232             inner: Self::default(),
8233             marker: ::std::marker::PhantomData,
8234         }
8235     }
8236 }
8237 #[repr(transparent)]
8238 pub struct SubpassDescriptionBuilder<'a> {
8239     inner: SubpassDescription,
8240     marker: ::std::marker::PhantomData<&'a ()>,
8241 }
8242 impl<'a> ::std::ops::Deref for SubpassDescriptionBuilder<'a> {
8243     type Target = SubpassDescription;
deref(&self) -> &Self::Target8244     fn deref(&self) -> &Self::Target {
8245         &self.inner
8246     }
8247 }
8248 impl<'a> ::std::ops::DerefMut for SubpassDescriptionBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target8249     fn deref_mut(&mut self) -> &mut Self::Target {
8250         &mut self.inner
8251     }
8252 }
8253 impl<'a> SubpassDescriptionBuilder<'a> {
8254     #[inline]
flags(mut self, flags: SubpassDescriptionFlags) -> Self8255     pub fn flags(mut self, flags: SubpassDescriptionFlags) -> Self {
8256         self.inner.flags = flags;
8257         self
8258     }
8259     #[inline]
pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self8260     pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self {
8261         self.inner.pipeline_bind_point = pipeline_bind_point;
8262         self
8263     }
8264     #[inline]
input_attachments(mut self, input_attachments: &'a [AttachmentReference]) -> Self8265     pub fn input_attachments(mut self, input_attachments: &'a [AttachmentReference]) -> Self {
8266         self.inner.input_attachment_count = input_attachments.len() as _;
8267         self.inner.p_input_attachments = input_attachments.as_ptr();
8268         self
8269     }
8270     #[inline]
color_attachments(mut self, color_attachments: &'a [AttachmentReference]) -> Self8271     pub fn color_attachments(mut self, color_attachments: &'a [AttachmentReference]) -> Self {
8272         self.inner.color_attachment_count = color_attachments.len() as _;
8273         self.inner.p_color_attachments = color_attachments.as_ptr();
8274         self
8275     }
8276     #[inline]
resolve_attachments(mut self, resolve_attachments: &'a [AttachmentReference]) -> Self8277     pub fn resolve_attachments(mut self, resolve_attachments: &'a [AttachmentReference]) -> Self {
8278         self.inner.color_attachment_count = resolve_attachments.len() as _;
8279         self.inner.p_resolve_attachments = resolve_attachments.as_ptr();
8280         self
8281     }
8282     #[inline]
depth_stencil_attachment( mut self, depth_stencil_attachment: &'a AttachmentReference, ) -> Self8283     pub fn depth_stencil_attachment(
8284         mut self,
8285         depth_stencil_attachment: &'a AttachmentReference,
8286     ) -> Self {
8287         self.inner.p_depth_stencil_attachment = depth_stencil_attachment;
8288         self
8289     }
8290     #[inline]
preserve_attachments(mut self, preserve_attachments: &'a [u32]) -> Self8291     pub fn preserve_attachments(mut self, preserve_attachments: &'a [u32]) -> Self {
8292         self.inner.preserve_attachment_count = preserve_attachments.len() as _;
8293         self.inner.p_preserve_attachments = preserve_attachments.as_ptr();
8294         self
8295     }
8296     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
8297     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
8298     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SubpassDescription8299     pub fn build(self) -> SubpassDescription {
8300         self.inner
8301     }
8302 }
8303 #[repr(C)]
8304 #[cfg_attr(feature = "debug", derive(Debug))]
8305 #[derive(Copy, Clone, Default)]
8306 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDependency.html>"]
8307 pub struct SubpassDependency {
8308     pub src_subpass: u32,
8309     pub dst_subpass: u32,
8310     pub src_stage_mask: PipelineStageFlags,
8311     pub dst_stage_mask: PipelineStageFlags,
8312     pub src_access_mask: AccessFlags,
8313     pub dst_access_mask: AccessFlags,
8314     pub dependency_flags: DependencyFlags,
8315 }
8316 impl SubpassDependency {
builder<'a>() -> SubpassDependencyBuilder<'a>8317     pub fn builder<'a>() -> SubpassDependencyBuilder<'a> {
8318         SubpassDependencyBuilder {
8319             inner: Self::default(),
8320             marker: ::std::marker::PhantomData,
8321         }
8322     }
8323 }
8324 #[repr(transparent)]
8325 pub struct SubpassDependencyBuilder<'a> {
8326     inner: SubpassDependency,
8327     marker: ::std::marker::PhantomData<&'a ()>,
8328 }
8329 impl<'a> ::std::ops::Deref for SubpassDependencyBuilder<'a> {
8330     type Target = SubpassDependency;
deref(&self) -> &Self::Target8331     fn deref(&self) -> &Self::Target {
8332         &self.inner
8333     }
8334 }
8335 impl<'a> ::std::ops::DerefMut for SubpassDependencyBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target8336     fn deref_mut(&mut self) -> &mut Self::Target {
8337         &mut self.inner
8338     }
8339 }
8340 impl<'a> SubpassDependencyBuilder<'a> {
8341     #[inline]
src_subpass(mut self, src_subpass: u32) -> Self8342     pub fn src_subpass(mut self, src_subpass: u32) -> Self {
8343         self.inner.src_subpass = src_subpass;
8344         self
8345     }
8346     #[inline]
dst_subpass(mut self, dst_subpass: u32) -> Self8347     pub fn dst_subpass(mut self, dst_subpass: u32) -> Self {
8348         self.inner.dst_subpass = dst_subpass;
8349         self
8350     }
8351     #[inline]
src_stage_mask(mut self, src_stage_mask: PipelineStageFlags) -> Self8352     pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags) -> Self {
8353         self.inner.src_stage_mask = src_stage_mask;
8354         self
8355     }
8356     #[inline]
dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags) -> Self8357     pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags) -> Self {
8358         self.inner.dst_stage_mask = dst_stage_mask;
8359         self
8360     }
8361     #[inline]
src_access_mask(mut self, src_access_mask: AccessFlags) -> Self8362     pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self {
8363         self.inner.src_access_mask = src_access_mask;
8364         self
8365     }
8366     #[inline]
dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self8367     pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self {
8368         self.inner.dst_access_mask = dst_access_mask;
8369         self
8370     }
8371     #[inline]
dependency_flags(mut self, dependency_flags: DependencyFlags) -> Self8372     pub fn dependency_flags(mut self, dependency_flags: DependencyFlags) -> Self {
8373         self.inner.dependency_flags = dependency_flags;
8374         self
8375     }
8376     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
8377     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
8378     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SubpassDependency8379     pub fn build(self) -> SubpassDependency {
8380         self.inner
8381     }
8382 }
8383 #[repr(C)]
8384 #[cfg_attr(feature = "debug", derive(Debug))]
8385 #[derive(Copy, Clone)]
8386 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassCreateInfo.html>"]
8387 pub struct RenderPassCreateInfo {
8388     pub s_type: StructureType,
8389     pub p_next: *const c_void,
8390     pub flags: RenderPassCreateFlags,
8391     pub attachment_count: u32,
8392     pub p_attachments: *const AttachmentDescription,
8393     pub subpass_count: u32,
8394     pub p_subpasses: *const SubpassDescription,
8395     pub dependency_count: u32,
8396     pub p_dependencies: *const SubpassDependency,
8397 }
8398 impl ::std::default::Default for RenderPassCreateInfo {
8399     #[inline]
default() -> Self8400     fn default() -> Self {
8401         Self {
8402             s_type: Self::STRUCTURE_TYPE,
8403             p_next: ::std::ptr::null(),
8404             flags: RenderPassCreateFlags::default(),
8405             attachment_count: u32::default(),
8406             p_attachments: ::std::ptr::null(),
8407             subpass_count: u32::default(),
8408             p_subpasses: ::std::ptr::null(),
8409             dependency_count: u32::default(),
8410             p_dependencies: ::std::ptr::null(),
8411         }
8412     }
8413 }
8414 unsafe impl TaggedStructure for RenderPassCreateInfo {
8415     const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_CREATE_INFO;
8416 }
8417 impl RenderPassCreateInfo {
builder<'a>() -> RenderPassCreateInfoBuilder<'a>8418     pub fn builder<'a>() -> RenderPassCreateInfoBuilder<'a> {
8419         RenderPassCreateInfoBuilder {
8420             inner: Self::default(),
8421             marker: ::std::marker::PhantomData,
8422         }
8423     }
8424 }
8425 #[repr(transparent)]
8426 pub struct RenderPassCreateInfoBuilder<'a> {
8427     inner: RenderPassCreateInfo,
8428     marker: ::std::marker::PhantomData<&'a ()>,
8429 }
8430 pub unsafe trait ExtendsRenderPassCreateInfo {}
8431 impl<'a> ::std::ops::Deref for RenderPassCreateInfoBuilder<'a> {
8432     type Target = RenderPassCreateInfo;
deref(&self) -> &Self::Target8433     fn deref(&self) -> &Self::Target {
8434         &self.inner
8435     }
8436 }
8437 impl<'a> ::std::ops::DerefMut for RenderPassCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target8438     fn deref_mut(&mut self) -> &mut Self::Target {
8439         &mut self.inner
8440     }
8441 }
8442 impl<'a> RenderPassCreateInfoBuilder<'a> {
8443     #[inline]
flags(mut self, flags: RenderPassCreateFlags) -> Self8444     pub fn flags(mut self, flags: RenderPassCreateFlags) -> Self {
8445         self.inner.flags = flags;
8446         self
8447     }
8448     #[inline]
attachments(mut self, attachments: &'a [AttachmentDescription]) -> Self8449     pub fn attachments(mut self, attachments: &'a [AttachmentDescription]) -> Self {
8450         self.inner.attachment_count = attachments.len() as _;
8451         self.inner.p_attachments = attachments.as_ptr();
8452         self
8453     }
8454     #[inline]
subpasses(mut self, subpasses: &'a [SubpassDescription]) -> Self8455     pub fn subpasses(mut self, subpasses: &'a [SubpassDescription]) -> Self {
8456         self.inner.subpass_count = subpasses.len() as _;
8457         self.inner.p_subpasses = subpasses.as_ptr();
8458         self
8459     }
8460     #[inline]
dependencies(mut self, dependencies: &'a [SubpassDependency]) -> Self8461     pub fn dependencies(mut self, dependencies: &'a [SubpassDependency]) -> Self {
8462         self.inner.dependency_count = dependencies.len() as _;
8463         self.inner.p_dependencies = dependencies.as_ptr();
8464         self
8465     }
8466     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
8467     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
8468     #[doc = r" valid extension structs can be pushed into the chain."]
8469     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
8470     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsRenderPassCreateInfo>(mut self, next: &'a mut T) -> Self8471     pub fn push_next<T: ExtendsRenderPassCreateInfo>(mut self, next: &'a mut T) -> Self {
8472         unsafe {
8473             let next_ptr = <*const T>::cast(next);
8474             let last_next = ptr_chain_iter(next).last().unwrap();
8475             (*last_next).p_next = self.inner.p_next as _;
8476             self.inner.p_next = next_ptr;
8477         }
8478         self
8479     }
8480     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
8481     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
8482     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RenderPassCreateInfo8483     pub fn build(self) -> RenderPassCreateInfo {
8484         self.inner
8485     }
8486 }
8487 #[repr(C)]
8488 #[cfg_attr(feature = "debug", derive(Debug))]
8489 #[derive(Copy, Clone)]
8490 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkEventCreateInfo.html>"]
8491 pub struct EventCreateInfo {
8492     pub s_type: StructureType,
8493     pub p_next: *const c_void,
8494     pub flags: EventCreateFlags,
8495 }
8496 impl ::std::default::Default for EventCreateInfo {
8497     #[inline]
default() -> Self8498     fn default() -> Self {
8499         Self {
8500             s_type: Self::STRUCTURE_TYPE,
8501             p_next: ::std::ptr::null(),
8502             flags: EventCreateFlags::default(),
8503         }
8504     }
8505 }
8506 unsafe impl TaggedStructure for EventCreateInfo {
8507     const STRUCTURE_TYPE: StructureType = StructureType::EVENT_CREATE_INFO;
8508 }
8509 impl EventCreateInfo {
builder<'a>() -> EventCreateInfoBuilder<'a>8510     pub fn builder<'a>() -> EventCreateInfoBuilder<'a> {
8511         EventCreateInfoBuilder {
8512             inner: Self::default(),
8513             marker: ::std::marker::PhantomData,
8514         }
8515     }
8516 }
8517 #[repr(transparent)]
8518 pub struct EventCreateInfoBuilder<'a> {
8519     inner: EventCreateInfo,
8520     marker: ::std::marker::PhantomData<&'a ()>,
8521 }
8522 pub unsafe trait ExtendsEventCreateInfo {}
8523 impl<'a> ::std::ops::Deref for EventCreateInfoBuilder<'a> {
8524     type Target = EventCreateInfo;
deref(&self) -> &Self::Target8525     fn deref(&self) -> &Self::Target {
8526         &self.inner
8527     }
8528 }
8529 impl<'a> ::std::ops::DerefMut for EventCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target8530     fn deref_mut(&mut self) -> &mut Self::Target {
8531         &mut self.inner
8532     }
8533 }
8534 impl<'a> EventCreateInfoBuilder<'a> {
8535     #[inline]
flags(mut self, flags: EventCreateFlags) -> Self8536     pub fn flags(mut self, flags: EventCreateFlags) -> Self {
8537         self.inner.flags = flags;
8538         self
8539     }
8540     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
8541     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
8542     #[doc = r" valid extension structs can be pushed into the chain."]
8543     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
8544     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsEventCreateInfo>(mut self, next: &'a mut T) -> Self8545     pub fn push_next<T: ExtendsEventCreateInfo>(mut self, next: &'a mut T) -> Self {
8546         unsafe {
8547             let next_ptr = <*const T>::cast(next);
8548             let last_next = ptr_chain_iter(next).last().unwrap();
8549             (*last_next).p_next = self.inner.p_next as _;
8550             self.inner.p_next = next_ptr;
8551         }
8552         self
8553     }
8554     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
8555     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
8556     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> EventCreateInfo8557     pub fn build(self) -> EventCreateInfo {
8558         self.inner
8559     }
8560 }
8561 #[repr(C)]
8562 #[cfg_attr(feature = "debug", derive(Debug))]
8563 #[derive(Copy, Clone)]
8564 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFenceCreateInfo.html>"]
8565 pub struct FenceCreateInfo {
8566     pub s_type: StructureType,
8567     pub p_next: *const c_void,
8568     pub flags: FenceCreateFlags,
8569 }
8570 impl ::std::default::Default for FenceCreateInfo {
8571     #[inline]
default() -> Self8572     fn default() -> Self {
8573         Self {
8574             s_type: Self::STRUCTURE_TYPE,
8575             p_next: ::std::ptr::null(),
8576             flags: FenceCreateFlags::default(),
8577         }
8578     }
8579 }
8580 unsafe impl TaggedStructure for FenceCreateInfo {
8581     const STRUCTURE_TYPE: StructureType = StructureType::FENCE_CREATE_INFO;
8582 }
8583 impl FenceCreateInfo {
builder<'a>() -> FenceCreateInfoBuilder<'a>8584     pub fn builder<'a>() -> FenceCreateInfoBuilder<'a> {
8585         FenceCreateInfoBuilder {
8586             inner: Self::default(),
8587             marker: ::std::marker::PhantomData,
8588         }
8589     }
8590 }
8591 #[repr(transparent)]
8592 pub struct FenceCreateInfoBuilder<'a> {
8593     inner: FenceCreateInfo,
8594     marker: ::std::marker::PhantomData<&'a ()>,
8595 }
8596 pub unsafe trait ExtendsFenceCreateInfo {}
8597 impl<'a> ::std::ops::Deref for FenceCreateInfoBuilder<'a> {
8598     type Target = FenceCreateInfo;
deref(&self) -> &Self::Target8599     fn deref(&self) -> &Self::Target {
8600         &self.inner
8601     }
8602 }
8603 impl<'a> ::std::ops::DerefMut for FenceCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target8604     fn deref_mut(&mut self) -> &mut Self::Target {
8605         &mut self.inner
8606     }
8607 }
8608 impl<'a> FenceCreateInfoBuilder<'a> {
8609     #[inline]
flags(mut self, flags: FenceCreateFlags) -> Self8610     pub fn flags(mut self, flags: FenceCreateFlags) -> Self {
8611         self.inner.flags = flags;
8612         self
8613     }
8614     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
8615     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
8616     #[doc = r" valid extension structs can be pushed into the chain."]
8617     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
8618     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsFenceCreateInfo>(mut self, next: &'a mut T) -> Self8619     pub fn push_next<T: ExtendsFenceCreateInfo>(mut self, next: &'a mut T) -> Self {
8620         unsafe {
8621             let next_ptr = <*const T>::cast(next);
8622             let last_next = ptr_chain_iter(next).last().unwrap();
8623             (*last_next).p_next = self.inner.p_next as _;
8624             self.inner.p_next = next_ptr;
8625         }
8626         self
8627     }
8628     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
8629     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
8630     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> FenceCreateInfo8631     pub fn build(self) -> FenceCreateInfo {
8632         self.inner
8633     }
8634 }
8635 #[repr(C)]
8636 #[cfg_attr(feature = "debug", derive(Debug))]
8637 #[derive(Copy, Clone, Default)]
8638 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFeatures.html>"]
8639 pub struct PhysicalDeviceFeatures {
8640     pub robust_buffer_access: Bool32,
8641     pub full_draw_index_uint32: Bool32,
8642     pub image_cube_array: Bool32,
8643     pub independent_blend: Bool32,
8644     pub geometry_shader: Bool32,
8645     pub tessellation_shader: Bool32,
8646     pub sample_rate_shading: Bool32,
8647     pub dual_src_blend: Bool32,
8648     pub logic_op: Bool32,
8649     pub multi_draw_indirect: Bool32,
8650     pub draw_indirect_first_instance: Bool32,
8651     pub depth_clamp: Bool32,
8652     pub depth_bias_clamp: Bool32,
8653     pub fill_mode_non_solid: Bool32,
8654     pub depth_bounds: Bool32,
8655     pub wide_lines: Bool32,
8656     pub large_points: Bool32,
8657     pub alpha_to_one: Bool32,
8658     pub multi_viewport: Bool32,
8659     pub sampler_anisotropy: Bool32,
8660     pub texture_compression_etc2: Bool32,
8661     pub texture_compression_astc_ldr: Bool32,
8662     pub texture_compression_bc: Bool32,
8663     pub occlusion_query_precise: Bool32,
8664     pub pipeline_statistics_query: Bool32,
8665     pub vertex_pipeline_stores_and_atomics: Bool32,
8666     pub fragment_stores_and_atomics: Bool32,
8667     pub shader_tessellation_and_geometry_point_size: Bool32,
8668     pub shader_image_gather_extended: Bool32,
8669     pub shader_storage_image_extended_formats: Bool32,
8670     pub shader_storage_image_multisample: Bool32,
8671     pub shader_storage_image_read_without_format: Bool32,
8672     pub shader_storage_image_write_without_format: Bool32,
8673     pub shader_uniform_buffer_array_dynamic_indexing: Bool32,
8674     pub shader_sampled_image_array_dynamic_indexing: Bool32,
8675     pub shader_storage_buffer_array_dynamic_indexing: Bool32,
8676     pub shader_storage_image_array_dynamic_indexing: Bool32,
8677     pub shader_clip_distance: Bool32,
8678     pub shader_cull_distance: Bool32,
8679     pub shader_float64: Bool32,
8680     pub shader_int64: Bool32,
8681     pub shader_int16: Bool32,
8682     pub shader_resource_residency: Bool32,
8683     pub shader_resource_min_lod: Bool32,
8684     pub sparse_binding: Bool32,
8685     pub sparse_residency_buffer: Bool32,
8686     pub sparse_residency_image2_d: Bool32,
8687     pub sparse_residency_image3_d: Bool32,
8688     pub sparse_residency2_samples: Bool32,
8689     pub sparse_residency4_samples: Bool32,
8690     pub sparse_residency8_samples: Bool32,
8691     pub sparse_residency16_samples: Bool32,
8692     pub sparse_residency_aliased: Bool32,
8693     pub variable_multisample_rate: Bool32,
8694     pub inherited_queries: Bool32,
8695 }
8696 impl PhysicalDeviceFeatures {
builder<'a>() -> PhysicalDeviceFeaturesBuilder<'a>8697     pub fn builder<'a>() -> PhysicalDeviceFeaturesBuilder<'a> {
8698         PhysicalDeviceFeaturesBuilder {
8699             inner: Self::default(),
8700             marker: ::std::marker::PhantomData,
8701         }
8702     }
8703 }
8704 #[repr(transparent)]
8705 pub struct PhysicalDeviceFeaturesBuilder<'a> {
8706     inner: PhysicalDeviceFeatures,
8707     marker: ::std::marker::PhantomData<&'a ()>,
8708 }
8709 impl<'a> ::std::ops::Deref for PhysicalDeviceFeaturesBuilder<'a> {
8710     type Target = PhysicalDeviceFeatures;
deref(&self) -> &Self::Target8711     fn deref(&self) -> &Self::Target {
8712         &self.inner
8713     }
8714 }
8715 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target8716     fn deref_mut(&mut self) -> &mut Self::Target {
8717         &mut self.inner
8718     }
8719 }
8720 impl<'a> PhysicalDeviceFeaturesBuilder<'a> {
8721     #[inline]
robust_buffer_access(mut self, robust_buffer_access: bool) -> Self8722     pub fn robust_buffer_access(mut self, robust_buffer_access: bool) -> Self {
8723         self.inner.robust_buffer_access = robust_buffer_access.into();
8724         self
8725     }
8726     #[inline]
full_draw_index_uint32(mut self, full_draw_index_uint32: bool) -> Self8727     pub fn full_draw_index_uint32(mut self, full_draw_index_uint32: bool) -> Self {
8728         self.inner.full_draw_index_uint32 = full_draw_index_uint32.into();
8729         self
8730     }
8731     #[inline]
image_cube_array(mut self, image_cube_array: bool) -> Self8732     pub fn image_cube_array(mut self, image_cube_array: bool) -> Self {
8733         self.inner.image_cube_array = image_cube_array.into();
8734         self
8735     }
8736     #[inline]
independent_blend(mut self, independent_blend: bool) -> Self8737     pub fn independent_blend(mut self, independent_blend: bool) -> Self {
8738         self.inner.independent_blend = independent_blend.into();
8739         self
8740     }
8741     #[inline]
geometry_shader(mut self, geometry_shader: bool) -> Self8742     pub fn geometry_shader(mut self, geometry_shader: bool) -> Self {
8743         self.inner.geometry_shader = geometry_shader.into();
8744         self
8745     }
8746     #[inline]
tessellation_shader(mut self, tessellation_shader: bool) -> Self8747     pub fn tessellation_shader(mut self, tessellation_shader: bool) -> Self {
8748         self.inner.tessellation_shader = tessellation_shader.into();
8749         self
8750     }
8751     #[inline]
sample_rate_shading(mut self, sample_rate_shading: bool) -> Self8752     pub fn sample_rate_shading(mut self, sample_rate_shading: bool) -> Self {
8753         self.inner.sample_rate_shading = sample_rate_shading.into();
8754         self
8755     }
8756     #[inline]
dual_src_blend(mut self, dual_src_blend: bool) -> Self8757     pub fn dual_src_blend(mut self, dual_src_blend: bool) -> Self {
8758         self.inner.dual_src_blend = dual_src_blend.into();
8759         self
8760     }
8761     #[inline]
logic_op(mut self, logic_op: bool) -> Self8762     pub fn logic_op(mut self, logic_op: bool) -> Self {
8763         self.inner.logic_op = logic_op.into();
8764         self
8765     }
8766     #[inline]
multi_draw_indirect(mut self, multi_draw_indirect: bool) -> Self8767     pub fn multi_draw_indirect(mut self, multi_draw_indirect: bool) -> Self {
8768         self.inner.multi_draw_indirect = multi_draw_indirect.into();
8769         self
8770     }
8771     #[inline]
draw_indirect_first_instance(mut self, draw_indirect_first_instance: bool) -> Self8772     pub fn draw_indirect_first_instance(mut self, draw_indirect_first_instance: bool) -> Self {
8773         self.inner.draw_indirect_first_instance = draw_indirect_first_instance.into();
8774         self
8775     }
8776     #[inline]
depth_clamp(mut self, depth_clamp: bool) -> Self8777     pub fn depth_clamp(mut self, depth_clamp: bool) -> Self {
8778         self.inner.depth_clamp = depth_clamp.into();
8779         self
8780     }
8781     #[inline]
depth_bias_clamp(mut self, depth_bias_clamp: bool) -> Self8782     pub fn depth_bias_clamp(mut self, depth_bias_clamp: bool) -> Self {
8783         self.inner.depth_bias_clamp = depth_bias_clamp.into();
8784         self
8785     }
8786     #[inline]
fill_mode_non_solid(mut self, fill_mode_non_solid: bool) -> Self8787     pub fn fill_mode_non_solid(mut self, fill_mode_non_solid: bool) -> Self {
8788         self.inner.fill_mode_non_solid = fill_mode_non_solid.into();
8789         self
8790     }
8791     #[inline]
depth_bounds(mut self, depth_bounds: bool) -> Self8792     pub fn depth_bounds(mut self, depth_bounds: bool) -> Self {
8793         self.inner.depth_bounds = depth_bounds.into();
8794         self
8795     }
8796     #[inline]
wide_lines(mut self, wide_lines: bool) -> Self8797     pub fn wide_lines(mut self, wide_lines: bool) -> Self {
8798         self.inner.wide_lines = wide_lines.into();
8799         self
8800     }
8801     #[inline]
large_points(mut self, large_points: bool) -> Self8802     pub fn large_points(mut self, large_points: bool) -> Self {
8803         self.inner.large_points = large_points.into();
8804         self
8805     }
8806     #[inline]
alpha_to_one(mut self, alpha_to_one: bool) -> Self8807     pub fn alpha_to_one(mut self, alpha_to_one: bool) -> Self {
8808         self.inner.alpha_to_one = alpha_to_one.into();
8809         self
8810     }
8811     #[inline]
multi_viewport(mut self, multi_viewport: bool) -> Self8812     pub fn multi_viewport(mut self, multi_viewport: bool) -> Self {
8813         self.inner.multi_viewport = multi_viewport.into();
8814         self
8815     }
8816     #[inline]
sampler_anisotropy(mut self, sampler_anisotropy: bool) -> Self8817     pub fn sampler_anisotropy(mut self, sampler_anisotropy: bool) -> Self {
8818         self.inner.sampler_anisotropy = sampler_anisotropy.into();
8819         self
8820     }
8821     #[inline]
texture_compression_etc2(mut self, texture_compression_etc2: bool) -> Self8822     pub fn texture_compression_etc2(mut self, texture_compression_etc2: bool) -> Self {
8823         self.inner.texture_compression_etc2 = texture_compression_etc2.into();
8824         self
8825     }
8826     #[inline]
texture_compression_astc_ldr(mut self, texture_compression_astc_ldr: bool) -> Self8827     pub fn texture_compression_astc_ldr(mut self, texture_compression_astc_ldr: bool) -> Self {
8828         self.inner.texture_compression_astc_ldr = texture_compression_astc_ldr.into();
8829         self
8830     }
8831     #[inline]
texture_compression_bc(mut self, texture_compression_bc: bool) -> Self8832     pub fn texture_compression_bc(mut self, texture_compression_bc: bool) -> Self {
8833         self.inner.texture_compression_bc = texture_compression_bc.into();
8834         self
8835     }
8836     #[inline]
occlusion_query_precise(mut self, occlusion_query_precise: bool) -> Self8837     pub fn occlusion_query_precise(mut self, occlusion_query_precise: bool) -> Self {
8838         self.inner.occlusion_query_precise = occlusion_query_precise.into();
8839         self
8840     }
8841     #[inline]
pipeline_statistics_query(mut self, pipeline_statistics_query: bool) -> Self8842     pub fn pipeline_statistics_query(mut self, pipeline_statistics_query: bool) -> Self {
8843         self.inner.pipeline_statistics_query = pipeline_statistics_query.into();
8844         self
8845     }
8846     #[inline]
vertex_pipeline_stores_and_atomics( mut self, vertex_pipeline_stores_and_atomics: bool, ) -> Self8847     pub fn vertex_pipeline_stores_and_atomics(
8848         mut self,
8849         vertex_pipeline_stores_and_atomics: bool,
8850     ) -> Self {
8851         self.inner.vertex_pipeline_stores_and_atomics = vertex_pipeline_stores_and_atomics.into();
8852         self
8853     }
8854     #[inline]
fragment_stores_and_atomics(mut self, fragment_stores_and_atomics: bool) -> Self8855     pub fn fragment_stores_and_atomics(mut self, fragment_stores_and_atomics: bool) -> Self {
8856         self.inner.fragment_stores_and_atomics = fragment_stores_and_atomics.into();
8857         self
8858     }
8859     #[inline]
shader_tessellation_and_geometry_point_size( mut self, shader_tessellation_and_geometry_point_size: bool, ) -> Self8860     pub fn shader_tessellation_and_geometry_point_size(
8861         mut self,
8862         shader_tessellation_and_geometry_point_size: bool,
8863     ) -> Self {
8864         self.inner.shader_tessellation_and_geometry_point_size =
8865             shader_tessellation_and_geometry_point_size.into();
8866         self
8867     }
8868     #[inline]
shader_image_gather_extended(mut self, shader_image_gather_extended: bool) -> Self8869     pub fn shader_image_gather_extended(mut self, shader_image_gather_extended: bool) -> Self {
8870         self.inner.shader_image_gather_extended = shader_image_gather_extended.into();
8871         self
8872     }
8873     #[inline]
shader_storage_image_extended_formats( mut self, shader_storage_image_extended_formats: bool, ) -> Self8874     pub fn shader_storage_image_extended_formats(
8875         mut self,
8876         shader_storage_image_extended_formats: bool,
8877     ) -> Self {
8878         self.inner.shader_storage_image_extended_formats =
8879             shader_storage_image_extended_formats.into();
8880         self
8881     }
8882     #[inline]
shader_storage_image_multisample( mut self, shader_storage_image_multisample: bool, ) -> Self8883     pub fn shader_storage_image_multisample(
8884         mut self,
8885         shader_storage_image_multisample: bool,
8886     ) -> Self {
8887         self.inner.shader_storage_image_multisample = shader_storage_image_multisample.into();
8888         self
8889     }
8890     #[inline]
shader_storage_image_read_without_format( mut self, shader_storage_image_read_without_format: bool, ) -> Self8891     pub fn shader_storage_image_read_without_format(
8892         mut self,
8893         shader_storage_image_read_without_format: bool,
8894     ) -> Self {
8895         self.inner.shader_storage_image_read_without_format =
8896             shader_storage_image_read_without_format.into();
8897         self
8898     }
8899     #[inline]
shader_storage_image_write_without_format( mut self, shader_storage_image_write_without_format: bool, ) -> Self8900     pub fn shader_storage_image_write_without_format(
8901         mut self,
8902         shader_storage_image_write_without_format: bool,
8903     ) -> Self {
8904         self.inner.shader_storage_image_write_without_format =
8905             shader_storage_image_write_without_format.into();
8906         self
8907     }
8908     #[inline]
shader_uniform_buffer_array_dynamic_indexing( mut self, shader_uniform_buffer_array_dynamic_indexing: bool, ) -> Self8909     pub fn shader_uniform_buffer_array_dynamic_indexing(
8910         mut self,
8911         shader_uniform_buffer_array_dynamic_indexing: bool,
8912     ) -> Self {
8913         self.inner.shader_uniform_buffer_array_dynamic_indexing =
8914             shader_uniform_buffer_array_dynamic_indexing.into();
8915         self
8916     }
8917     #[inline]
shader_sampled_image_array_dynamic_indexing( mut self, shader_sampled_image_array_dynamic_indexing: bool, ) -> Self8918     pub fn shader_sampled_image_array_dynamic_indexing(
8919         mut self,
8920         shader_sampled_image_array_dynamic_indexing: bool,
8921     ) -> Self {
8922         self.inner.shader_sampled_image_array_dynamic_indexing =
8923             shader_sampled_image_array_dynamic_indexing.into();
8924         self
8925     }
8926     #[inline]
shader_storage_buffer_array_dynamic_indexing( mut self, shader_storage_buffer_array_dynamic_indexing: bool, ) -> Self8927     pub fn shader_storage_buffer_array_dynamic_indexing(
8928         mut self,
8929         shader_storage_buffer_array_dynamic_indexing: bool,
8930     ) -> Self {
8931         self.inner.shader_storage_buffer_array_dynamic_indexing =
8932             shader_storage_buffer_array_dynamic_indexing.into();
8933         self
8934     }
8935     #[inline]
shader_storage_image_array_dynamic_indexing( mut self, shader_storage_image_array_dynamic_indexing: bool, ) -> Self8936     pub fn shader_storage_image_array_dynamic_indexing(
8937         mut self,
8938         shader_storage_image_array_dynamic_indexing: bool,
8939     ) -> Self {
8940         self.inner.shader_storage_image_array_dynamic_indexing =
8941             shader_storage_image_array_dynamic_indexing.into();
8942         self
8943     }
8944     #[inline]
shader_clip_distance(mut self, shader_clip_distance: bool) -> Self8945     pub fn shader_clip_distance(mut self, shader_clip_distance: bool) -> Self {
8946         self.inner.shader_clip_distance = shader_clip_distance.into();
8947         self
8948     }
8949     #[inline]
shader_cull_distance(mut self, shader_cull_distance: bool) -> Self8950     pub fn shader_cull_distance(mut self, shader_cull_distance: bool) -> Self {
8951         self.inner.shader_cull_distance = shader_cull_distance.into();
8952         self
8953     }
8954     #[inline]
shader_float64(mut self, shader_float64: bool) -> Self8955     pub fn shader_float64(mut self, shader_float64: bool) -> Self {
8956         self.inner.shader_float64 = shader_float64.into();
8957         self
8958     }
8959     #[inline]
shader_int64(mut self, shader_int64: bool) -> Self8960     pub fn shader_int64(mut self, shader_int64: bool) -> Self {
8961         self.inner.shader_int64 = shader_int64.into();
8962         self
8963     }
8964     #[inline]
shader_int16(mut self, shader_int16: bool) -> Self8965     pub fn shader_int16(mut self, shader_int16: bool) -> Self {
8966         self.inner.shader_int16 = shader_int16.into();
8967         self
8968     }
8969     #[inline]
shader_resource_residency(mut self, shader_resource_residency: bool) -> Self8970     pub fn shader_resource_residency(mut self, shader_resource_residency: bool) -> Self {
8971         self.inner.shader_resource_residency = shader_resource_residency.into();
8972         self
8973     }
8974     #[inline]
shader_resource_min_lod(mut self, shader_resource_min_lod: bool) -> Self8975     pub fn shader_resource_min_lod(mut self, shader_resource_min_lod: bool) -> Self {
8976         self.inner.shader_resource_min_lod = shader_resource_min_lod.into();
8977         self
8978     }
8979     #[inline]
sparse_binding(mut self, sparse_binding: bool) -> Self8980     pub fn sparse_binding(mut self, sparse_binding: bool) -> Self {
8981         self.inner.sparse_binding = sparse_binding.into();
8982         self
8983     }
8984     #[inline]
sparse_residency_buffer(mut self, sparse_residency_buffer: bool) -> Self8985     pub fn sparse_residency_buffer(mut self, sparse_residency_buffer: bool) -> Self {
8986         self.inner.sparse_residency_buffer = sparse_residency_buffer.into();
8987         self
8988     }
8989     #[inline]
sparse_residency_image2_d(mut self, sparse_residency_image2_d: bool) -> Self8990     pub fn sparse_residency_image2_d(mut self, sparse_residency_image2_d: bool) -> Self {
8991         self.inner.sparse_residency_image2_d = sparse_residency_image2_d.into();
8992         self
8993     }
8994     #[inline]
sparse_residency_image3_d(mut self, sparse_residency_image3_d: bool) -> Self8995     pub fn sparse_residency_image3_d(mut self, sparse_residency_image3_d: bool) -> Self {
8996         self.inner.sparse_residency_image3_d = sparse_residency_image3_d.into();
8997         self
8998     }
8999     #[inline]
sparse_residency2_samples(mut self, sparse_residency2_samples: bool) -> Self9000     pub fn sparse_residency2_samples(mut self, sparse_residency2_samples: bool) -> Self {
9001         self.inner.sparse_residency2_samples = sparse_residency2_samples.into();
9002         self
9003     }
9004     #[inline]
sparse_residency4_samples(mut self, sparse_residency4_samples: bool) -> Self9005     pub fn sparse_residency4_samples(mut self, sparse_residency4_samples: bool) -> Self {
9006         self.inner.sparse_residency4_samples = sparse_residency4_samples.into();
9007         self
9008     }
9009     #[inline]
sparse_residency8_samples(mut self, sparse_residency8_samples: bool) -> Self9010     pub fn sparse_residency8_samples(mut self, sparse_residency8_samples: bool) -> Self {
9011         self.inner.sparse_residency8_samples = sparse_residency8_samples.into();
9012         self
9013     }
9014     #[inline]
sparse_residency16_samples(mut self, sparse_residency16_samples: bool) -> Self9015     pub fn sparse_residency16_samples(mut self, sparse_residency16_samples: bool) -> Self {
9016         self.inner.sparse_residency16_samples = sparse_residency16_samples.into();
9017         self
9018     }
9019     #[inline]
sparse_residency_aliased(mut self, sparse_residency_aliased: bool) -> Self9020     pub fn sparse_residency_aliased(mut self, sparse_residency_aliased: bool) -> Self {
9021         self.inner.sparse_residency_aliased = sparse_residency_aliased.into();
9022         self
9023     }
9024     #[inline]
variable_multisample_rate(mut self, variable_multisample_rate: bool) -> Self9025     pub fn variable_multisample_rate(mut self, variable_multisample_rate: bool) -> Self {
9026         self.inner.variable_multisample_rate = variable_multisample_rate.into();
9027         self
9028     }
9029     #[inline]
inherited_queries(mut self, inherited_queries: bool) -> Self9030     pub fn inherited_queries(mut self, inherited_queries: bool) -> Self {
9031         self.inner.inherited_queries = inherited_queries.into();
9032         self
9033     }
9034     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9035     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9036     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFeatures9037     pub fn build(self) -> PhysicalDeviceFeatures {
9038         self.inner
9039     }
9040 }
9041 #[repr(C)]
9042 #[cfg_attr(feature = "debug", derive(Debug))]
9043 #[derive(Copy, Clone, Default)]
9044 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSparseProperties.html>"]
9045 pub struct PhysicalDeviceSparseProperties {
9046     pub residency_standard2_d_block_shape: Bool32,
9047     pub residency_standard2_d_multisample_block_shape: Bool32,
9048     pub residency_standard3_d_block_shape: Bool32,
9049     pub residency_aligned_mip_size: Bool32,
9050     pub residency_non_resident_strict: Bool32,
9051 }
9052 impl PhysicalDeviceSparseProperties {
builder<'a>() -> PhysicalDeviceSparsePropertiesBuilder<'a>9053     pub fn builder<'a>() -> PhysicalDeviceSparsePropertiesBuilder<'a> {
9054         PhysicalDeviceSparsePropertiesBuilder {
9055             inner: Self::default(),
9056             marker: ::std::marker::PhantomData,
9057         }
9058     }
9059 }
9060 #[repr(transparent)]
9061 pub struct PhysicalDeviceSparsePropertiesBuilder<'a> {
9062     inner: PhysicalDeviceSparseProperties,
9063     marker: ::std::marker::PhantomData<&'a ()>,
9064 }
9065 impl<'a> ::std::ops::Deref for PhysicalDeviceSparsePropertiesBuilder<'a> {
9066     type Target = PhysicalDeviceSparseProperties;
deref(&self) -> &Self::Target9067     fn deref(&self) -> &Self::Target {
9068         &self.inner
9069     }
9070 }
9071 impl<'a> ::std::ops::DerefMut for PhysicalDeviceSparsePropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target9072     fn deref_mut(&mut self) -> &mut Self::Target {
9073         &mut self.inner
9074     }
9075 }
9076 impl<'a> PhysicalDeviceSparsePropertiesBuilder<'a> {
9077     #[inline]
residency_standard2_d_block_shape( mut self, residency_standard2_d_block_shape: bool, ) -> Self9078     pub fn residency_standard2_d_block_shape(
9079         mut self,
9080         residency_standard2_d_block_shape: bool,
9081     ) -> Self {
9082         self.inner.residency_standard2_d_block_shape = residency_standard2_d_block_shape.into();
9083         self
9084     }
9085     #[inline]
residency_standard2_d_multisample_block_shape( mut self, residency_standard2_d_multisample_block_shape: bool, ) -> Self9086     pub fn residency_standard2_d_multisample_block_shape(
9087         mut self,
9088         residency_standard2_d_multisample_block_shape: bool,
9089     ) -> Self {
9090         self.inner.residency_standard2_d_multisample_block_shape =
9091             residency_standard2_d_multisample_block_shape.into();
9092         self
9093     }
9094     #[inline]
residency_standard3_d_block_shape( mut self, residency_standard3_d_block_shape: bool, ) -> Self9095     pub fn residency_standard3_d_block_shape(
9096         mut self,
9097         residency_standard3_d_block_shape: bool,
9098     ) -> Self {
9099         self.inner.residency_standard3_d_block_shape = residency_standard3_d_block_shape.into();
9100         self
9101     }
9102     #[inline]
residency_aligned_mip_size(mut self, residency_aligned_mip_size: bool) -> Self9103     pub fn residency_aligned_mip_size(mut self, residency_aligned_mip_size: bool) -> Self {
9104         self.inner.residency_aligned_mip_size = residency_aligned_mip_size.into();
9105         self
9106     }
9107     #[inline]
residency_non_resident_strict(mut self, residency_non_resident_strict: bool) -> Self9108     pub fn residency_non_resident_strict(mut self, residency_non_resident_strict: bool) -> Self {
9109         self.inner.residency_non_resident_strict = residency_non_resident_strict.into();
9110         self
9111     }
9112     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9113     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9114     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceSparseProperties9115     pub fn build(self) -> PhysicalDeviceSparseProperties {
9116         self.inner
9117     }
9118 }
9119 #[repr(C)]
9120 #[cfg_attr(feature = "debug", derive(Debug))]
9121 #[derive(Copy, Clone)]
9122 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceLimits.html>"]
9123 pub struct PhysicalDeviceLimits {
9124     pub max_image_dimension1_d: u32,
9125     pub max_image_dimension2_d: u32,
9126     pub max_image_dimension3_d: u32,
9127     pub max_image_dimension_cube: u32,
9128     pub max_image_array_layers: u32,
9129     pub max_texel_buffer_elements: u32,
9130     pub max_uniform_buffer_range: u32,
9131     pub max_storage_buffer_range: u32,
9132     pub max_push_constants_size: u32,
9133     pub max_memory_allocation_count: u32,
9134     pub max_sampler_allocation_count: u32,
9135     pub buffer_image_granularity: DeviceSize,
9136     pub sparse_address_space_size: DeviceSize,
9137     pub max_bound_descriptor_sets: u32,
9138     pub max_per_stage_descriptor_samplers: u32,
9139     pub max_per_stage_descriptor_uniform_buffers: u32,
9140     pub max_per_stage_descriptor_storage_buffers: u32,
9141     pub max_per_stage_descriptor_sampled_images: u32,
9142     pub max_per_stage_descriptor_storage_images: u32,
9143     pub max_per_stage_descriptor_input_attachments: u32,
9144     pub max_per_stage_resources: u32,
9145     pub max_descriptor_set_samplers: u32,
9146     pub max_descriptor_set_uniform_buffers: u32,
9147     pub max_descriptor_set_uniform_buffers_dynamic: u32,
9148     pub max_descriptor_set_storage_buffers: u32,
9149     pub max_descriptor_set_storage_buffers_dynamic: u32,
9150     pub max_descriptor_set_sampled_images: u32,
9151     pub max_descriptor_set_storage_images: u32,
9152     pub max_descriptor_set_input_attachments: u32,
9153     pub max_vertex_input_attributes: u32,
9154     pub max_vertex_input_bindings: u32,
9155     pub max_vertex_input_attribute_offset: u32,
9156     pub max_vertex_input_binding_stride: u32,
9157     pub max_vertex_output_components: u32,
9158     pub max_tessellation_generation_level: u32,
9159     pub max_tessellation_patch_size: u32,
9160     pub max_tessellation_control_per_vertex_input_components: u32,
9161     pub max_tessellation_control_per_vertex_output_components: u32,
9162     pub max_tessellation_control_per_patch_output_components: u32,
9163     pub max_tessellation_control_total_output_components: u32,
9164     pub max_tessellation_evaluation_input_components: u32,
9165     pub max_tessellation_evaluation_output_components: u32,
9166     pub max_geometry_shader_invocations: u32,
9167     pub max_geometry_input_components: u32,
9168     pub max_geometry_output_components: u32,
9169     pub max_geometry_output_vertices: u32,
9170     pub max_geometry_total_output_components: u32,
9171     pub max_fragment_input_components: u32,
9172     pub max_fragment_output_attachments: u32,
9173     pub max_fragment_dual_src_attachments: u32,
9174     pub max_fragment_combined_output_resources: u32,
9175     pub max_compute_shared_memory_size: u32,
9176     pub max_compute_work_group_count: [u32; 3],
9177     pub max_compute_work_group_invocations: u32,
9178     pub max_compute_work_group_size: [u32; 3],
9179     pub sub_pixel_precision_bits: u32,
9180     pub sub_texel_precision_bits: u32,
9181     pub mipmap_precision_bits: u32,
9182     pub max_draw_indexed_index_value: u32,
9183     pub max_draw_indirect_count: u32,
9184     pub max_sampler_lod_bias: f32,
9185     pub max_sampler_anisotropy: f32,
9186     pub max_viewports: u32,
9187     pub max_viewport_dimensions: [u32; 2],
9188     pub viewport_bounds_range: [f32; 2],
9189     pub viewport_sub_pixel_bits: u32,
9190     pub min_memory_map_alignment: usize,
9191     pub min_texel_buffer_offset_alignment: DeviceSize,
9192     pub min_uniform_buffer_offset_alignment: DeviceSize,
9193     pub min_storage_buffer_offset_alignment: DeviceSize,
9194     pub min_texel_offset: i32,
9195     pub max_texel_offset: u32,
9196     pub min_texel_gather_offset: i32,
9197     pub max_texel_gather_offset: u32,
9198     pub min_interpolation_offset: f32,
9199     pub max_interpolation_offset: f32,
9200     pub sub_pixel_interpolation_offset_bits: u32,
9201     pub max_framebuffer_width: u32,
9202     pub max_framebuffer_height: u32,
9203     pub max_framebuffer_layers: u32,
9204     pub framebuffer_color_sample_counts: SampleCountFlags,
9205     pub framebuffer_depth_sample_counts: SampleCountFlags,
9206     pub framebuffer_stencil_sample_counts: SampleCountFlags,
9207     pub framebuffer_no_attachments_sample_counts: SampleCountFlags,
9208     pub max_color_attachments: u32,
9209     pub sampled_image_color_sample_counts: SampleCountFlags,
9210     pub sampled_image_integer_sample_counts: SampleCountFlags,
9211     pub sampled_image_depth_sample_counts: SampleCountFlags,
9212     pub sampled_image_stencil_sample_counts: SampleCountFlags,
9213     pub storage_image_sample_counts: SampleCountFlags,
9214     pub max_sample_mask_words: u32,
9215     pub timestamp_compute_and_graphics: Bool32,
9216     pub timestamp_period: f32,
9217     pub max_clip_distances: u32,
9218     pub max_cull_distances: u32,
9219     pub max_combined_clip_and_cull_distances: u32,
9220     pub discrete_queue_priorities: u32,
9221     pub point_size_range: [f32; 2],
9222     pub line_width_range: [f32; 2],
9223     pub point_size_granularity: f32,
9224     pub line_width_granularity: f32,
9225     pub strict_lines: Bool32,
9226     pub standard_sample_locations: Bool32,
9227     pub optimal_buffer_copy_offset_alignment: DeviceSize,
9228     pub optimal_buffer_copy_row_pitch_alignment: DeviceSize,
9229     pub non_coherent_atom_size: DeviceSize,
9230 }
9231 impl ::std::default::Default for PhysicalDeviceLimits {
9232     #[inline]
default() -> Self9233     fn default() -> Self {
9234         Self {
9235             max_image_dimension1_d: u32::default(),
9236             max_image_dimension2_d: u32::default(),
9237             max_image_dimension3_d: u32::default(),
9238             max_image_dimension_cube: u32::default(),
9239             max_image_array_layers: u32::default(),
9240             max_texel_buffer_elements: u32::default(),
9241             max_uniform_buffer_range: u32::default(),
9242             max_storage_buffer_range: u32::default(),
9243             max_push_constants_size: u32::default(),
9244             max_memory_allocation_count: u32::default(),
9245             max_sampler_allocation_count: u32::default(),
9246             buffer_image_granularity: DeviceSize::default(),
9247             sparse_address_space_size: DeviceSize::default(),
9248             max_bound_descriptor_sets: u32::default(),
9249             max_per_stage_descriptor_samplers: u32::default(),
9250             max_per_stage_descriptor_uniform_buffers: u32::default(),
9251             max_per_stage_descriptor_storage_buffers: u32::default(),
9252             max_per_stage_descriptor_sampled_images: u32::default(),
9253             max_per_stage_descriptor_storage_images: u32::default(),
9254             max_per_stage_descriptor_input_attachments: u32::default(),
9255             max_per_stage_resources: u32::default(),
9256             max_descriptor_set_samplers: u32::default(),
9257             max_descriptor_set_uniform_buffers: u32::default(),
9258             max_descriptor_set_uniform_buffers_dynamic: u32::default(),
9259             max_descriptor_set_storage_buffers: u32::default(),
9260             max_descriptor_set_storage_buffers_dynamic: u32::default(),
9261             max_descriptor_set_sampled_images: u32::default(),
9262             max_descriptor_set_storage_images: u32::default(),
9263             max_descriptor_set_input_attachments: u32::default(),
9264             max_vertex_input_attributes: u32::default(),
9265             max_vertex_input_bindings: u32::default(),
9266             max_vertex_input_attribute_offset: u32::default(),
9267             max_vertex_input_binding_stride: u32::default(),
9268             max_vertex_output_components: u32::default(),
9269             max_tessellation_generation_level: u32::default(),
9270             max_tessellation_patch_size: u32::default(),
9271             max_tessellation_control_per_vertex_input_components: u32::default(),
9272             max_tessellation_control_per_vertex_output_components: u32::default(),
9273             max_tessellation_control_per_patch_output_components: u32::default(),
9274             max_tessellation_control_total_output_components: u32::default(),
9275             max_tessellation_evaluation_input_components: u32::default(),
9276             max_tessellation_evaluation_output_components: u32::default(),
9277             max_geometry_shader_invocations: u32::default(),
9278             max_geometry_input_components: u32::default(),
9279             max_geometry_output_components: u32::default(),
9280             max_geometry_output_vertices: u32::default(),
9281             max_geometry_total_output_components: u32::default(),
9282             max_fragment_input_components: u32::default(),
9283             max_fragment_output_attachments: u32::default(),
9284             max_fragment_dual_src_attachments: u32::default(),
9285             max_fragment_combined_output_resources: u32::default(),
9286             max_compute_shared_memory_size: u32::default(),
9287             max_compute_work_group_count: unsafe { ::std::mem::zeroed() },
9288             max_compute_work_group_invocations: u32::default(),
9289             max_compute_work_group_size: unsafe { ::std::mem::zeroed() },
9290             sub_pixel_precision_bits: u32::default(),
9291             sub_texel_precision_bits: u32::default(),
9292             mipmap_precision_bits: u32::default(),
9293             max_draw_indexed_index_value: u32::default(),
9294             max_draw_indirect_count: u32::default(),
9295             max_sampler_lod_bias: f32::default(),
9296             max_sampler_anisotropy: f32::default(),
9297             max_viewports: u32::default(),
9298             max_viewport_dimensions: unsafe { ::std::mem::zeroed() },
9299             viewport_bounds_range: unsafe { ::std::mem::zeroed() },
9300             viewport_sub_pixel_bits: u32::default(),
9301             min_memory_map_alignment: usize::default(),
9302             min_texel_buffer_offset_alignment: DeviceSize::default(),
9303             min_uniform_buffer_offset_alignment: DeviceSize::default(),
9304             min_storage_buffer_offset_alignment: DeviceSize::default(),
9305             min_texel_offset: i32::default(),
9306             max_texel_offset: u32::default(),
9307             min_texel_gather_offset: i32::default(),
9308             max_texel_gather_offset: u32::default(),
9309             min_interpolation_offset: f32::default(),
9310             max_interpolation_offset: f32::default(),
9311             sub_pixel_interpolation_offset_bits: u32::default(),
9312             max_framebuffer_width: u32::default(),
9313             max_framebuffer_height: u32::default(),
9314             max_framebuffer_layers: u32::default(),
9315             framebuffer_color_sample_counts: SampleCountFlags::default(),
9316             framebuffer_depth_sample_counts: SampleCountFlags::default(),
9317             framebuffer_stencil_sample_counts: SampleCountFlags::default(),
9318             framebuffer_no_attachments_sample_counts: SampleCountFlags::default(),
9319             max_color_attachments: u32::default(),
9320             sampled_image_color_sample_counts: SampleCountFlags::default(),
9321             sampled_image_integer_sample_counts: SampleCountFlags::default(),
9322             sampled_image_depth_sample_counts: SampleCountFlags::default(),
9323             sampled_image_stencil_sample_counts: SampleCountFlags::default(),
9324             storage_image_sample_counts: SampleCountFlags::default(),
9325             max_sample_mask_words: u32::default(),
9326             timestamp_compute_and_graphics: Bool32::default(),
9327             timestamp_period: f32::default(),
9328             max_clip_distances: u32::default(),
9329             max_cull_distances: u32::default(),
9330             max_combined_clip_and_cull_distances: u32::default(),
9331             discrete_queue_priorities: u32::default(),
9332             point_size_range: unsafe { ::std::mem::zeroed() },
9333             line_width_range: unsafe { ::std::mem::zeroed() },
9334             point_size_granularity: f32::default(),
9335             line_width_granularity: f32::default(),
9336             strict_lines: Bool32::default(),
9337             standard_sample_locations: Bool32::default(),
9338             optimal_buffer_copy_offset_alignment: DeviceSize::default(),
9339             optimal_buffer_copy_row_pitch_alignment: DeviceSize::default(),
9340             non_coherent_atom_size: DeviceSize::default(),
9341         }
9342     }
9343 }
9344 impl PhysicalDeviceLimits {
builder<'a>() -> PhysicalDeviceLimitsBuilder<'a>9345     pub fn builder<'a>() -> PhysicalDeviceLimitsBuilder<'a> {
9346         PhysicalDeviceLimitsBuilder {
9347             inner: Self::default(),
9348             marker: ::std::marker::PhantomData,
9349         }
9350     }
9351 }
9352 #[repr(transparent)]
9353 pub struct PhysicalDeviceLimitsBuilder<'a> {
9354     inner: PhysicalDeviceLimits,
9355     marker: ::std::marker::PhantomData<&'a ()>,
9356 }
9357 impl<'a> ::std::ops::Deref for PhysicalDeviceLimitsBuilder<'a> {
9358     type Target = PhysicalDeviceLimits;
deref(&self) -> &Self::Target9359     fn deref(&self) -> &Self::Target {
9360         &self.inner
9361     }
9362 }
9363 impl<'a> ::std::ops::DerefMut for PhysicalDeviceLimitsBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target9364     fn deref_mut(&mut self) -> &mut Self::Target {
9365         &mut self.inner
9366     }
9367 }
9368 impl<'a> PhysicalDeviceLimitsBuilder<'a> {
9369     #[inline]
max_image_dimension1_d(mut self, max_image_dimension1_d: u32) -> Self9370     pub fn max_image_dimension1_d(mut self, max_image_dimension1_d: u32) -> Self {
9371         self.inner.max_image_dimension1_d = max_image_dimension1_d;
9372         self
9373     }
9374     #[inline]
max_image_dimension2_d(mut self, max_image_dimension2_d: u32) -> Self9375     pub fn max_image_dimension2_d(mut self, max_image_dimension2_d: u32) -> Self {
9376         self.inner.max_image_dimension2_d = max_image_dimension2_d;
9377         self
9378     }
9379     #[inline]
max_image_dimension3_d(mut self, max_image_dimension3_d: u32) -> Self9380     pub fn max_image_dimension3_d(mut self, max_image_dimension3_d: u32) -> Self {
9381         self.inner.max_image_dimension3_d = max_image_dimension3_d;
9382         self
9383     }
9384     #[inline]
max_image_dimension_cube(mut self, max_image_dimension_cube: u32) -> Self9385     pub fn max_image_dimension_cube(mut self, max_image_dimension_cube: u32) -> Self {
9386         self.inner.max_image_dimension_cube = max_image_dimension_cube;
9387         self
9388     }
9389     #[inline]
max_image_array_layers(mut self, max_image_array_layers: u32) -> Self9390     pub fn max_image_array_layers(mut self, max_image_array_layers: u32) -> Self {
9391         self.inner.max_image_array_layers = max_image_array_layers;
9392         self
9393     }
9394     #[inline]
max_texel_buffer_elements(mut self, max_texel_buffer_elements: u32) -> Self9395     pub fn max_texel_buffer_elements(mut self, max_texel_buffer_elements: u32) -> Self {
9396         self.inner.max_texel_buffer_elements = max_texel_buffer_elements;
9397         self
9398     }
9399     #[inline]
max_uniform_buffer_range(mut self, max_uniform_buffer_range: u32) -> Self9400     pub fn max_uniform_buffer_range(mut self, max_uniform_buffer_range: u32) -> Self {
9401         self.inner.max_uniform_buffer_range = max_uniform_buffer_range;
9402         self
9403     }
9404     #[inline]
max_storage_buffer_range(mut self, max_storage_buffer_range: u32) -> Self9405     pub fn max_storage_buffer_range(mut self, max_storage_buffer_range: u32) -> Self {
9406         self.inner.max_storage_buffer_range = max_storage_buffer_range;
9407         self
9408     }
9409     #[inline]
max_push_constants_size(mut self, max_push_constants_size: u32) -> Self9410     pub fn max_push_constants_size(mut self, max_push_constants_size: u32) -> Self {
9411         self.inner.max_push_constants_size = max_push_constants_size;
9412         self
9413     }
9414     #[inline]
max_memory_allocation_count(mut self, max_memory_allocation_count: u32) -> Self9415     pub fn max_memory_allocation_count(mut self, max_memory_allocation_count: u32) -> Self {
9416         self.inner.max_memory_allocation_count = max_memory_allocation_count;
9417         self
9418     }
9419     #[inline]
max_sampler_allocation_count(mut self, max_sampler_allocation_count: u32) -> Self9420     pub fn max_sampler_allocation_count(mut self, max_sampler_allocation_count: u32) -> Self {
9421         self.inner.max_sampler_allocation_count = max_sampler_allocation_count;
9422         self
9423     }
9424     #[inline]
buffer_image_granularity(mut self, buffer_image_granularity: DeviceSize) -> Self9425     pub fn buffer_image_granularity(mut self, buffer_image_granularity: DeviceSize) -> Self {
9426         self.inner.buffer_image_granularity = buffer_image_granularity;
9427         self
9428     }
9429     #[inline]
sparse_address_space_size(mut self, sparse_address_space_size: DeviceSize) -> Self9430     pub fn sparse_address_space_size(mut self, sparse_address_space_size: DeviceSize) -> Self {
9431         self.inner.sparse_address_space_size = sparse_address_space_size;
9432         self
9433     }
9434     #[inline]
max_bound_descriptor_sets(mut self, max_bound_descriptor_sets: u32) -> Self9435     pub fn max_bound_descriptor_sets(mut self, max_bound_descriptor_sets: u32) -> Self {
9436         self.inner.max_bound_descriptor_sets = max_bound_descriptor_sets;
9437         self
9438     }
9439     #[inline]
max_per_stage_descriptor_samplers( mut self, max_per_stage_descriptor_samplers: u32, ) -> Self9440     pub fn max_per_stage_descriptor_samplers(
9441         mut self,
9442         max_per_stage_descriptor_samplers: u32,
9443     ) -> Self {
9444         self.inner.max_per_stage_descriptor_samplers = max_per_stage_descriptor_samplers;
9445         self
9446     }
9447     #[inline]
max_per_stage_descriptor_uniform_buffers( mut self, max_per_stage_descriptor_uniform_buffers: u32, ) -> Self9448     pub fn max_per_stage_descriptor_uniform_buffers(
9449         mut self,
9450         max_per_stage_descriptor_uniform_buffers: u32,
9451     ) -> Self {
9452         self.inner.max_per_stage_descriptor_uniform_buffers =
9453             max_per_stage_descriptor_uniform_buffers;
9454         self
9455     }
9456     #[inline]
max_per_stage_descriptor_storage_buffers( mut self, max_per_stage_descriptor_storage_buffers: u32, ) -> Self9457     pub fn max_per_stage_descriptor_storage_buffers(
9458         mut self,
9459         max_per_stage_descriptor_storage_buffers: u32,
9460     ) -> Self {
9461         self.inner.max_per_stage_descriptor_storage_buffers =
9462             max_per_stage_descriptor_storage_buffers;
9463         self
9464     }
9465     #[inline]
max_per_stage_descriptor_sampled_images( mut self, max_per_stage_descriptor_sampled_images: u32, ) -> Self9466     pub fn max_per_stage_descriptor_sampled_images(
9467         mut self,
9468         max_per_stage_descriptor_sampled_images: u32,
9469     ) -> Self {
9470         self.inner.max_per_stage_descriptor_sampled_images =
9471             max_per_stage_descriptor_sampled_images;
9472         self
9473     }
9474     #[inline]
max_per_stage_descriptor_storage_images( mut self, max_per_stage_descriptor_storage_images: u32, ) -> Self9475     pub fn max_per_stage_descriptor_storage_images(
9476         mut self,
9477         max_per_stage_descriptor_storage_images: u32,
9478     ) -> Self {
9479         self.inner.max_per_stage_descriptor_storage_images =
9480             max_per_stage_descriptor_storage_images;
9481         self
9482     }
9483     #[inline]
max_per_stage_descriptor_input_attachments( mut self, max_per_stage_descriptor_input_attachments: u32, ) -> Self9484     pub fn max_per_stage_descriptor_input_attachments(
9485         mut self,
9486         max_per_stage_descriptor_input_attachments: u32,
9487     ) -> Self {
9488         self.inner.max_per_stage_descriptor_input_attachments =
9489             max_per_stage_descriptor_input_attachments;
9490         self
9491     }
9492     #[inline]
max_per_stage_resources(mut self, max_per_stage_resources: u32) -> Self9493     pub fn max_per_stage_resources(mut self, max_per_stage_resources: u32) -> Self {
9494         self.inner.max_per_stage_resources = max_per_stage_resources;
9495         self
9496     }
9497     #[inline]
max_descriptor_set_samplers(mut self, max_descriptor_set_samplers: u32) -> Self9498     pub fn max_descriptor_set_samplers(mut self, max_descriptor_set_samplers: u32) -> Self {
9499         self.inner.max_descriptor_set_samplers = max_descriptor_set_samplers;
9500         self
9501     }
9502     #[inline]
max_descriptor_set_uniform_buffers( mut self, max_descriptor_set_uniform_buffers: u32, ) -> Self9503     pub fn max_descriptor_set_uniform_buffers(
9504         mut self,
9505         max_descriptor_set_uniform_buffers: u32,
9506     ) -> Self {
9507         self.inner.max_descriptor_set_uniform_buffers = max_descriptor_set_uniform_buffers;
9508         self
9509     }
9510     #[inline]
max_descriptor_set_uniform_buffers_dynamic( mut self, max_descriptor_set_uniform_buffers_dynamic: u32, ) -> Self9511     pub fn max_descriptor_set_uniform_buffers_dynamic(
9512         mut self,
9513         max_descriptor_set_uniform_buffers_dynamic: u32,
9514     ) -> Self {
9515         self.inner.max_descriptor_set_uniform_buffers_dynamic =
9516             max_descriptor_set_uniform_buffers_dynamic;
9517         self
9518     }
9519     #[inline]
max_descriptor_set_storage_buffers( mut self, max_descriptor_set_storage_buffers: u32, ) -> Self9520     pub fn max_descriptor_set_storage_buffers(
9521         mut self,
9522         max_descriptor_set_storage_buffers: u32,
9523     ) -> Self {
9524         self.inner.max_descriptor_set_storage_buffers = max_descriptor_set_storage_buffers;
9525         self
9526     }
9527     #[inline]
max_descriptor_set_storage_buffers_dynamic( mut self, max_descriptor_set_storage_buffers_dynamic: u32, ) -> Self9528     pub fn max_descriptor_set_storage_buffers_dynamic(
9529         mut self,
9530         max_descriptor_set_storage_buffers_dynamic: u32,
9531     ) -> Self {
9532         self.inner.max_descriptor_set_storage_buffers_dynamic =
9533             max_descriptor_set_storage_buffers_dynamic;
9534         self
9535     }
9536     #[inline]
max_descriptor_set_sampled_images( mut self, max_descriptor_set_sampled_images: u32, ) -> Self9537     pub fn max_descriptor_set_sampled_images(
9538         mut self,
9539         max_descriptor_set_sampled_images: u32,
9540     ) -> Self {
9541         self.inner.max_descriptor_set_sampled_images = max_descriptor_set_sampled_images;
9542         self
9543     }
9544     #[inline]
max_descriptor_set_storage_images( mut self, max_descriptor_set_storage_images: u32, ) -> Self9545     pub fn max_descriptor_set_storage_images(
9546         mut self,
9547         max_descriptor_set_storage_images: u32,
9548     ) -> Self {
9549         self.inner.max_descriptor_set_storage_images = max_descriptor_set_storage_images;
9550         self
9551     }
9552     #[inline]
max_descriptor_set_input_attachments( mut self, max_descriptor_set_input_attachments: u32, ) -> Self9553     pub fn max_descriptor_set_input_attachments(
9554         mut self,
9555         max_descriptor_set_input_attachments: u32,
9556     ) -> Self {
9557         self.inner.max_descriptor_set_input_attachments = max_descriptor_set_input_attachments;
9558         self
9559     }
9560     #[inline]
max_vertex_input_attributes(mut self, max_vertex_input_attributes: u32) -> Self9561     pub fn max_vertex_input_attributes(mut self, max_vertex_input_attributes: u32) -> Self {
9562         self.inner.max_vertex_input_attributes = max_vertex_input_attributes;
9563         self
9564     }
9565     #[inline]
max_vertex_input_bindings(mut self, max_vertex_input_bindings: u32) -> Self9566     pub fn max_vertex_input_bindings(mut self, max_vertex_input_bindings: u32) -> Self {
9567         self.inner.max_vertex_input_bindings = max_vertex_input_bindings;
9568         self
9569     }
9570     #[inline]
max_vertex_input_attribute_offset( mut self, max_vertex_input_attribute_offset: u32, ) -> Self9571     pub fn max_vertex_input_attribute_offset(
9572         mut self,
9573         max_vertex_input_attribute_offset: u32,
9574     ) -> Self {
9575         self.inner.max_vertex_input_attribute_offset = max_vertex_input_attribute_offset;
9576         self
9577     }
9578     #[inline]
max_vertex_input_binding_stride(mut self, max_vertex_input_binding_stride: u32) -> Self9579     pub fn max_vertex_input_binding_stride(mut self, max_vertex_input_binding_stride: u32) -> Self {
9580         self.inner.max_vertex_input_binding_stride = max_vertex_input_binding_stride;
9581         self
9582     }
9583     #[inline]
max_vertex_output_components(mut self, max_vertex_output_components: u32) -> Self9584     pub fn max_vertex_output_components(mut self, max_vertex_output_components: u32) -> Self {
9585         self.inner.max_vertex_output_components = max_vertex_output_components;
9586         self
9587     }
9588     #[inline]
max_tessellation_generation_level( mut self, max_tessellation_generation_level: u32, ) -> Self9589     pub fn max_tessellation_generation_level(
9590         mut self,
9591         max_tessellation_generation_level: u32,
9592     ) -> Self {
9593         self.inner.max_tessellation_generation_level = max_tessellation_generation_level;
9594         self
9595     }
9596     #[inline]
max_tessellation_patch_size(mut self, max_tessellation_patch_size: u32) -> Self9597     pub fn max_tessellation_patch_size(mut self, max_tessellation_patch_size: u32) -> Self {
9598         self.inner.max_tessellation_patch_size = max_tessellation_patch_size;
9599         self
9600     }
9601     #[inline]
max_tessellation_control_per_vertex_input_components( mut self, max_tessellation_control_per_vertex_input_components: u32, ) -> Self9602     pub fn max_tessellation_control_per_vertex_input_components(
9603         mut self,
9604         max_tessellation_control_per_vertex_input_components: u32,
9605     ) -> Self {
9606         self.inner
9607             .max_tessellation_control_per_vertex_input_components =
9608             max_tessellation_control_per_vertex_input_components;
9609         self
9610     }
9611     #[inline]
max_tessellation_control_per_vertex_output_components( mut self, max_tessellation_control_per_vertex_output_components: u32, ) -> Self9612     pub fn max_tessellation_control_per_vertex_output_components(
9613         mut self,
9614         max_tessellation_control_per_vertex_output_components: u32,
9615     ) -> Self {
9616         self.inner
9617             .max_tessellation_control_per_vertex_output_components =
9618             max_tessellation_control_per_vertex_output_components;
9619         self
9620     }
9621     #[inline]
max_tessellation_control_per_patch_output_components( mut self, max_tessellation_control_per_patch_output_components: u32, ) -> Self9622     pub fn max_tessellation_control_per_patch_output_components(
9623         mut self,
9624         max_tessellation_control_per_patch_output_components: u32,
9625     ) -> Self {
9626         self.inner
9627             .max_tessellation_control_per_patch_output_components =
9628             max_tessellation_control_per_patch_output_components;
9629         self
9630     }
9631     #[inline]
max_tessellation_control_total_output_components( mut self, max_tessellation_control_total_output_components: u32, ) -> Self9632     pub fn max_tessellation_control_total_output_components(
9633         mut self,
9634         max_tessellation_control_total_output_components: u32,
9635     ) -> Self {
9636         self.inner.max_tessellation_control_total_output_components =
9637             max_tessellation_control_total_output_components;
9638         self
9639     }
9640     #[inline]
max_tessellation_evaluation_input_components( mut self, max_tessellation_evaluation_input_components: u32, ) -> Self9641     pub fn max_tessellation_evaluation_input_components(
9642         mut self,
9643         max_tessellation_evaluation_input_components: u32,
9644     ) -> Self {
9645         self.inner.max_tessellation_evaluation_input_components =
9646             max_tessellation_evaluation_input_components;
9647         self
9648     }
9649     #[inline]
max_tessellation_evaluation_output_components( mut self, max_tessellation_evaluation_output_components: u32, ) -> Self9650     pub fn max_tessellation_evaluation_output_components(
9651         mut self,
9652         max_tessellation_evaluation_output_components: u32,
9653     ) -> Self {
9654         self.inner.max_tessellation_evaluation_output_components =
9655             max_tessellation_evaluation_output_components;
9656         self
9657     }
9658     #[inline]
max_geometry_shader_invocations(mut self, max_geometry_shader_invocations: u32) -> Self9659     pub fn max_geometry_shader_invocations(mut self, max_geometry_shader_invocations: u32) -> Self {
9660         self.inner.max_geometry_shader_invocations = max_geometry_shader_invocations;
9661         self
9662     }
9663     #[inline]
max_geometry_input_components(mut self, max_geometry_input_components: u32) -> Self9664     pub fn max_geometry_input_components(mut self, max_geometry_input_components: u32) -> Self {
9665         self.inner.max_geometry_input_components = max_geometry_input_components;
9666         self
9667     }
9668     #[inline]
max_geometry_output_components(mut self, max_geometry_output_components: u32) -> Self9669     pub fn max_geometry_output_components(mut self, max_geometry_output_components: u32) -> Self {
9670         self.inner.max_geometry_output_components = max_geometry_output_components;
9671         self
9672     }
9673     #[inline]
max_geometry_output_vertices(mut self, max_geometry_output_vertices: u32) -> Self9674     pub fn max_geometry_output_vertices(mut self, max_geometry_output_vertices: u32) -> Self {
9675         self.inner.max_geometry_output_vertices = max_geometry_output_vertices;
9676         self
9677     }
9678     #[inline]
max_geometry_total_output_components( mut self, max_geometry_total_output_components: u32, ) -> Self9679     pub fn max_geometry_total_output_components(
9680         mut self,
9681         max_geometry_total_output_components: u32,
9682     ) -> Self {
9683         self.inner.max_geometry_total_output_components = max_geometry_total_output_components;
9684         self
9685     }
9686     #[inline]
max_fragment_input_components(mut self, max_fragment_input_components: u32) -> Self9687     pub fn max_fragment_input_components(mut self, max_fragment_input_components: u32) -> Self {
9688         self.inner.max_fragment_input_components = max_fragment_input_components;
9689         self
9690     }
9691     #[inline]
max_fragment_output_attachments(mut self, max_fragment_output_attachments: u32) -> Self9692     pub fn max_fragment_output_attachments(mut self, max_fragment_output_attachments: u32) -> Self {
9693         self.inner.max_fragment_output_attachments = max_fragment_output_attachments;
9694         self
9695     }
9696     #[inline]
max_fragment_dual_src_attachments( mut self, max_fragment_dual_src_attachments: u32, ) -> Self9697     pub fn max_fragment_dual_src_attachments(
9698         mut self,
9699         max_fragment_dual_src_attachments: u32,
9700     ) -> Self {
9701         self.inner.max_fragment_dual_src_attachments = max_fragment_dual_src_attachments;
9702         self
9703     }
9704     #[inline]
max_fragment_combined_output_resources( mut self, max_fragment_combined_output_resources: u32, ) -> Self9705     pub fn max_fragment_combined_output_resources(
9706         mut self,
9707         max_fragment_combined_output_resources: u32,
9708     ) -> Self {
9709         self.inner.max_fragment_combined_output_resources = max_fragment_combined_output_resources;
9710         self
9711     }
9712     #[inline]
max_compute_shared_memory_size(mut self, max_compute_shared_memory_size: u32) -> Self9713     pub fn max_compute_shared_memory_size(mut self, max_compute_shared_memory_size: u32) -> Self {
9714         self.inner.max_compute_shared_memory_size = max_compute_shared_memory_size;
9715         self
9716     }
9717     #[inline]
max_compute_work_group_count(mut self, max_compute_work_group_count: [u32; 3]) -> Self9718     pub fn max_compute_work_group_count(mut self, max_compute_work_group_count: [u32; 3]) -> Self {
9719         self.inner.max_compute_work_group_count = max_compute_work_group_count;
9720         self
9721     }
9722     #[inline]
max_compute_work_group_invocations( mut self, max_compute_work_group_invocations: u32, ) -> Self9723     pub fn max_compute_work_group_invocations(
9724         mut self,
9725         max_compute_work_group_invocations: u32,
9726     ) -> Self {
9727         self.inner.max_compute_work_group_invocations = max_compute_work_group_invocations;
9728         self
9729     }
9730     #[inline]
max_compute_work_group_size(mut self, max_compute_work_group_size: [u32; 3]) -> Self9731     pub fn max_compute_work_group_size(mut self, max_compute_work_group_size: [u32; 3]) -> Self {
9732         self.inner.max_compute_work_group_size = max_compute_work_group_size;
9733         self
9734     }
9735     #[inline]
sub_pixel_precision_bits(mut self, sub_pixel_precision_bits: u32) -> Self9736     pub fn sub_pixel_precision_bits(mut self, sub_pixel_precision_bits: u32) -> Self {
9737         self.inner.sub_pixel_precision_bits = sub_pixel_precision_bits;
9738         self
9739     }
9740     #[inline]
sub_texel_precision_bits(mut self, sub_texel_precision_bits: u32) -> Self9741     pub fn sub_texel_precision_bits(mut self, sub_texel_precision_bits: u32) -> Self {
9742         self.inner.sub_texel_precision_bits = sub_texel_precision_bits;
9743         self
9744     }
9745     #[inline]
mipmap_precision_bits(mut self, mipmap_precision_bits: u32) -> Self9746     pub fn mipmap_precision_bits(mut self, mipmap_precision_bits: u32) -> Self {
9747         self.inner.mipmap_precision_bits = mipmap_precision_bits;
9748         self
9749     }
9750     #[inline]
max_draw_indexed_index_value(mut self, max_draw_indexed_index_value: u32) -> Self9751     pub fn max_draw_indexed_index_value(mut self, max_draw_indexed_index_value: u32) -> Self {
9752         self.inner.max_draw_indexed_index_value = max_draw_indexed_index_value;
9753         self
9754     }
9755     #[inline]
max_draw_indirect_count(mut self, max_draw_indirect_count: u32) -> Self9756     pub fn max_draw_indirect_count(mut self, max_draw_indirect_count: u32) -> Self {
9757         self.inner.max_draw_indirect_count = max_draw_indirect_count;
9758         self
9759     }
9760     #[inline]
max_sampler_lod_bias(mut self, max_sampler_lod_bias: f32) -> Self9761     pub fn max_sampler_lod_bias(mut self, max_sampler_lod_bias: f32) -> Self {
9762         self.inner.max_sampler_lod_bias = max_sampler_lod_bias;
9763         self
9764     }
9765     #[inline]
max_sampler_anisotropy(mut self, max_sampler_anisotropy: f32) -> Self9766     pub fn max_sampler_anisotropy(mut self, max_sampler_anisotropy: f32) -> Self {
9767         self.inner.max_sampler_anisotropy = max_sampler_anisotropy;
9768         self
9769     }
9770     #[inline]
max_viewports(mut self, max_viewports: u32) -> Self9771     pub fn max_viewports(mut self, max_viewports: u32) -> Self {
9772         self.inner.max_viewports = max_viewports;
9773         self
9774     }
9775     #[inline]
max_viewport_dimensions(mut self, max_viewport_dimensions: [u32; 2]) -> Self9776     pub fn max_viewport_dimensions(mut self, max_viewport_dimensions: [u32; 2]) -> Self {
9777         self.inner.max_viewport_dimensions = max_viewport_dimensions;
9778         self
9779     }
9780     #[inline]
viewport_bounds_range(mut self, viewport_bounds_range: [f32; 2]) -> Self9781     pub fn viewport_bounds_range(mut self, viewport_bounds_range: [f32; 2]) -> Self {
9782         self.inner.viewport_bounds_range = viewport_bounds_range;
9783         self
9784     }
9785     #[inline]
viewport_sub_pixel_bits(mut self, viewport_sub_pixel_bits: u32) -> Self9786     pub fn viewport_sub_pixel_bits(mut self, viewport_sub_pixel_bits: u32) -> Self {
9787         self.inner.viewport_sub_pixel_bits = viewport_sub_pixel_bits;
9788         self
9789     }
9790     #[inline]
min_memory_map_alignment(mut self, min_memory_map_alignment: usize) -> Self9791     pub fn min_memory_map_alignment(mut self, min_memory_map_alignment: usize) -> Self {
9792         self.inner.min_memory_map_alignment = min_memory_map_alignment;
9793         self
9794     }
9795     #[inline]
min_texel_buffer_offset_alignment( mut self, min_texel_buffer_offset_alignment: DeviceSize, ) -> Self9796     pub fn min_texel_buffer_offset_alignment(
9797         mut self,
9798         min_texel_buffer_offset_alignment: DeviceSize,
9799     ) -> Self {
9800         self.inner.min_texel_buffer_offset_alignment = min_texel_buffer_offset_alignment;
9801         self
9802     }
9803     #[inline]
min_uniform_buffer_offset_alignment( mut self, min_uniform_buffer_offset_alignment: DeviceSize, ) -> Self9804     pub fn min_uniform_buffer_offset_alignment(
9805         mut self,
9806         min_uniform_buffer_offset_alignment: DeviceSize,
9807     ) -> Self {
9808         self.inner.min_uniform_buffer_offset_alignment = min_uniform_buffer_offset_alignment;
9809         self
9810     }
9811     #[inline]
min_storage_buffer_offset_alignment( mut self, min_storage_buffer_offset_alignment: DeviceSize, ) -> Self9812     pub fn min_storage_buffer_offset_alignment(
9813         mut self,
9814         min_storage_buffer_offset_alignment: DeviceSize,
9815     ) -> Self {
9816         self.inner.min_storage_buffer_offset_alignment = min_storage_buffer_offset_alignment;
9817         self
9818     }
9819     #[inline]
min_texel_offset(mut self, min_texel_offset: i32) -> Self9820     pub fn min_texel_offset(mut self, min_texel_offset: i32) -> Self {
9821         self.inner.min_texel_offset = min_texel_offset;
9822         self
9823     }
9824     #[inline]
max_texel_offset(mut self, max_texel_offset: u32) -> Self9825     pub fn max_texel_offset(mut self, max_texel_offset: u32) -> Self {
9826         self.inner.max_texel_offset = max_texel_offset;
9827         self
9828     }
9829     #[inline]
min_texel_gather_offset(mut self, min_texel_gather_offset: i32) -> Self9830     pub fn min_texel_gather_offset(mut self, min_texel_gather_offset: i32) -> Self {
9831         self.inner.min_texel_gather_offset = min_texel_gather_offset;
9832         self
9833     }
9834     #[inline]
max_texel_gather_offset(mut self, max_texel_gather_offset: u32) -> Self9835     pub fn max_texel_gather_offset(mut self, max_texel_gather_offset: u32) -> Self {
9836         self.inner.max_texel_gather_offset = max_texel_gather_offset;
9837         self
9838     }
9839     #[inline]
min_interpolation_offset(mut self, min_interpolation_offset: f32) -> Self9840     pub fn min_interpolation_offset(mut self, min_interpolation_offset: f32) -> Self {
9841         self.inner.min_interpolation_offset = min_interpolation_offset;
9842         self
9843     }
9844     #[inline]
max_interpolation_offset(mut self, max_interpolation_offset: f32) -> Self9845     pub fn max_interpolation_offset(mut self, max_interpolation_offset: f32) -> Self {
9846         self.inner.max_interpolation_offset = max_interpolation_offset;
9847         self
9848     }
9849     #[inline]
sub_pixel_interpolation_offset_bits( mut self, sub_pixel_interpolation_offset_bits: u32, ) -> Self9850     pub fn sub_pixel_interpolation_offset_bits(
9851         mut self,
9852         sub_pixel_interpolation_offset_bits: u32,
9853     ) -> Self {
9854         self.inner.sub_pixel_interpolation_offset_bits = sub_pixel_interpolation_offset_bits;
9855         self
9856     }
9857     #[inline]
max_framebuffer_width(mut self, max_framebuffer_width: u32) -> Self9858     pub fn max_framebuffer_width(mut self, max_framebuffer_width: u32) -> Self {
9859         self.inner.max_framebuffer_width = max_framebuffer_width;
9860         self
9861     }
9862     #[inline]
max_framebuffer_height(mut self, max_framebuffer_height: u32) -> Self9863     pub fn max_framebuffer_height(mut self, max_framebuffer_height: u32) -> Self {
9864         self.inner.max_framebuffer_height = max_framebuffer_height;
9865         self
9866     }
9867     #[inline]
max_framebuffer_layers(mut self, max_framebuffer_layers: u32) -> Self9868     pub fn max_framebuffer_layers(mut self, max_framebuffer_layers: u32) -> Self {
9869         self.inner.max_framebuffer_layers = max_framebuffer_layers;
9870         self
9871     }
9872     #[inline]
framebuffer_color_sample_counts( mut self, framebuffer_color_sample_counts: SampleCountFlags, ) -> Self9873     pub fn framebuffer_color_sample_counts(
9874         mut self,
9875         framebuffer_color_sample_counts: SampleCountFlags,
9876     ) -> Self {
9877         self.inner.framebuffer_color_sample_counts = framebuffer_color_sample_counts;
9878         self
9879     }
9880     #[inline]
framebuffer_depth_sample_counts( mut self, framebuffer_depth_sample_counts: SampleCountFlags, ) -> Self9881     pub fn framebuffer_depth_sample_counts(
9882         mut self,
9883         framebuffer_depth_sample_counts: SampleCountFlags,
9884     ) -> Self {
9885         self.inner.framebuffer_depth_sample_counts = framebuffer_depth_sample_counts;
9886         self
9887     }
9888     #[inline]
framebuffer_stencil_sample_counts( mut self, framebuffer_stencil_sample_counts: SampleCountFlags, ) -> Self9889     pub fn framebuffer_stencil_sample_counts(
9890         mut self,
9891         framebuffer_stencil_sample_counts: SampleCountFlags,
9892     ) -> Self {
9893         self.inner.framebuffer_stencil_sample_counts = framebuffer_stencil_sample_counts;
9894         self
9895     }
9896     #[inline]
framebuffer_no_attachments_sample_counts( mut self, framebuffer_no_attachments_sample_counts: SampleCountFlags, ) -> Self9897     pub fn framebuffer_no_attachments_sample_counts(
9898         mut self,
9899         framebuffer_no_attachments_sample_counts: SampleCountFlags,
9900     ) -> Self {
9901         self.inner.framebuffer_no_attachments_sample_counts =
9902             framebuffer_no_attachments_sample_counts;
9903         self
9904     }
9905     #[inline]
max_color_attachments(mut self, max_color_attachments: u32) -> Self9906     pub fn max_color_attachments(mut self, max_color_attachments: u32) -> Self {
9907         self.inner.max_color_attachments = max_color_attachments;
9908         self
9909     }
9910     #[inline]
sampled_image_color_sample_counts( mut self, sampled_image_color_sample_counts: SampleCountFlags, ) -> Self9911     pub fn sampled_image_color_sample_counts(
9912         mut self,
9913         sampled_image_color_sample_counts: SampleCountFlags,
9914     ) -> Self {
9915         self.inner.sampled_image_color_sample_counts = sampled_image_color_sample_counts;
9916         self
9917     }
9918     #[inline]
sampled_image_integer_sample_counts( mut self, sampled_image_integer_sample_counts: SampleCountFlags, ) -> Self9919     pub fn sampled_image_integer_sample_counts(
9920         mut self,
9921         sampled_image_integer_sample_counts: SampleCountFlags,
9922     ) -> Self {
9923         self.inner.sampled_image_integer_sample_counts = sampled_image_integer_sample_counts;
9924         self
9925     }
9926     #[inline]
sampled_image_depth_sample_counts( mut self, sampled_image_depth_sample_counts: SampleCountFlags, ) -> Self9927     pub fn sampled_image_depth_sample_counts(
9928         mut self,
9929         sampled_image_depth_sample_counts: SampleCountFlags,
9930     ) -> Self {
9931         self.inner.sampled_image_depth_sample_counts = sampled_image_depth_sample_counts;
9932         self
9933     }
9934     #[inline]
sampled_image_stencil_sample_counts( mut self, sampled_image_stencil_sample_counts: SampleCountFlags, ) -> Self9935     pub fn sampled_image_stencil_sample_counts(
9936         mut self,
9937         sampled_image_stencil_sample_counts: SampleCountFlags,
9938     ) -> Self {
9939         self.inner.sampled_image_stencil_sample_counts = sampled_image_stencil_sample_counts;
9940         self
9941     }
9942     #[inline]
storage_image_sample_counts( mut self, storage_image_sample_counts: SampleCountFlags, ) -> Self9943     pub fn storage_image_sample_counts(
9944         mut self,
9945         storage_image_sample_counts: SampleCountFlags,
9946     ) -> Self {
9947         self.inner.storage_image_sample_counts = storage_image_sample_counts;
9948         self
9949     }
9950     #[inline]
max_sample_mask_words(mut self, max_sample_mask_words: u32) -> Self9951     pub fn max_sample_mask_words(mut self, max_sample_mask_words: u32) -> Self {
9952         self.inner.max_sample_mask_words = max_sample_mask_words;
9953         self
9954     }
9955     #[inline]
timestamp_compute_and_graphics(mut self, timestamp_compute_and_graphics: bool) -> Self9956     pub fn timestamp_compute_and_graphics(mut self, timestamp_compute_and_graphics: bool) -> Self {
9957         self.inner.timestamp_compute_and_graphics = timestamp_compute_and_graphics.into();
9958         self
9959     }
9960     #[inline]
timestamp_period(mut self, timestamp_period: f32) -> Self9961     pub fn timestamp_period(mut self, timestamp_period: f32) -> Self {
9962         self.inner.timestamp_period = timestamp_period;
9963         self
9964     }
9965     #[inline]
max_clip_distances(mut self, max_clip_distances: u32) -> Self9966     pub fn max_clip_distances(mut self, max_clip_distances: u32) -> Self {
9967         self.inner.max_clip_distances = max_clip_distances;
9968         self
9969     }
9970     #[inline]
max_cull_distances(mut self, max_cull_distances: u32) -> Self9971     pub fn max_cull_distances(mut self, max_cull_distances: u32) -> Self {
9972         self.inner.max_cull_distances = max_cull_distances;
9973         self
9974     }
9975     #[inline]
max_combined_clip_and_cull_distances( mut self, max_combined_clip_and_cull_distances: u32, ) -> Self9976     pub fn max_combined_clip_and_cull_distances(
9977         mut self,
9978         max_combined_clip_and_cull_distances: u32,
9979     ) -> Self {
9980         self.inner.max_combined_clip_and_cull_distances = max_combined_clip_and_cull_distances;
9981         self
9982     }
9983     #[inline]
discrete_queue_priorities(mut self, discrete_queue_priorities: u32) -> Self9984     pub fn discrete_queue_priorities(mut self, discrete_queue_priorities: u32) -> Self {
9985         self.inner.discrete_queue_priorities = discrete_queue_priorities;
9986         self
9987     }
9988     #[inline]
point_size_range(mut self, point_size_range: [f32; 2]) -> Self9989     pub fn point_size_range(mut self, point_size_range: [f32; 2]) -> Self {
9990         self.inner.point_size_range = point_size_range;
9991         self
9992     }
9993     #[inline]
line_width_range(mut self, line_width_range: [f32; 2]) -> Self9994     pub fn line_width_range(mut self, line_width_range: [f32; 2]) -> Self {
9995         self.inner.line_width_range = line_width_range;
9996         self
9997     }
9998     #[inline]
point_size_granularity(mut self, point_size_granularity: f32) -> Self9999     pub fn point_size_granularity(mut self, point_size_granularity: f32) -> Self {
10000         self.inner.point_size_granularity = point_size_granularity;
10001         self
10002     }
10003     #[inline]
line_width_granularity(mut self, line_width_granularity: f32) -> Self10004     pub fn line_width_granularity(mut self, line_width_granularity: f32) -> Self {
10005         self.inner.line_width_granularity = line_width_granularity;
10006         self
10007     }
10008     #[inline]
strict_lines(mut self, strict_lines: bool) -> Self10009     pub fn strict_lines(mut self, strict_lines: bool) -> Self {
10010         self.inner.strict_lines = strict_lines.into();
10011         self
10012     }
10013     #[inline]
standard_sample_locations(mut self, standard_sample_locations: bool) -> Self10014     pub fn standard_sample_locations(mut self, standard_sample_locations: bool) -> Self {
10015         self.inner.standard_sample_locations = standard_sample_locations.into();
10016         self
10017     }
10018     #[inline]
optimal_buffer_copy_offset_alignment( mut self, optimal_buffer_copy_offset_alignment: DeviceSize, ) -> Self10019     pub fn optimal_buffer_copy_offset_alignment(
10020         mut self,
10021         optimal_buffer_copy_offset_alignment: DeviceSize,
10022     ) -> Self {
10023         self.inner.optimal_buffer_copy_offset_alignment = optimal_buffer_copy_offset_alignment;
10024         self
10025     }
10026     #[inline]
optimal_buffer_copy_row_pitch_alignment( mut self, optimal_buffer_copy_row_pitch_alignment: DeviceSize, ) -> Self10027     pub fn optimal_buffer_copy_row_pitch_alignment(
10028         mut self,
10029         optimal_buffer_copy_row_pitch_alignment: DeviceSize,
10030     ) -> Self {
10031         self.inner.optimal_buffer_copy_row_pitch_alignment =
10032             optimal_buffer_copy_row_pitch_alignment;
10033         self
10034     }
10035     #[inline]
non_coherent_atom_size(mut self, non_coherent_atom_size: DeviceSize) -> Self10036     pub fn non_coherent_atom_size(mut self, non_coherent_atom_size: DeviceSize) -> Self {
10037         self.inner.non_coherent_atom_size = non_coherent_atom_size;
10038         self
10039     }
10040     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10041     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10042     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceLimits10043     pub fn build(self) -> PhysicalDeviceLimits {
10044         self.inner
10045     }
10046 }
10047 #[repr(C)]
10048 #[cfg_attr(feature = "debug", derive(Debug))]
10049 #[derive(Copy, Clone)]
10050 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreCreateInfo.html>"]
10051 pub struct SemaphoreCreateInfo {
10052     pub s_type: StructureType,
10053     pub p_next: *const c_void,
10054     pub flags: SemaphoreCreateFlags,
10055 }
10056 impl ::std::default::Default for SemaphoreCreateInfo {
10057     #[inline]
default() -> Self10058     fn default() -> Self {
10059         Self {
10060             s_type: Self::STRUCTURE_TYPE,
10061             p_next: ::std::ptr::null(),
10062             flags: SemaphoreCreateFlags::default(),
10063         }
10064     }
10065 }
10066 unsafe impl TaggedStructure for SemaphoreCreateInfo {
10067     const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_CREATE_INFO;
10068 }
10069 impl SemaphoreCreateInfo {
builder<'a>() -> SemaphoreCreateInfoBuilder<'a>10070     pub fn builder<'a>() -> SemaphoreCreateInfoBuilder<'a> {
10071         SemaphoreCreateInfoBuilder {
10072             inner: Self::default(),
10073             marker: ::std::marker::PhantomData,
10074         }
10075     }
10076 }
10077 #[repr(transparent)]
10078 pub struct SemaphoreCreateInfoBuilder<'a> {
10079     inner: SemaphoreCreateInfo,
10080     marker: ::std::marker::PhantomData<&'a ()>,
10081 }
10082 pub unsafe trait ExtendsSemaphoreCreateInfo {}
10083 impl<'a> ::std::ops::Deref for SemaphoreCreateInfoBuilder<'a> {
10084     type Target = SemaphoreCreateInfo;
deref(&self) -> &Self::Target10085     fn deref(&self) -> &Self::Target {
10086         &self.inner
10087     }
10088 }
10089 impl<'a> ::std::ops::DerefMut for SemaphoreCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target10090     fn deref_mut(&mut self) -> &mut Self::Target {
10091         &mut self.inner
10092     }
10093 }
10094 impl<'a> SemaphoreCreateInfoBuilder<'a> {
10095     #[inline]
flags(mut self, flags: SemaphoreCreateFlags) -> Self10096     pub fn flags(mut self, flags: SemaphoreCreateFlags) -> Self {
10097         self.inner.flags = flags;
10098         self
10099     }
10100     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
10101     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
10102     #[doc = r" valid extension structs can be pushed into the chain."]
10103     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
10104     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSemaphoreCreateInfo>(mut self, next: &'a mut T) -> Self10105     pub fn push_next<T: ExtendsSemaphoreCreateInfo>(mut self, next: &'a mut T) -> Self {
10106         unsafe {
10107             let next_ptr = <*const T>::cast(next);
10108             let last_next = ptr_chain_iter(next).last().unwrap();
10109             (*last_next).p_next = self.inner.p_next as _;
10110             self.inner.p_next = next_ptr;
10111         }
10112         self
10113     }
10114     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10115     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10116     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SemaphoreCreateInfo10117     pub fn build(self) -> SemaphoreCreateInfo {
10118         self.inner
10119     }
10120 }
10121 #[repr(C)]
10122 #[cfg_attr(feature = "debug", derive(Debug))]
10123 #[derive(Copy, Clone)]
10124 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPoolCreateInfo.html>"]
10125 pub struct QueryPoolCreateInfo {
10126     pub s_type: StructureType,
10127     pub p_next: *const c_void,
10128     pub flags: QueryPoolCreateFlags,
10129     pub query_type: QueryType,
10130     pub query_count: u32,
10131     pub pipeline_statistics: QueryPipelineStatisticFlags,
10132 }
10133 impl ::std::default::Default for QueryPoolCreateInfo {
10134     #[inline]
default() -> Self10135     fn default() -> Self {
10136         Self {
10137             s_type: Self::STRUCTURE_TYPE,
10138             p_next: ::std::ptr::null(),
10139             flags: QueryPoolCreateFlags::default(),
10140             query_type: QueryType::default(),
10141             query_count: u32::default(),
10142             pipeline_statistics: QueryPipelineStatisticFlags::default(),
10143         }
10144     }
10145 }
10146 unsafe impl TaggedStructure for QueryPoolCreateInfo {
10147     const STRUCTURE_TYPE: StructureType = StructureType::QUERY_POOL_CREATE_INFO;
10148 }
10149 impl QueryPoolCreateInfo {
builder<'a>() -> QueryPoolCreateInfoBuilder<'a>10150     pub fn builder<'a>() -> QueryPoolCreateInfoBuilder<'a> {
10151         QueryPoolCreateInfoBuilder {
10152             inner: Self::default(),
10153             marker: ::std::marker::PhantomData,
10154         }
10155     }
10156 }
10157 #[repr(transparent)]
10158 pub struct QueryPoolCreateInfoBuilder<'a> {
10159     inner: QueryPoolCreateInfo,
10160     marker: ::std::marker::PhantomData<&'a ()>,
10161 }
10162 pub unsafe trait ExtendsQueryPoolCreateInfo {}
10163 impl<'a> ::std::ops::Deref for QueryPoolCreateInfoBuilder<'a> {
10164     type Target = QueryPoolCreateInfo;
deref(&self) -> &Self::Target10165     fn deref(&self) -> &Self::Target {
10166         &self.inner
10167     }
10168 }
10169 impl<'a> ::std::ops::DerefMut for QueryPoolCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target10170     fn deref_mut(&mut self) -> &mut Self::Target {
10171         &mut self.inner
10172     }
10173 }
10174 impl<'a> QueryPoolCreateInfoBuilder<'a> {
10175     #[inline]
flags(mut self, flags: QueryPoolCreateFlags) -> Self10176     pub fn flags(mut self, flags: QueryPoolCreateFlags) -> Self {
10177         self.inner.flags = flags;
10178         self
10179     }
10180     #[inline]
query_type(mut self, query_type: QueryType) -> Self10181     pub fn query_type(mut self, query_type: QueryType) -> Self {
10182         self.inner.query_type = query_type;
10183         self
10184     }
10185     #[inline]
query_count(mut self, query_count: u32) -> Self10186     pub fn query_count(mut self, query_count: u32) -> Self {
10187         self.inner.query_count = query_count;
10188         self
10189     }
10190     #[inline]
pipeline_statistics(mut self, pipeline_statistics: QueryPipelineStatisticFlags) -> Self10191     pub fn pipeline_statistics(mut self, pipeline_statistics: QueryPipelineStatisticFlags) -> Self {
10192         self.inner.pipeline_statistics = pipeline_statistics;
10193         self
10194     }
10195     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
10196     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
10197     #[doc = r" valid extension structs can be pushed into the chain."]
10198     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
10199     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsQueryPoolCreateInfo>(mut self, next: &'a mut T) -> Self10200     pub fn push_next<T: ExtendsQueryPoolCreateInfo>(mut self, next: &'a mut T) -> Self {
10201         unsafe {
10202             let next_ptr = <*const T>::cast(next);
10203             let last_next = ptr_chain_iter(next).last().unwrap();
10204             (*last_next).p_next = self.inner.p_next as _;
10205             self.inner.p_next = next_ptr;
10206         }
10207         self
10208     }
10209     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10210     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10211     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> QueryPoolCreateInfo10212     pub fn build(self) -> QueryPoolCreateInfo {
10213         self.inner
10214     }
10215 }
10216 #[repr(C)]
10217 #[cfg_attr(feature = "debug", derive(Debug))]
10218 #[derive(Copy, Clone)]
10219 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebufferCreateInfo.html>"]
10220 pub struct FramebufferCreateInfo {
10221     pub s_type: StructureType,
10222     pub p_next: *const c_void,
10223     pub flags: FramebufferCreateFlags,
10224     pub render_pass: RenderPass,
10225     pub attachment_count: u32,
10226     pub p_attachments: *const ImageView,
10227     pub width: u32,
10228     pub height: u32,
10229     pub layers: u32,
10230 }
10231 impl ::std::default::Default for FramebufferCreateInfo {
10232     #[inline]
default() -> Self10233     fn default() -> Self {
10234         Self {
10235             s_type: Self::STRUCTURE_TYPE,
10236             p_next: ::std::ptr::null(),
10237             flags: FramebufferCreateFlags::default(),
10238             render_pass: RenderPass::default(),
10239             attachment_count: u32::default(),
10240             p_attachments: ::std::ptr::null(),
10241             width: u32::default(),
10242             height: u32::default(),
10243             layers: u32::default(),
10244         }
10245     }
10246 }
10247 unsafe impl TaggedStructure for FramebufferCreateInfo {
10248     const STRUCTURE_TYPE: StructureType = StructureType::FRAMEBUFFER_CREATE_INFO;
10249 }
10250 impl FramebufferCreateInfo {
builder<'a>() -> FramebufferCreateInfoBuilder<'a>10251     pub fn builder<'a>() -> FramebufferCreateInfoBuilder<'a> {
10252         FramebufferCreateInfoBuilder {
10253             inner: Self::default(),
10254             marker: ::std::marker::PhantomData,
10255         }
10256     }
10257 }
10258 #[repr(transparent)]
10259 pub struct FramebufferCreateInfoBuilder<'a> {
10260     inner: FramebufferCreateInfo,
10261     marker: ::std::marker::PhantomData<&'a ()>,
10262 }
10263 pub unsafe trait ExtendsFramebufferCreateInfo {}
10264 impl<'a> ::std::ops::Deref for FramebufferCreateInfoBuilder<'a> {
10265     type Target = FramebufferCreateInfo;
deref(&self) -> &Self::Target10266     fn deref(&self) -> &Self::Target {
10267         &self.inner
10268     }
10269 }
10270 impl<'a> ::std::ops::DerefMut for FramebufferCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target10271     fn deref_mut(&mut self) -> &mut Self::Target {
10272         &mut self.inner
10273     }
10274 }
10275 impl<'a> FramebufferCreateInfoBuilder<'a> {
10276     #[inline]
flags(mut self, flags: FramebufferCreateFlags) -> Self10277     pub fn flags(mut self, flags: FramebufferCreateFlags) -> Self {
10278         self.inner.flags = flags;
10279         self
10280     }
10281     #[inline]
render_pass(mut self, render_pass: RenderPass) -> Self10282     pub fn render_pass(mut self, render_pass: RenderPass) -> Self {
10283         self.inner.render_pass = render_pass;
10284         self
10285     }
10286     #[inline]
attachment_count(mut self, attachment_count: u32) -> Self10287     pub fn attachment_count(mut self, attachment_count: u32) -> Self {
10288         self.inner.attachment_count = attachment_count;
10289         self
10290     }
10291     #[inline]
attachments(mut self, attachments: &'a [ImageView]) -> Self10292     pub fn attachments(mut self, attachments: &'a [ImageView]) -> Self {
10293         self.inner.attachment_count = attachments.len() as _;
10294         self.inner.p_attachments = attachments.as_ptr();
10295         self
10296     }
10297     #[inline]
width(mut self, width: u32) -> Self10298     pub fn width(mut self, width: u32) -> Self {
10299         self.inner.width = width;
10300         self
10301     }
10302     #[inline]
height(mut self, height: u32) -> Self10303     pub fn height(mut self, height: u32) -> Self {
10304         self.inner.height = height;
10305         self
10306     }
10307     #[inline]
layers(mut self, layers: u32) -> Self10308     pub fn layers(mut self, layers: u32) -> Self {
10309         self.inner.layers = layers;
10310         self
10311     }
10312     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
10313     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
10314     #[doc = r" valid extension structs can be pushed into the chain."]
10315     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
10316     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsFramebufferCreateInfo>(mut self, next: &'a mut T) -> Self10317     pub fn push_next<T: ExtendsFramebufferCreateInfo>(mut self, next: &'a mut T) -> Self {
10318         unsafe {
10319             let next_ptr = <*const T>::cast(next);
10320             let last_next = ptr_chain_iter(next).last().unwrap();
10321             (*last_next).p_next = self.inner.p_next as _;
10322             self.inner.p_next = next_ptr;
10323         }
10324         self
10325     }
10326     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10327     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10328     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> FramebufferCreateInfo10329     pub fn build(self) -> FramebufferCreateInfo {
10330         self.inner
10331     }
10332 }
10333 #[repr(C)]
10334 #[cfg_attr(feature = "debug", derive(Debug))]
10335 #[derive(Copy, Clone, Default)]
10336 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrawIndirectCommand.html>"]
10337 pub struct DrawIndirectCommand {
10338     pub vertex_count: u32,
10339     pub instance_count: u32,
10340     pub first_vertex: u32,
10341     pub first_instance: u32,
10342 }
10343 impl DrawIndirectCommand {
builder<'a>() -> DrawIndirectCommandBuilder<'a>10344     pub fn builder<'a>() -> DrawIndirectCommandBuilder<'a> {
10345         DrawIndirectCommandBuilder {
10346             inner: Self::default(),
10347             marker: ::std::marker::PhantomData,
10348         }
10349     }
10350 }
10351 #[repr(transparent)]
10352 pub struct DrawIndirectCommandBuilder<'a> {
10353     inner: DrawIndirectCommand,
10354     marker: ::std::marker::PhantomData<&'a ()>,
10355 }
10356 impl<'a> ::std::ops::Deref for DrawIndirectCommandBuilder<'a> {
10357     type Target = DrawIndirectCommand;
deref(&self) -> &Self::Target10358     fn deref(&self) -> &Self::Target {
10359         &self.inner
10360     }
10361 }
10362 impl<'a> ::std::ops::DerefMut for DrawIndirectCommandBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target10363     fn deref_mut(&mut self) -> &mut Self::Target {
10364         &mut self.inner
10365     }
10366 }
10367 impl<'a> DrawIndirectCommandBuilder<'a> {
10368     #[inline]
vertex_count(mut self, vertex_count: u32) -> Self10369     pub fn vertex_count(mut self, vertex_count: u32) -> Self {
10370         self.inner.vertex_count = vertex_count;
10371         self
10372     }
10373     #[inline]
instance_count(mut self, instance_count: u32) -> Self10374     pub fn instance_count(mut self, instance_count: u32) -> Self {
10375         self.inner.instance_count = instance_count;
10376         self
10377     }
10378     #[inline]
first_vertex(mut self, first_vertex: u32) -> Self10379     pub fn first_vertex(mut self, first_vertex: u32) -> Self {
10380         self.inner.first_vertex = first_vertex;
10381         self
10382     }
10383     #[inline]
first_instance(mut self, first_instance: u32) -> Self10384     pub fn first_instance(mut self, first_instance: u32) -> Self {
10385         self.inner.first_instance = first_instance;
10386         self
10387     }
10388     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10389     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10390     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DrawIndirectCommand10391     pub fn build(self) -> DrawIndirectCommand {
10392         self.inner
10393     }
10394 }
10395 #[repr(C)]
10396 #[cfg_attr(feature = "debug", derive(Debug))]
10397 #[derive(Copy, Clone, Default)]
10398 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrawIndexedIndirectCommand.html>"]
10399 pub struct DrawIndexedIndirectCommand {
10400     pub index_count: u32,
10401     pub instance_count: u32,
10402     pub first_index: u32,
10403     pub vertex_offset: i32,
10404     pub first_instance: u32,
10405 }
10406 impl DrawIndexedIndirectCommand {
builder<'a>() -> DrawIndexedIndirectCommandBuilder<'a>10407     pub fn builder<'a>() -> DrawIndexedIndirectCommandBuilder<'a> {
10408         DrawIndexedIndirectCommandBuilder {
10409             inner: Self::default(),
10410             marker: ::std::marker::PhantomData,
10411         }
10412     }
10413 }
10414 #[repr(transparent)]
10415 pub struct DrawIndexedIndirectCommandBuilder<'a> {
10416     inner: DrawIndexedIndirectCommand,
10417     marker: ::std::marker::PhantomData<&'a ()>,
10418 }
10419 impl<'a> ::std::ops::Deref for DrawIndexedIndirectCommandBuilder<'a> {
10420     type Target = DrawIndexedIndirectCommand;
deref(&self) -> &Self::Target10421     fn deref(&self) -> &Self::Target {
10422         &self.inner
10423     }
10424 }
10425 impl<'a> ::std::ops::DerefMut for DrawIndexedIndirectCommandBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target10426     fn deref_mut(&mut self) -> &mut Self::Target {
10427         &mut self.inner
10428     }
10429 }
10430 impl<'a> DrawIndexedIndirectCommandBuilder<'a> {
10431     #[inline]
index_count(mut self, index_count: u32) -> Self10432     pub fn index_count(mut self, index_count: u32) -> Self {
10433         self.inner.index_count = index_count;
10434         self
10435     }
10436     #[inline]
instance_count(mut self, instance_count: u32) -> Self10437     pub fn instance_count(mut self, instance_count: u32) -> Self {
10438         self.inner.instance_count = instance_count;
10439         self
10440     }
10441     #[inline]
first_index(mut self, first_index: u32) -> Self10442     pub fn first_index(mut self, first_index: u32) -> Self {
10443         self.inner.first_index = first_index;
10444         self
10445     }
10446     #[inline]
vertex_offset(mut self, vertex_offset: i32) -> Self10447     pub fn vertex_offset(mut self, vertex_offset: i32) -> Self {
10448         self.inner.vertex_offset = vertex_offset;
10449         self
10450     }
10451     #[inline]
first_instance(mut self, first_instance: u32) -> Self10452     pub fn first_instance(mut self, first_instance: u32) -> Self {
10453         self.inner.first_instance = first_instance;
10454         self
10455     }
10456     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10457     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10458     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DrawIndexedIndirectCommand10459     pub fn build(self) -> DrawIndexedIndirectCommand {
10460         self.inner
10461     }
10462 }
10463 #[repr(C)]
10464 #[cfg_attr(feature = "debug", derive(Debug))]
10465 #[derive(Copy, Clone, Default)]
10466 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDispatchIndirectCommand.html>"]
10467 pub struct DispatchIndirectCommand {
10468     pub x: u32,
10469     pub y: u32,
10470     pub z: u32,
10471 }
10472 impl DispatchIndirectCommand {
builder<'a>() -> DispatchIndirectCommandBuilder<'a>10473     pub fn builder<'a>() -> DispatchIndirectCommandBuilder<'a> {
10474         DispatchIndirectCommandBuilder {
10475             inner: Self::default(),
10476             marker: ::std::marker::PhantomData,
10477         }
10478     }
10479 }
10480 #[repr(transparent)]
10481 pub struct DispatchIndirectCommandBuilder<'a> {
10482     inner: DispatchIndirectCommand,
10483     marker: ::std::marker::PhantomData<&'a ()>,
10484 }
10485 impl<'a> ::std::ops::Deref for DispatchIndirectCommandBuilder<'a> {
10486     type Target = DispatchIndirectCommand;
deref(&self) -> &Self::Target10487     fn deref(&self) -> &Self::Target {
10488         &self.inner
10489     }
10490 }
10491 impl<'a> ::std::ops::DerefMut for DispatchIndirectCommandBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target10492     fn deref_mut(&mut self) -> &mut Self::Target {
10493         &mut self.inner
10494     }
10495 }
10496 impl<'a> DispatchIndirectCommandBuilder<'a> {
10497     #[inline]
x(mut self, x: u32) -> Self10498     pub fn x(mut self, x: u32) -> Self {
10499         self.inner.x = x;
10500         self
10501     }
10502     #[inline]
y(mut self, y: u32) -> Self10503     pub fn y(mut self, y: u32) -> Self {
10504         self.inner.y = y;
10505         self
10506     }
10507     #[inline]
z(mut self, z: u32) -> Self10508     pub fn z(mut self, z: u32) -> Self {
10509         self.inner.z = z;
10510         self
10511     }
10512     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10513     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10514     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DispatchIndirectCommand10515     pub fn build(self) -> DispatchIndirectCommand {
10516         self.inner
10517     }
10518 }
10519 #[repr(C)]
10520 #[cfg_attr(feature = "debug", derive(Debug))]
10521 #[derive(Copy, Clone, Default)]
10522 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMultiDrawInfoEXT.html>"]
10523 pub struct MultiDrawInfoEXT {
10524     pub first_vertex: u32,
10525     pub vertex_count: u32,
10526 }
10527 impl MultiDrawInfoEXT {
builder<'a>() -> MultiDrawInfoEXTBuilder<'a>10528     pub fn builder<'a>() -> MultiDrawInfoEXTBuilder<'a> {
10529         MultiDrawInfoEXTBuilder {
10530             inner: Self::default(),
10531             marker: ::std::marker::PhantomData,
10532         }
10533     }
10534 }
10535 #[repr(transparent)]
10536 pub struct MultiDrawInfoEXTBuilder<'a> {
10537     inner: MultiDrawInfoEXT,
10538     marker: ::std::marker::PhantomData<&'a ()>,
10539 }
10540 impl<'a> ::std::ops::Deref for MultiDrawInfoEXTBuilder<'a> {
10541     type Target = MultiDrawInfoEXT;
deref(&self) -> &Self::Target10542     fn deref(&self) -> &Self::Target {
10543         &self.inner
10544     }
10545 }
10546 impl<'a> ::std::ops::DerefMut for MultiDrawInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target10547     fn deref_mut(&mut self) -> &mut Self::Target {
10548         &mut self.inner
10549     }
10550 }
10551 impl<'a> MultiDrawInfoEXTBuilder<'a> {
10552     #[inline]
first_vertex(mut self, first_vertex: u32) -> Self10553     pub fn first_vertex(mut self, first_vertex: u32) -> Self {
10554         self.inner.first_vertex = first_vertex;
10555         self
10556     }
10557     #[inline]
vertex_count(mut self, vertex_count: u32) -> Self10558     pub fn vertex_count(mut self, vertex_count: u32) -> Self {
10559         self.inner.vertex_count = vertex_count;
10560         self
10561     }
10562     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10563     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10564     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MultiDrawInfoEXT10565     pub fn build(self) -> MultiDrawInfoEXT {
10566         self.inner
10567     }
10568 }
10569 #[repr(C)]
10570 #[cfg_attr(feature = "debug", derive(Debug))]
10571 #[derive(Copy, Clone, Default)]
10572 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMultiDrawIndexedInfoEXT.html>"]
10573 pub struct MultiDrawIndexedInfoEXT {
10574     pub first_index: u32,
10575     pub index_count: u32,
10576     pub vertex_offset: i32,
10577 }
10578 impl MultiDrawIndexedInfoEXT {
builder<'a>() -> MultiDrawIndexedInfoEXTBuilder<'a>10579     pub fn builder<'a>() -> MultiDrawIndexedInfoEXTBuilder<'a> {
10580         MultiDrawIndexedInfoEXTBuilder {
10581             inner: Self::default(),
10582             marker: ::std::marker::PhantomData,
10583         }
10584     }
10585 }
10586 #[repr(transparent)]
10587 pub struct MultiDrawIndexedInfoEXTBuilder<'a> {
10588     inner: MultiDrawIndexedInfoEXT,
10589     marker: ::std::marker::PhantomData<&'a ()>,
10590 }
10591 impl<'a> ::std::ops::Deref for MultiDrawIndexedInfoEXTBuilder<'a> {
10592     type Target = MultiDrawIndexedInfoEXT;
deref(&self) -> &Self::Target10593     fn deref(&self) -> &Self::Target {
10594         &self.inner
10595     }
10596 }
10597 impl<'a> ::std::ops::DerefMut for MultiDrawIndexedInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target10598     fn deref_mut(&mut self) -> &mut Self::Target {
10599         &mut self.inner
10600     }
10601 }
10602 impl<'a> MultiDrawIndexedInfoEXTBuilder<'a> {
10603     #[inline]
first_index(mut self, first_index: u32) -> Self10604     pub fn first_index(mut self, first_index: u32) -> Self {
10605         self.inner.first_index = first_index;
10606         self
10607     }
10608     #[inline]
index_count(mut self, index_count: u32) -> Self10609     pub fn index_count(mut self, index_count: u32) -> Self {
10610         self.inner.index_count = index_count;
10611         self
10612     }
10613     #[inline]
vertex_offset(mut self, vertex_offset: i32) -> Self10614     pub fn vertex_offset(mut self, vertex_offset: i32) -> Self {
10615         self.inner.vertex_offset = vertex_offset;
10616         self
10617     }
10618     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10619     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10620     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MultiDrawIndexedInfoEXT10621     pub fn build(self) -> MultiDrawIndexedInfoEXT {
10622         self.inner
10623     }
10624 }
10625 #[repr(C)]
10626 #[cfg_attr(feature = "debug", derive(Debug))]
10627 #[derive(Copy, Clone)]
10628 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubmitInfo.html>"]
10629 pub struct SubmitInfo {
10630     pub s_type: StructureType,
10631     pub p_next: *const c_void,
10632     pub wait_semaphore_count: u32,
10633     pub p_wait_semaphores: *const Semaphore,
10634     pub p_wait_dst_stage_mask: *const PipelineStageFlags,
10635     pub command_buffer_count: u32,
10636     pub p_command_buffers: *const CommandBuffer,
10637     pub signal_semaphore_count: u32,
10638     pub p_signal_semaphores: *const Semaphore,
10639 }
10640 impl ::std::default::Default for SubmitInfo {
10641     #[inline]
default() -> Self10642     fn default() -> Self {
10643         Self {
10644             s_type: Self::STRUCTURE_TYPE,
10645             p_next: ::std::ptr::null(),
10646             wait_semaphore_count: u32::default(),
10647             p_wait_semaphores: ::std::ptr::null(),
10648             p_wait_dst_stage_mask: ::std::ptr::null(),
10649             command_buffer_count: u32::default(),
10650             p_command_buffers: ::std::ptr::null(),
10651             signal_semaphore_count: u32::default(),
10652             p_signal_semaphores: ::std::ptr::null(),
10653         }
10654     }
10655 }
10656 unsafe impl TaggedStructure for SubmitInfo {
10657     const STRUCTURE_TYPE: StructureType = StructureType::SUBMIT_INFO;
10658 }
10659 impl SubmitInfo {
builder<'a>() -> SubmitInfoBuilder<'a>10660     pub fn builder<'a>() -> SubmitInfoBuilder<'a> {
10661         SubmitInfoBuilder {
10662             inner: Self::default(),
10663             marker: ::std::marker::PhantomData,
10664         }
10665     }
10666 }
10667 #[repr(transparent)]
10668 pub struct SubmitInfoBuilder<'a> {
10669     inner: SubmitInfo,
10670     marker: ::std::marker::PhantomData<&'a ()>,
10671 }
10672 pub unsafe trait ExtendsSubmitInfo {}
10673 impl<'a> ::std::ops::Deref for SubmitInfoBuilder<'a> {
10674     type Target = SubmitInfo;
deref(&self) -> &Self::Target10675     fn deref(&self) -> &Self::Target {
10676         &self.inner
10677     }
10678 }
10679 impl<'a> ::std::ops::DerefMut for SubmitInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target10680     fn deref_mut(&mut self) -> &mut Self::Target {
10681         &mut self.inner
10682     }
10683 }
10684 impl<'a> SubmitInfoBuilder<'a> {
10685     #[inline]
wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> Self10686     pub fn wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> Self {
10687         self.inner.wait_semaphore_count = wait_semaphores.len() as _;
10688         self.inner.p_wait_semaphores = wait_semaphores.as_ptr();
10689         self
10690     }
10691     #[inline]
wait_dst_stage_mask(mut self, wait_dst_stage_mask: &'a [PipelineStageFlags]) -> Self10692     pub fn wait_dst_stage_mask(mut self, wait_dst_stage_mask: &'a [PipelineStageFlags]) -> Self {
10693         self.inner.wait_semaphore_count = wait_dst_stage_mask.len() as _;
10694         self.inner.p_wait_dst_stage_mask = wait_dst_stage_mask.as_ptr();
10695         self
10696     }
10697     #[inline]
command_buffers(mut self, command_buffers: &'a [CommandBuffer]) -> Self10698     pub fn command_buffers(mut self, command_buffers: &'a [CommandBuffer]) -> Self {
10699         self.inner.command_buffer_count = command_buffers.len() as _;
10700         self.inner.p_command_buffers = command_buffers.as_ptr();
10701         self
10702     }
10703     #[inline]
signal_semaphores(mut self, signal_semaphores: &'a [Semaphore]) -> Self10704     pub fn signal_semaphores(mut self, signal_semaphores: &'a [Semaphore]) -> Self {
10705         self.inner.signal_semaphore_count = signal_semaphores.len() as _;
10706         self.inner.p_signal_semaphores = signal_semaphores.as_ptr();
10707         self
10708     }
10709     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
10710     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
10711     #[doc = r" valid extension structs can be pushed into the chain."]
10712     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
10713     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSubmitInfo>(mut self, next: &'a mut T) -> Self10714     pub fn push_next<T: ExtendsSubmitInfo>(mut self, next: &'a mut T) -> Self {
10715         unsafe {
10716             let next_ptr = <*const T>::cast(next);
10717             let last_next = ptr_chain_iter(next).last().unwrap();
10718             (*last_next).p_next = self.inner.p_next as _;
10719             self.inner.p_next = next_ptr;
10720         }
10721         self
10722     }
10723     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10724     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10725     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SubmitInfo10726     pub fn build(self) -> SubmitInfo {
10727         self.inner
10728     }
10729 }
10730 #[repr(C)]
10731 #[cfg_attr(feature = "debug", derive(Debug))]
10732 #[derive(Copy, Clone)]
10733 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPropertiesKHR.html>"]
10734 pub struct DisplayPropertiesKHR {
10735     pub display: DisplayKHR,
10736     pub display_name: *const c_char,
10737     pub physical_dimensions: Extent2D,
10738     pub physical_resolution: Extent2D,
10739     pub supported_transforms: SurfaceTransformFlagsKHR,
10740     pub plane_reorder_possible: Bool32,
10741     pub persistent_content: Bool32,
10742 }
10743 impl ::std::default::Default for DisplayPropertiesKHR {
10744     #[inline]
default() -> Self10745     fn default() -> Self {
10746         Self {
10747             display: DisplayKHR::default(),
10748             display_name: ::std::ptr::null(),
10749             physical_dimensions: Extent2D::default(),
10750             physical_resolution: Extent2D::default(),
10751             supported_transforms: SurfaceTransformFlagsKHR::default(),
10752             plane_reorder_possible: Bool32::default(),
10753             persistent_content: Bool32::default(),
10754         }
10755     }
10756 }
10757 impl DisplayPropertiesKHR {
builder<'a>() -> DisplayPropertiesKHRBuilder<'a>10758     pub fn builder<'a>() -> DisplayPropertiesKHRBuilder<'a> {
10759         DisplayPropertiesKHRBuilder {
10760             inner: Self::default(),
10761             marker: ::std::marker::PhantomData,
10762         }
10763     }
10764 }
10765 #[repr(transparent)]
10766 pub struct DisplayPropertiesKHRBuilder<'a> {
10767     inner: DisplayPropertiesKHR,
10768     marker: ::std::marker::PhantomData<&'a ()>,
10769 }
10770 impl<'a> ::std::ops::Deref for DisplayPropertiesKHRBuilder<'a> {
10771     type Target = DisplayPropertiesKHR;
deref(&self) -> &Self::Target10772     fn deref(&self) -> &Self::Target {
10773         &self.inner
10774     }
10775 }
10776 impl<'a> ::std::ops::DerefMut for DisplayPropertiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target10777     fn deref_mut(&mut self) -> &mut Self::Target {
10778         &mut self.inner
10779     }
10780 }
10781 impl<'a> DisplayPropertiesKHRBuilder<'a> {
10782     #[inline]
display(mut self, display: DisplayKHR) -> Self10783     pub fn display(mut self, display: DisplayKHR) -> Self {
10784         self.inner.display = display;
10785         self
10786     }
10787     #[inline]
display_name(mut self, display_name: &'a ::std::ffi::CStr) -> Self10788     pub fn display_name(mut self, display_name: &'a ::std::ffi::CStr) -> Self {
10789         self.inner.display_name = display_name.as_ptr();
10790         self
10791     }
10792     #[inline]
physical_dimensions(mut self, physical_dimensions: Extent2D) -> Self10793     pub fn physical_dimensions(mut self, physical_dimensions: Extent2D) -> Self {
10794         self.inner.physical_dimensions = physical_dimensions;
10795         self
10796     }
10797     #[inline]
physical_resolution(mut self, physical_resolution: Extent2D) -> Self10798     pub fn physical_resolution(mut self, physical_resolution: Extent2D) -> Self {
10799         self.inner.physical_resolution = physical_resolution;
10800         self
10801     }
10802     #[inline]
supported_transforms(mut self, supported_transforms: SurfaceTransformFlagsKHR) -> Self10803     pub fn supported_transforms(mut self, supported_transforms: SurfaceTransformFlagsKHR) -> Self {
10804         self.inner.supported_transforms = supported_transforms;
10805         self
10806     }
10807     #[inline]
plane_reorder_possible(mut self, plane_reorder_possible: bool) -> Self10808     pub fn plane_reorder_possible(mut self, plane_reorder_possible: bool) -> Self {
10809         self.inner.plane_reorder_possible = plane_reorder_possible.into();
10810         self
10811     }
10812     #[inline]
persistent_content(mut self, persistent_content: bool) -> Self10813     pub fn persistent_content(mut self, persistent_content: bool) -> Self {
10814         self.inner.persistent_content = persistent_content.into();
10815         self
10816     }
10817     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10818     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10819     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayPropertiesKHR10820     pub fn build(self) -> DisplayPropertiesKHR {
10821         self.inner
10822     }
10823 }
10824 #[repr(C)]
10825 #[cfg_attr(feature = "debug", derive(Debug))]
10826 #[derive(Copy, Clone, Default)]
10827 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPlanePropertiesKHR.html>"]
10828 pub struct DisplayPlanePropertiesKHR {
10829     pub current_display: DisplayKHR,
10830     pub current_stack_index: u32,
10831 }
10832 impl DisplayPlanePropertiesKHR {
builder<'a>() -> DisplayPlanePropertiesKHRBuilder<'a>10833     pub fn builder<'a>() -> DisplayPlanePropertiesKHRBuilder<'a> {
10834         DisplayPlanePropertiesKHRBuilder {
10835             inner: Self::default(),
10836             marker: ::std::marker::PhantomData,
10837         }
10838     }
10839 }
10840 #[repr(transparent)]
10841 pub struct DisplayPlanePropertiesKHRBuilder<'a> {
10842     inner: DisplayPlanePropertiesKHR,
10843     marker: ::std::marker::PhantomData<&'a ()>,
10844 }
10845 impl<'a> ::std::ops::Deref for DisplayPlanePropertiesKHRBuilder<'a> {
10846     type Target = DisplayPlanePropertiesKHR;
deref(&self) -> &Self::Target10847     fn deref(&self) -> &Self::Target {
10848         &self.inner
10849     }
10850 }
10851 impl<'a> ::std::ops::DerefMut for DisplayPlanePropertiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target10852     fn deref_mut(&mut self) -> &mut Self::Target {
10853         &mut self.inner
10854     }
10855 }
10856 impl<'a> DisplayPlanePropertiesKHRBuilder<'a> {
10857     #[inline]
current_display(mut self, current_display: DisplayKHR) -> Self10858     pub fn current_display(mut self, current_display: DisplayKHR) -> Self {
10859         self.inner.current_display = current_display;
10860         self
10861     }
10862     #[inline]
current_stack_index(mut self, current_stack_index: u32) -> Self10863     pub fn current_stack_index(mut self, current_stack_index: u32) -> Self {
10864         self.inner.current_stack_index = current_stack_index;
10865         self
10866     }
10867     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10868     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10869     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayPlanePropertiesKHR10870     pub fn build(self) -> DisplayPlanePropertiesKHR {
10871         self.inner
10872     }
10873 }
10874 #[repr(C)]
10875 #[cfg_attr(feature = "debug", derive(Debug))]
10876 #[derive(Copy, Clone, Default)]
10877 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModeParametersKHR.html>"]
10878 pub struct DisplayModeParametersKHR {
10879     pub visible_region: Extent2D,
10880     pub refresh_rate: u32,
10881 }
10882 impl DisplayModeParametersKHR {
builder<'a>() -> DisplayModeParametersKHRBuilder<'a>10883     pub fn builder<'a>() -> DisplayModeParametersKHRBuilder<'a> {
10884         DisplayModeParametersKHRBuilder {
10885             inner: Self::default(),
10886             marker: ::std::marker::PhantomData,
10887         }
10888     }
10889 }
10890 #[repr(transparent)]
10891 pub struct DisplayModeParametersKHRBuilder<'a> {
10892     inner: DisplayModeParametersKHR,
10893     marker: ::std::marker::PhantomData<&'a ()>,
10894 }
10895 impl<'a> ::std::ops::Deref for DisplayModeParametersKHRBuilder<'a> {
10896     type Target = DisplayModeParametersKHR;
deref(&self) -> &Self::Target10897     fn deref(&self) -> &Self::Target {
10898         &self.inner
10899     }
10900 }
10901 impl<'a> ::std::ops::DerefMut for DisplayModeParametersKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target10902     fn deref_mut(&mut self) -> &mut Self::Target {
10903         &mut self.inner
10904     }
10905 }
10906 impl<'a> DisplayModeParametersKHRBuilder<'a> {
10907     #[inline]
visible_region(mut self, visible_region: Extent2D) -> Self10908     pub fn visible_region(mut self, visible_region: Extent2D) -> Self {
10909         self.inner.visible_region = visible_region;
10910         self
10911     }
10912     #[inline]
refresh_rate(mut self, refresh_rate: u32) -> Self10913     pub fn refresh_rate(mut self, refresh_rate: u32) -> Self {
10914         self.inner.refresh_rate = refresh_rate;
10915         self
10916     }
10917     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10918     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10919     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayModeParametersKHR10920     pub fn build(self) -> DisplayModeParametersKHR {
10921         self.inner
10922     }
10923 }
10924 #[repr(C)]
10925 #[cfg_attr(feature = "debug", derive(Debug))]
10926 #[derive(Copy, Clone, Default)]
10927 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModePropertiesKHR.html>"]
10928 pub struct DisplayModePropertiesKHR {
10929     pub display_mode: DisplayModeKHR,
10930     pub parameters: DisplayModeParametersKHR,
10931 }
10932 impl DisplayModePropertiesKHR {
builder<'a>() -> DisplayModePropertiesKHRBuilder<'a>10933     pub fn builder<'a>() -> DisplayModePropertiesKHRBuilder<'a> {
10934         DisplayModePropertiesKHRBuilder {
10935             inner: Self::default(),
10936             marker: ::std::marker::PhantomData,
10937         }
10938     }
10939 }
10940 #[repr(transparent)]
10941 pub struct DisplayModePropertiesKHRBuilder<'a> {
10942     inner: DisplayModePropertiesKHR,
10943     marker: ::std::marker::PhantomData<&'a ()>,
10944 }
10945 impl<'a> ::std::ops::Deref for DisplayModePropertiesKHRBuilder<'a> {
10946     type Target = DisplayModePropertiesKHR;
deref(&self) -> &Self::Target10947     fn deref(&self) -> &Self::Target {
10948         &self.inner
10949     }
10950 }
10951 impl<'a> ::std::ops::DerefMut for DisplayModePropertiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target10952     fn deref_mut(&mut self) -> &mut Self::Target {
10953         &mut self.inner
10954     }
10955 }
10956 impl<'a> DisplayModePropertiesKHRBuilder<'a> {
10957     #[inline]
display_mode(mut self, display_mode: DisplayModeKHR) -> Self10958     pub fn display_mode(mut self, display_mode: DisplayModeKHR) -> Self {
10959         self.inner.display_mode = display_mode;
10960         self
10961     }
10962     #[inline]
parameters(mut self, parameters: DisplayModeParametersKHR) -> Self10963     pub fn parameters(mut self, parameters: DisplayModeParametersKHR) -> Self {
10964         self.inner.parameters = parameters;
10965         self
10966     }
10967     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10968     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10969     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayModePropertiesKHR10970     pub fn build(self) -> DisplayModePropertiesKHR {
10971         self.inner
10972     }
10973 }
10974 #[repr(C)]
10975 #[cfg_attr(feature = "debug", derive(Debug))]
10976 #[derive(Copy, Clone)]
10977 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModeCreateInfoKHR.html>"]
10978 pub struct DisplayModeCreateInfoKHR {
10979     pub s_type: StructureType,
10980     pub p_next: *const c_void,
10981     pub flags: DisplayModeCreateFlagsKHR,
10982     pub parameters: DisplayModeParametersKHR,
10983 }
10984 impl ::std::default::Default for DisplayModeCreateInfoKHR {
10985     #[inline]
default() -> Self10986     fn default() -> Self {
10987         Self {
10988             s_type: Self::STRUCTURE_TYPE,
10989             p_next: ::std::ptr::null(),
10990             flags: DisplayModeCreateFlagsKHR::default(),
10991             parameters: DisplayModeParametersKHR::default(),
10992         }
10993     }
10994 }
10995 unsafe impl TaggedStructure for DisplayModeCreateInfoKHR {
10996     const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_MODE_CREATE_INFO_KHR;
10997 }
10998 impl DisplayModeCreateInfoKHR {
builder<'a>() -> DisplayModeCreateInfoKHRBuilder<'a>10999     pub fn builder<'a>() -> DisplayModeCreateInfoKHRBuilder<'a> {
11000         DisplayModeCreateInfoKHRBuilder {
11001             inner: Self::default(),
11002             marker: ::std::marker::PhantomData,
11003         }
11004     }
11005 }
11006 #[repr(transparent)]
11007 pub struct DisplayModeCreateInfoKHRBuilder<'a> {
11008     inner: DisplayModeCreateInfoKHR,
11009     marker: ::std::marker::PhantomData<&'a ()>,
11010 }
11011 impl<'a> ::std::ops::Deref for DisplayModeCreateInfoKHRBuilder<'a> {
11012     type Target = DisplayModeCreateInfoKHR;
deref(&self) -> &Self::Target11013     fn deref(&self) -> &Self::Target {
11014         &self.inner
11015     }
11016 }
11017 impl<'a> ::std::ops::DerefMut for DisplayModeCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target11018     fn deref_mut(&mut self) -> &mut Self::Target {
11019         &mut self.inner
11020     }
11021 }
11022 impl<'a> DisplayModeCreateInfoKHRBuilder<'a> {
11023     #[inline]
flags(mut self, flags: DisplayModeCreateFlagsKHR) -> Self11024     pub fn flags(mut self, flags: DisplayModeCreateFlagsKHR) -> Self {
11025         self.inner.flags = flags;
11026         self
11027     }
11028     #[inline]
parameters(mut self, parameters: DisplayModeParametersKHR) -> Self11029     pub fn parameters(mut self, parameters: DisplayModeParametersKHR) -> Self {
11030         self.inner.parameters = parameters;
11031         self
11032     }
11033     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11034     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11035     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayModeCreateInfoKHR11036     pub fn build(self) -> DisplayModeCreateInfoKHR {
11037         self.inner
11038     }
11039 }
11040 #[repr(C)]
11041 #[cfg_attr(feature = "debug", derive(Debug))]
11042 #[derive(Copy, Clone, Default)]
11043 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPlaneCapabilitiesKHR.html>"]
11044 pub struct DisplayPlaneCapabilitiesKHR {
11045     pub supported_alpha: DisplayPlaneAlphaFlagsKHR,
11046     pub min_src_position: Offset2D,
11047     pub max_src_position: Offset2D,
11048     pub min_src_extent: Extent2D,
11049     pub max_src_extent: Extent2D,
11050     pub min_dst_position: Offset2D,
11051     pub max_dst_position: Offset2D,
11052     pub min_dst_extent: Extent2D,
11053     pub max_dst_extent: Extent2D,
11054 }
11055 impl DisplayPlaneCapabilitiesKHR {
builder<'a>() -> DisplayPlaneCapabilitiesKHRBuilder<'a>11056     pub fn builder<'a>() -> DisplayPlaneCapabilitiesKHRBuilder<'a> {
11057         DisplayPlaneCapabilitiesKHRBuilder {
11058             inner: Self::default(),
11059             marker: ::std::marker::PhantomData,
11060         }
11061     }
11062 }
11063 #[repr(transparent)]
11064 pub struct DisplayPlaneCapabilitiesKHRBuilder<'a> {
11065     inner: DisplayPlaneCapabilitiesKHR,
11066     marker: ::std::marker::PhantomData<&'a ()>,
11067 }
11068 impl<'a> ::std::ops::Deref for DisplayPlaneCapabilitiesKHRBuilder<'a> {
11069     type Target = DisplayPlaneCapabilitiesKHR;
deref(&self) -> &Self::Target11070     fn deref(&self) -> &Self::Target {
11071         &self.inner
11072     }
11073 }
11074 impl<'a> ::std::ops::DerefMut for DisplayPlaneCapabilitiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target11075     fn deref_mut(&mut self) -> &mut Self::Target {
11076         &mut self.inner
11077     }
11078 }
11079 impl<'a> DisplayPlaneCapabilitiesKHRBuilder<'a> {
11080     #[inline]
supported_alpha(mut self, supported_alpha: DisplayPlaneAlphaFlagsKHR) -> Self11081     pub fn supported_alpha(mut self, supported_alpha: DisplayPlaneAlphaFlagsKHR) -> Self {
11082         self.inner.supported_alpha = supported_alpha;
11083         self
11084     }
11085     #[inline]
min_src_position(mut self, min_src_position: Offset2D) -> Self11086     pub fn min_src_position(mut self, min_src_position: Offset2D) -> Self {
11087         self.inner.min_src_position = min_src_position;
11088         self
11089     }
11090     #[inline]
max_src_position(mut self, max_src_position: Offset2D) -> Self11091     pub fn max_src_position(mut self, max_src_position: Offset2D) -> Self {
11092         self.inner.max_src_position = max_src_position;
11093         self
11094     }
11095     #[inline]
min_src_extent(mut self, min_src_extent: Extent2D) -> Self11096     pub fn min_src_extent(mut self, min_src_extent: Extent2D) -> Self {
11097         self.inner.min_src_extent = min_src_extent;
11098         self
11099     }
11100     #[inline]
max_src_extent(mut self, max_src_extent: Extent2D) -> Self11101     pub fn max_src_extent(mut self, max_src_extent: Extent2D) -> Self {
11102         self.inner.max_src_extent = max_src_extent;
11103         self
11104     }
11105     #[inline]
min_dst_position(mut self, min_dst_position: Offset2D) -> Self11106     pub fn min_dst_position(mut self, min_dst_position: Offset2D) -> Self {
11107         self.inner.min_dst_position = min_dst_position;
11108         self
11109     }
11110     #[inline]
max_dst_position(mut self, max_dst_position: Offset2D) -> Self11111     pub fn max_dst_position(mut self, max_dst_position: Offset2D) -> Self {
11112         self.inner.max_dst_position = max_dst_position;
11113         self
11114     }
11115     #[inline]
min_dst_extent(mut self, min_dst_extent: Extent2D) -> Self11116     pub fn min_dst_extent(mut self, min_dst_extent: Extent2D) -> Self {
11117         self.inner.min_dst_extent = min_dst_extent;
11118         self
11119     }
11120     #[inline]
max_dst_extent(mut self, max_dst_extent: Extent2D) -> Self11121     pub fn max_dst_extent(mut self, max_dst_extent: Extent2D) -> Self {
11122         self.inner.max_dst_extent = max_dst_extent;
11123         self
11124     }
11125     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11126     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11127     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayPlaneCapabilitiesKHR11128     pub fn build(self) -> DisplayPlaneCapabilitiesKHR {
11129         self.inner
11130     }
11131 }
11132 #[repr(C)]
11133 #[cfg_attr(feature = "debug", derive(Debug))]
11134 #[derive(Copy, Clone)]
11135 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplaySurfaceCreateInfoKHR.html>"]
11136 pub struct DisplaySurfaceCreateInfoKHR {
11137     pub s_type: StructureType,
11138     pub p_next: *const c_void,
11139     pub flags: DisplaySurfaceCreateFlagsKHR,
11140     pub display_mode: DisplayModeKHR,
11141     pub plane_index: u32,
11142     pub plane_stack_index: u32,
11143     pub transform: SurfaceTransformFlagsKHR,
11144     pub global_alpha: f32,
11145     pub alpha_mode: DisplayPlaneAlphaFlagsKHR,
11146     pub image_extent: Extent2D,
11147 }
11148 impl ::std::default::Default for DisplaySurfaceCreateInfoKHR {
11149     #[inline]
default() -> Self11150     fn default() -> Self {
11151         Self {
11152             s_type: Self::STRUCTURE_TYPE,
11153             p_next: ::std::ptr::null(),
11154             flags: DisplaySurfaceCreateFlagsKHR::default(),
11155             display_mode: DisplayModeKHR::default(),
11156             plane_index: u32::default(),
11157             plane_stack_index: u32::default(),
11158             transform: SurfaceTransformFlagsKHR::default(),
11159             global_alpha: f32::default(),
11160             alpha_mode: DisplayPlaneAlphaFlagsKHR::default(),
11161             image_extent: Extent2D::default(),
11162         }
11163     }
11164 }
11165 unsafe impl TaggedStructure for DisplaySurfaceCreateInfoKHR {
11166     const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_SURFACE_CREATE_INFO_KHR;
11167 }
11168 impl DisplaySurfaceCreateInfoKHR {
builder<'a>() -> DisplaySurfaceCreateInfoKHRBuilder<'a>11169     pub fn builder<'a>() -> DisplaySurfaceCreateInfoKHRBuilder<'a> {
11170         DisplaySurfaceCreateInfoKHRBuilder {
11171             inner: Self::default(),
11172             marker: ::std::marker::PhantomData,
11173         }
11174     }
11175 }
11176 #[repr(transparent)]
11177 pub struct DisplaySurfaceCreateInfoKHRBuilder<'a> {
11178     inner: DisplaySurfaceCreateInfoKHR,
11179     marker: ::std::marker::PhantomData<&'a ()>,
11180 }
11181 impl<'a> ::std::ops::Deref for DisplaySurfaceCreateInfoKHRBuilder<'a> {
11182     type Target = DisplaySurfaceCreateInfoKHR;
deref(&self) -> &Self::Target11183     fn deref(&self) -> &Self::Target {
11184         &self.inner
11185     }
11186 }
11187 impl<'a> ::std::ops::DerefMut for DisplaySurfaceCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target11188     fn deref_mut(&mut self) -> &mut Self::Target {
11189         &mut self.inner
11190     }
11191 }
11192 impl<'a> DisplaySurfaceCreateInfoKHRBuilder<'a> {
11193     #[inline]
flags(mut self, flags: DisplaySurfaceCreateFlagsKHR) -> Self11194     pub fn flags(mut self, flags: DisplaySurfaceCreateFlagsKHR) -> Self {
11195         self.inner.flags = flags;
11196         self
11197     }
11198     #[inline]
display_mode(mut self, display_mode: DisplayModeKHR) -> Self11199     pub fn display_mode(mut self, display_mode: DisplayModeKHR) -> Self {
11200         self.inner.display_mode = display_mode;
11201         self
11202     }
11203     #[inline]
plane_index(mut self, plane_index: u32) -> Self11204     pub fn plane_index(mut self, plane_index: u32) -> Self {
11205         self.inner.plane_index = plane_index;
11206         self
11207     }
11208     #[inline]
plane_stack_index(mut self, plane_stack_index: u32) -> Self11209     pub fn plane_stack_index(mut self, plane_stack_index: u32) -> Self {
11210         self.inner.plane_stack_index = plane_stack_index;
11211         self
11212     }
11213     #[inline]
transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self11214     pub fn transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self {
11215         self.inner.transform = transform;
11216         self
11217     }
11218     #[inline]
global_alpha(mut self, global_alpha: f32) -> Self11219     pub fn global_alpha(mut self, global_alpha: f32) -> Self {
11220         self.inner.global_alpha = global_alpha;
11221         self
11222     }
11223     #[inline]
alpha_mode(mut self, alpha_mode: DisplayPlaneAlphaFlagsKHR) -> Self11224     pub fn alpha_mode(mut self, alpha_mode: DisplayPlaneAlphaFlagsKHR) -> Self {
11225         self.inner.alpha_mode = alpha_mode;
11226         self
11227     }
11228     #[inline]
image_extent(mut self, image_extent: Extent2D) -> Self11229     pub fn image_extent(mut self, image_extent: Extent2D) -> Self {
11230         self.inner.image_extent = image_extent;
11231         self
11232     }
11233     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11234     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11235     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplaySurfaceCreateInfoKHR11236     pub fn build(self) -> DisplaySurfaceCreateInfoKHR {
11237         self.inner
11238     }
11239 }
11240 #[repr(C)]
11241 #[cfg_attr(feature = "debug", derive(Debug))]
11242 #[derive(Copy, Clone)]
11243 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPresentInfoKHR.html>"]
11244 pub struct DisplayPresentInfoKHR {
11245     pub s_type: StructureType,
11246     pub p_next: *const c_void,
11247     pub src_rect: Rect2D,
11248     pub dst_rect: Rect2D,
11249     pub persistent: Bool32,
11250 }
11251 impl ::std::default::Default for DisplayPresentInfoKHR {
11252     #[inline]
default() -> Self11253     fn default() -> Self {
11254         Self {
11255             s_type: Self::STRUCTURE_TYPE,
11256             p_next: ::std::ptr::null(),
11257             src_rect: Rect2D::default(),
11258             dst_rect: Rect2D::default(),
11259             persistent: Bool32::default(),
11260         }
11261     }
11262 }
11263 unsafe impl TaggedStructure for DisplayPresentInfoKHR {
11264     const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_PRESENT_INFO_KHR;
11265 }
11266 impl DisplayPresentInfoKHR {
builder<'a>() -> DisplayPresentInfoKHRBuilder<'a>11267     pub fn builder<'a>() -> DisplayPresentInfoKHRBuilder<'a> {
11268         DisplayPresentInfoKHRBuilder {
11269             inner: Self::default(),
11270             marker: ::std::marker::PhantomData,
11271         }
11272     }
11273 }
11274 #[repr(transparent)]
11275 pub struct DisplayPresentInfoKHRBuilder<'a> {
11276     inner: DisplayPresentInfoKHR,
11277     marker: ::std::marker::PhantomData<&'a ()>,
11278 }
11279 unsafe impl ExtendsPresentInfoKHR for DisplayPresentInfoKHRBuilder<'_> {}
11280 unsafe impl ExtendsPresentInfoKHR for DisplayPresentInfoKHR {}
11281 impl<'a> ::std::ops::Deref for DisplayPresentInfoKHRBuilder<'a> {
11282     type Target = DisplayPresentInfoKHR;
deref(&self) -> &Self::Target11283     fn deref(&self) -> &Self::Target {
11284         &self.inner
11285     }
11286 }
11287 impl<'a> ::std::ops::DerefMut for DisplayPresentInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target11288     fn deref_mut(&mut self) -> &mut Self::Target {
11289         &mut self.inner
11290     }
11291 }
11292 impl<'a> DisplayPresentInfoKHRBuilder<'a> {
11293     #[inline]
src_rect(mut self, src_rect: Rect2D) -> Self11294     pub fn src_rect(mut self, src_rect: Rect2D) -> Self {
11295         self.inner.src_rect = src_rect;
11296         self
11297     }
11298     #[inline]
dst_rect(mut self, dst_rect: Rect2D) -> Self11299     pub fn dst_rect(mut self, dst_rect: Rect2D) -> Self {
11300         self.inner.dst_rect = dst_rect;
11301         self
11302     }
11303     #[inline]
persistent(mut self, persistent: bool) -> Self11304     pub fn persistent(mut self, persistent: bool) -> Self {
11305         self.inner.persistent = persistent.into();
11306         self
11307     }
11308     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11309     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11310     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayPresentInfoKHR11311     pub fn build(self) -> DisplayPresentInfoKHR {
11312         self.inner
11313     }
11314 }
11315 #[repr(C)]
11316 #[cfg_attr(feature = "debug", derive(Debug))]
11317 #[derive(Copy, Clone, Default)]
11318 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceCapabilitiesKHR.html>"]
11319 pub struct SurfaceCapabilitiesKHR {
11320     pub min_image_count: u32,
11321     pub max_image_count: u32,
11322     pub current_extent: Extent2D,
11323     pub min_image_extent: Extent2D,
11324     pub max_image_extent: Extent2D,
11325     pub max_image_array_layers: u32,
11326     pub supported_transforms: SurfaceTransformFlagsKHR,
11327     pub current_transform: SurfaceTransformFlagsKHR,
11328     pub supported_composite_alpha: CompositeAlphaFlagsKHR,
11329     pub supported_usage_flags: ImageUsageFlags,
11330 }
11331 impl SurfaceCapabilitiesKHR {
builder<'a>() -> SurfaceCapabilitiesKHRBuilder<'a>11332     pub fn builder<'a>() -> SurfaceCapabilitiesKHRBuilder<'a> {
11333         SurfaceCapabilitiesKHRBuilder {
11334             inner: Self::default(),
11335             marker: ::std::marker::PhantomData,
11336         }
11337     }
11338 }
11339 #[repr(transparent)]
11340 pub struct SurfaceCapabilitiesKHRBuilder<'a> {
11341     inner: SurfaceCapabilitiesKHR,
11342     marker: ::std::marker::PhantomData<&'a ()>,
11343 }
11344 impl<'a> ::std::ops::Deref for SurfaceCapabilitiesKHRBuilder<'a> {
11345     type Target = SurfaceCapabilitiesKHR;
deref(&self) -> &Self::Target11346     fn deref(&self) -> &Self::Target {
11347         &self.inner
11348     }
11349 }
11350 impl<'a> ::std::ops::DerefMut for SurfaceCapabilitiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target11351     fn deref_mut(&mut self) -> &mut Self::Target {
11352         &mut self.inner
11353     }
11354 }
11355 impl<'a> SurfaceCapabilitiesKHRBuilder<'a> {
11356     #[inline]
min_image_count(mut self, min_image_count: u32) -> Self11357     pub fn min_image_count(mut self, min_image_count: u32) -> Self {
11358         self.inner.min_image_count = min_image_count;
11359         self
11360     }
11361     #[inline]
max_image_count(mut self, max_image_count: u32) -> Self11362     pub fn max_image_count(mut self, max_image_count: u32) -> Self {
11363         self.inner.max_image_count = max_image_count;
11364         self
11365     }
11366     #[inline]
current_extent(mut self, current_extent: Extent2D) -> Self11367     pub fn current_extent(mut self, current_extent: Extent2D) -> Self {
11368         self.inner.current_extent = current_extent;
11369         self
11370     }
11371     #[inline]
min_image_extent(mut self, min_image_extent: Extent2D) -> Self11372     pub fn min_image_extent(mut self, min_image_extent: Extent2D) -> Self {
11373         self.inner.min_image_extent = min_image_extent;
11374         self
11375     }
11376     #[inline]
max_image_extent(mut self, max_image_extent: Extent2D) -> Self11377     pub fn max_image_extent(mut self, max_image_extent: Extent2D) -> Self {
11378         self.inner.max_image_extent = max_image_extent;
11379         self
11380     }
11381     #[inline]
max_image_array_layers(mut self, max_image_array_layers: u32) -> Self11382     pub fn max_image_array_layers(mut self, max_image_array_layers: u32) -> Self {
11383         self.inner.max_image_array_layers = max_image_array_layers;
11384         self
11385     }
11386     #[inline]
supported_transforms(mut self, supported_transforms: SurfaceTransformFlagsKHR) -> Self11387     pub fn supported_transforms(mut self, supported_transforms: SurfaceTransformFlagsKHR) -> Self {
11388         self.inner.supported_transforms = supported_transforms;
11389         self
11390     }
11391     #[inline]
current_transform(mut self, current_transform: SurfaceTransformFlagsKHR) -> Self11392     pub fn current_transform(mut self, current_transform: SurfaceTransformFlagsKHR) -> Self {
11393         self.inner.current_transform = current_transform;
11394         self
11395     }
11396     #[inline]
supported_composite_alpha( mut self, supported_composite_alpha: CompositeAlphaFlagsKHR, ) -> Self11397     pub fn supported_composite_alpha(
11398         mut self,
11399         supported_composite_alpha: CompositeAlphaFlagsKHR,
11400     ) -> Self {
11401         self.inner.supported_composite_alpha = supported_composite_alpha;
11402         self
11403     }
11404     #[inline]
supported_usage_flags(mut self, supported_usage_flags: ImageUsageFlags) -> Self11405     pub fn supported_usage_flags(mut self, supported_usage_flags: ImageUsageFlags) -> Self {
11406         self.inner.supported_usage_flags = supported_usage_flags;
11407         self
11408     }
11409     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11410     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11411     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SurfaceCapabilitiesKHR11412     pub fn build(self) -> SurfaceCapabilitiesKHR {
11413         self.inner
11414     }
11415 }
11416 #[repr(C)]
11417 #[cfg_attr(feature = "debug", derive(Debug))]
11418 #[derive(Copy, Clone)]
11419 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAndroidSurfaceCreateInfoKHR.html>"]
11420 pub struct AndroidSurfaceCreateInfoKHR {
11421     pub s_type: StructureType,
11422     pub p_next: *const c_void,
11423     pub flags: AndroidSurfaceCreateFlagsKHR,
11424     pub window: *mut ANativeWindow,
11425 }
11426 impl ::std::default::Default for AndroidSurfaceCreateInfoKHR {
11427     #[inline]
default() -> Self11428     fn default() -> Self {
11429         Self {
11430             s_type: Self::STRUCTURE_TYPE,
11431             p_next: ::std::ptr::null(),
11432             flags: AndroidSurfaceCreateFlagsKHR::default(),
11433             window: ::std::ptr::null_mut(),
11434         }
11435     }
11436 }
11437 unsafe impl TaggedStructure for AndroidSurfaceCreateInfoKHR {
11438     const STRUCTURE_TYPE: StructureType = StructureType::ANDROID_SURFACE_CREATE_INFO_KHR;
11439 }
11440 impl AndroidSurfaceCreateInfoKHR {
builder<'a>() -> AndroidSurfaceCreateInfoKHRBuilder<'a>11441     pub fn builder<'a>() -> AndroidSurfaceCreateInfoKHRBuilder<'a> {
11442         AndroidSurfaceCreateInfoKHRBuilder {
11443             inner: Self::default(),
11444             marker: ::std::marker::PhantomData,
11445         }
11446     }
11447 }
11448 #[repr(transparent)]
11449 pub struct AndroidSurfaceCreateInfoKHRBuilder<'a> {
11450     inner: AndroidSurfaceCreateInfoKHR,
11451     marker: ::std::marker::PhantomData<&'a ()>,
11452 }
11453 impl<'a> ::std::ops::Deref for AndroidSurfaceCreateInfoKHRBuilder<'a> {
11454     type Target = AndroidSurfaceCreateInfoKHR;
deref(&self) -> &Self::Target11455     fn deref(&self) -> &Self::Target {
11456         &self.inner
11457     }
11458 }
11459 impl<'a> ::std::ops::DerefMut for AndroidSurfaceCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target11460     fn deref_mut(&mut self) -> &mut Self::Target {
11461         &mut self.inner
11462     }
11463 }
11464 impl<'a> AndroidSurfaceCreateInfoKHRBuilder<'a> {
11465     #[inline]
flags(mut self, flags: AndroidSurfaceCreateFlagsKHR) -> Self11466     pub fn flags(mut self, flags: AndroidSurfaceCreateFlagsKHR) -> Self {
11467         self.inner.flags = flags;
11468         self
11469     }
11470     #[inline]
window(mut self, window: *mut ANativeWindow) -> Self11471     pub fn window(mut self, window: *mut ANativeWindow) -> Self {
11472         self.inner.window = window;
11473         self
11474     }
11475     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11476     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11477     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AndroidSurfaceCreateInfoKHR11478     pub fn build(self) -> AndroidSurfaceCreateInfoKHR {
11479         self.inner
11480     }
11481 }
11482 #[repr(C)]
11483 #[cfg_attr(feature = "debug", derive(Debug))]
11484 #[derive(Copy, Clone)]
11485 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkViSurfaceCreateInfoNN.html>"]
11486 pub struct ViSurfaceCreateInfoNN {
11487     pub s_type: StructureType,
11488     pub p_next: *const c_void,
11489     pub flags: ViSurfaceCreateFlagsNN,
11490     pub window: *mut c_void,
11491 }
11492 impl ::std::default::Default for ViSurfaceCreateInfoNN {
11493     #[inline]
default() -> Self11494     fn default() -> Self {
11495         Self {
11496             s_type: Self::STRUCTURE_TYPE,
11497             p_next: ::std::ptr::null(),
11498             flags: ViSurfaceCreateFlagsNN::default(),
11499             window: ::std::ptr::null_mut(),
11500         }
11501     }
11502 }
11503 unsafe impl TaggedStructure for ViSurfaceCreateInfoNN {
11504     const STRUCTURE_TYPE: StructureType = StructureType::VI_SURFACE_CREATE_INFO_NN;
11505 }
11506 impl ViSurfaceCreateInfoNN {
builder<'a>() -> ViSurfaceCreateInfoNNBuilder<'a>11507     pub fn builder<'a>() -> ViSurfaceCreateInfoNNBuilder<'a> {
11508         ViSurfaceCreateInfoNNBuilder {
11509             inner: Self::default(),
11510             marker: ::std::marker::PhantomData,
11511         }
11512     }
11513 }
11514 #[repr(transparent)]
11515 pub struct ViSurfaceCreateInfoNNBuilder<'a> {
11516     inner: ViSurfaceCreateInfoNN,
11517     marker: ::std::marker::PhantomData<&'a ()>,
11518 }
11519 impl<'a> ::std::ops::Deref for ViSurfaceCreateInfoNNBuilder<'a> {
11520     type Target = ViSurfaceCreateInfoNN;
deref(&self) -> &Self::Target11521     fn deref(&self) -> &Self::Target {
11522         &self.inner
11523     }
11524 }
11525 impl<'a> ::std::ops::DerefMut for ViSurfaceCreateInfoNNBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target11526     fn deref_mut(&mut self) -> &mut Self::Target {
11527         &mut self.inner
11528     }
11529 }
11530 impl<'a> ViSurfaceCreateInfoNNBuilder<'a> {
11531     #[inline]
flags(mut self, flags: ViSurfaceCreateFlagsNN) -> Self11532     pub fn flags(mut self, flags: ViSurfaceCreateFlagsNN) -> Self {
11533         self.inner.flags = flags;
11534         self
11535     }
11536     #[inline]
window(mut self, window: *mut c_void) -> Self11537     pub fn window(mut self, window: *mut c_void) -> Self {
11538         self.inner.window = window;
11539         self
11540     }
11541     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11542     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11543     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ViSurfaceCreateInfoNN11544     pub fn build(self) -> ViSurfaceCreateInfoNN {
11545         self.inner
11546     }
11547 }
11548 #[repr(C)]
11549 #[cfg_attr(feature = "debug", derive(Debug))]
11550 #[derive(Copy, Clone)]
11551 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWaylandSurfaceCreateInfoKHR.html>"]
11552 pub struct WaylandSurfaceCreateInfoKHR {
11553     pub s_type: StructureType,
11554     pub p_next: *const c_void,
11555     pub flags: WaylandSurfaceCreateFlagsKHR,
11556     pub display: *mut wl_display,
11557     pub surface: *mut wl_surface,
11558 }
11559 impl ::std::default::Default for WaylandSurfaceCreateInfoKHR {
11560     #[inline]
default() -> Self11561     fn default() -> Self {
11562         Self {
11563             s_type: Self::STRUCTURE_TYPE,
11564             p_next: ::std::ptr::null(),
11565             flags: WaylandSurfaceCreateFlagsKHR::default(),
11566             display: ::std::ptr::null_mut(),
11567             surface: ::std::ptr::null_mut(),
11568         }
11569     }
11570 }
11571 unsafe impl TaggedStructure for WaylandSurfaceCreateInfoKHR {
11572     const STRUCTURE_TYPE: StructureType = StructureType::WAYLAND_SURFACE_CREATE_INFO_KHR;
11573 }
11574 impl WaylandSurfaceCreateInfoKHR {
builder<'a>() -> WaylandSurfaceCreateInfoKHRBuilder<'a>11575     pub fn builder<'a>() -> WaylandSurfaceCreateInfoKHRBuilder<'a> {
11576         WaylandSurfaceCreateInfoKHRBuilder {
11577             inner: Self::default(),
11578             marker: ::std::marker::PhantomData,
11579         }
11580     }
11581 }
11582 #[repr(transparent)]
11583 pub struct WaylandSurfaceCreateInfoKHRBuilder<'a> {
11584     inner: WaylandSurfaceCreateInfoKHR,
11585     marker: ::std::marker::PhantomData<&'a ()>,
11586 }
11587 impl<'a> ::std::ops::Deref for WaylandSurfaceCreateInfoKHRBuilder<'a> {
11588     type Target = WaylandSurfaceCreateInfoKHR;
deref(&self) -> &Self::Target11589     fn deref(&self) -> &Self::Target {
11590         &self.inner
11591     }
11592 }
11593 impl<'a> ::std::ops::DerefMut for WaylandSurfaceCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target11594     fn deref_mut(&mut self) -> &mut Self::Target {
11595         &mut self.inner
11596     }
11597 }
11598 impl<'a> WaylandSurfaceCreateInfoKHRBuilder<'a> {
11599     #[inline]
flags(mut self, flags: WaylandSurfaceCreateFlagsKHR) -> Self11600     pub fn flags(mut self, flags: WaylandSurfaceCreateFlagsKHR) -> Self {
11601         self.inner.flags = flags;
11602         self
11603     }
11604     #[inline]
display(mut self, display: *mut wl_display) -> Self11605     pub fn display(mut self, display: *mut wl_display) -> Self {
11606         self.inner.display = display;
11607         self
11608     }
11609     #[inline]
surface(mut self, surface: *mut wl_surface) -> Self11610     pub fn surface(mut self, surface: *mut wl_surface) -> Self {
11611         self.inner.surface = surface;
11612         self
11613     }
11614     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11615     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11616     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> WaylandSurfaceCreateInfoKHR11617     pub fn build(self) -> WaylandSurfaceCreateInfoKHR {
11618         self.inner
11619     }
11620 }
11621 #[repr(C)]
11622 #[cfg_attr(feature = "debug", derive(Debug))]
11623 #[derive(Copy, Clone)]
11624 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWin32SurfaceCreateInfoKHR.html>"]
11625 pub struct Win32SurfaceCreateInfoKHR {
11626     pub s_type: StructureType,
11627     pub p_next: *const c_void,
11628     pub flags: Win32SurfaceCreateFlagsKHR,
11629     pub hinstance: HINSTANCE,
11630     pub hwnd: HWND,
11631 }
11632 impl ::std::default::Default for Win32SurfaceCreateInfoKHR {
11633     #[inline]
default() -> Self11634     fn default() -> Self {
11635         Self {
11636             s_type: Self::STRUCTURE_TYPE,
11637             p_next: ::std::ptr::null(),
11638             flags: Win32SurfaceCreateFlagsKHR::default(),
11639             hinstance: unsafe { ::std::mem::zeroed() },
11640             hwnd: unsafe { ::std::mem::zeroed() },
11641         }
11642     }
11643 }
11644 unsafe impl TaggedStructure for Win32SurfaceCreateInfoKHR {
11645     const STRUCTURE_TYPE: StructureType = StructureType::WIN32_SURFACE_CREATE_INFO_KHR;
11646 }
11647 impl Win32SurfaceCreateInfoKHR {
builder<'a>() -> Win32SurfaceCreateInfoKHRBuilder<'a>11648     pub fn builder<'a>() -> Win32SurfaceCreateInfoKHRBuilder<'a> {
11649         Win32SurfaceCreateInfoKHRBuilder {
11650             inner: Self::default(),
11651             marker: ::std::marker::PhantomData,
11652         }
11653     }
11654 }
11655 #[repr(transparent)]
11656 pub struct Win32SurfaceCreateInfoKHRBuilder<'a> {
11657     inner: Win32SurfaceCreateInfoKHR,
11658     marker: ::std::marker::PhantomData<&'a ()>,
11659 }
11660 impl<'a> ::std::ops::Deref for Win32SurfaceCreateInfoKHRBuilder<'a> {
11661     type Target = Win32SurfaceCreateInfoKHR;
deref(&self) -> &Self::Target11662     fn deref(&self) -> &Self::Target {
11663         &self.inner
11664     }
11665 }
11666 impl<'a> ::std::ops::DerefMut for Win32SurfaceCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target11667     fn deref_mut(&mut self) -> &mut Self::Target {
11668         &mut self.inner
11669     }
11670 }
11671 impl<'a> Win32SurfaceCreateInfoKHRBuilder<'a> {
11672     #[inline]
flags(mut self, flags: Win32SurfaceCreateFlagsKHR) -> Self11673     pub fn flags(mut self, flags: Win32SurfaceCreateFlagsKHR) -> Self {
11674         self.inner.flags = flags;
11675         self
11676     }
11677     #[inline]
hinstance(mut self, hinstance: HINSTANCE) -> Self11678     pub fn hinstance(mut self, hinstance: HINSTANCE) -> Self {
11679         self.inner.hinstance = hinstance;
11680         self
11681     }
11682     #[inline]
hwnd(mut self, hwnd: HWND) -> Self11683     pub fn hwnd(mut self, hwnd: HWND) -> Self {
11684         self.inner.hwnd = hwnd;
11685         self
11686     }
11687     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11688     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11689     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> Win32SurfaceCreateInfoKHR11690     pub fn build(self) -> Win32SurfaceCreateInfoKHR {
11691         self.inner
11692     }
11693 }
11694 #[repr(C)]
11695 #[cfg_attr(feature = "debug", derive(Debug))]
11696 #[derive(Copy, Clone)]
11697 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkXlibSurfaceCreateInfoKHR.html>"]
11698 pub struct XlibSurfaceCreateInfoKHR {
11699     pub s_type: StructureType,
11700     pub p_next: *const c_void,
11701     pub flags: XlibSurfaceCreateFlagsKHR,
11702     pub dpy: *mut Display,
11703     pub window: Window,
11704 }
11705 impl ::std::default::Default for XlibSurfaceCreateInfoKHR {
11706     #[inline]
default() -> Self11707     fn default() -> Self {
11708         Self {
11709             s_type: Self::STRUCTURE_TYPE,
11710             p_next: ::std::ptr::null(),
11711             flags: XlibSurfaceCreateFlagsKHR::default(),
11712             dpy: ::std::ptr::null_mut(),
11713             window: Window::default(),
11714         }
11715     }
11716 }
11717 unsafe impl TaggedStructure for XlibSurfaceCreateInfoKHR {
11718     const STRUCTURE_TYPE: StructureType = StructureType::XLIB_SURFACE_CREATE_INFO_KHR;
11719 }
11720 impl XlibSurfaceCreateInfoKHR {
builder<'a>() -> XlibSurfaceCreateInfoKHRBuilder<'a>11721     pub fn builder<'a>() -> XlibSurfaceCreateInfoKHRBuilder<'a> {
11722         XlibSurfaceCreateInfoKHRBuilder {
11723             inner: Self::default(),
11724             marker: ::std::marker::PhantomData,
11725         }
11726     }
11727 }
11728 #[repr(transparent)]
11729 pub struct XlibSurfaceCreateInfoKHRBuilder<'a> {
11730     inner: XlibSurfaceCreateInfoKHR,
11731     marker: ::std::marker::PhantomData<&'a ()>,
11732 }
11733 impl<'a> ::std::ops::Deref for XlibSurfaceCreateInfoKHRBuilder<'a> {
11734     type Target = XlibSurfaceCreateInfoKHR;
deref(&self) -> &Self::Target11735     fn deref(&self) -> &Self::Target {
11736         &self.inner
11737     }
11738 }
11739 impl<'a> ::std::ops::DerefMut for XlibSurfaceCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target11740     fn deref_mut(&mut self) -> &mut Self::Target {
11741         &mut self.inner
11742     }
11743 }
11744 impl<'a> XlibSurfaceCreateInfoKHRBuilder<'a> {
11745     #[inline]
flags(mut self, flags: XlibSurfaceCreateFlagsKHR) -> Self11746     pub fn flags(mut self, flags: XlibSurfaceCreateFlagsKHR) -> Self {
11747         self.inner.flags = flags;
11748         self
11749     }
11750     #[inline]
dpy(mut self, dpy: *mut Display) -> Self11751     pub fn dpy(mut self, dpy: *mut Display) -> Self {
11752         self.inner.dpy = dpy;
11753         self
11754     }
11755     #[inline]
window(mut self, window: Window) -> Self11756     pub fn window(mut self, window: Window) -> Self {
11757         self.inner.window = window;
11758         self
11759     }
11760     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11761     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11762     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> XlibSurfaceCreateInfoKHR11763     pub fn build(self) -> XlibSurfaceCreateInfoKHR {
11764         self.inner
11765     }
11766 }
11767 #[repr(C)]
11768 #[cfg_attr(feature = "debug", derive(Debug))]
11769 #[derive(Copy, Clone)]
11770 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkXcbSurfaceCreateInfoKHR.html>"]
11771 pub struct XcbSurfaceCreateInfoKHR {
11772     pub s_type: StructureType,
11773     pub p_next: *const c_void,
11774     pub flags: XcbSurfaceCreateFlagsKHR,
11775     pub connection: *mut xcb_connection_t,
11776     pub window: xcb_window_t,
11777 }
11778 impl ::std::default::Default for XcbSurfaceCreateInfoKHR {
11779     #[inline]
default() -> Self11780     fn default() -> Self {
11781         Self {
11782             s_type: Self::STRUCTURE_TYPE,
11783             p_next: ::std::ptr::null(),
11784             flags: XcbSurfaceCreateFlagsKHR::default(),
11785             connection: ::std::ptr::null_mut(),
11786             window: xcb_window_t::default(),
11787         }
11788     }
11789 }
11790 unsafe impl TaggedStructure for XcbSurfaceCreateInfoKHR {
11791     const STRUCTURE_TYPE: StructureType = StructureType::XCB_SURFACE_CREATE_INFO_KHR;
11792 }
11793 impl XcbSurfaceCreateInfoKHR {
builder<'a>() -> XcbSurfaceCreateInfoKHRBuilder<'a>11794     pub fn builder<'a>() -> XcbSurfaceCreateInfoKHRBuilder<'a> {
11795         XcbSurfaceCreateInfoKHRBuilder {
11796             inner: Self::default(),
11797             marker: ::std::marker::PhantomData,
11798         }
11799     }
11800 }
11801 #[repr(transparent)]
11802 pub struct XcbSurfaceCreateInfoKHRBuilder<'a> {
11803     inner: XcbSurfaceCreateInfoKHR,
11804     marker: ::std::marker::PhantomData<&'a ()>,
11805 }
11806 impl<'a> ::std::ops::Deref for XcbSurfaceCreateInfoKHRBuilder<'a> {
11807     type Target = XcbSurfaceCreateInfoKHR;
deref(&self) -> &Self::Target11808     fn deref(&self) -> &Self::Target {
11809         &self.inner
11810     }
11811 }
11812 impl<'a> ::std::ops::DerefMut for XcbSurfaceCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target11813     fn deref_mut(&mut self) -> &mut Self::Target {
11814         &mut self.inner
11815     }
11816 }
11817 impl<'a> XcbSurfaceCreateInfoKHRBuilder<'a> {
11818     #[inline]
flags(mut self, flags: XcbSurfaceCreateFlagsKHR) -> Self11819     pub fn flags(mut self, flags: XcbSurfaceCreateFlagsKHR) -> Self {
11820         self.inner.flags = flags;
11821         self
11822     }
11823     #[inline]
connection(mut self, connection: *mut xcb_connection_t) -> Self11824     pub fn connection(mut self, connection: *mut xcb_connection_t) -> Self {
11825         self.inner.connection = connection;
11826         self
11827     }
11828     #[inline]
window(mut self, window: xcb_window_t) -> Self11829     pub fn window(mut self, window: xcb_window_t) -> Self {
11830         self.inner.window = window;
11831         self
11832     }
11833     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11834     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11835     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> XcbSurfaceCreateInfoKHR11836     pub fn build(self) -> XcbSurfaceCreateInfoKHR {
11837         self.inner
11838     }
11839 }
11840 #[repr(C)]
11841 #[cfg_attr(feature = "debug", derive(Debug))]
11842 #[derive(Copy, Clone)]
11843 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDirectFBSurfaceCreateInfoEXT.html>"]
11844 pub struct DirectFBSurfaceCreateInfoEXT {
11845     pub s_type: StructureType,
11846     pub p_next: *const c_void,
11847     pub flags: DirectFBSurfaceCreateFlagsEXT,
11848     pub dfb: *mut IDirectFB,
11849     pub surface: *mut IDirectFBSurface,
11850 }
11851 impl ::std::default::Default for DirectFBSurfaceCreateInfoEXT {
11852     #[inline]
default() -> Self11853     fn default() -> Self {
11854         Self {
11855             s_type: Self::STRUCTURE_TYPE,
11856             p_next: ::std::ptr::null(),
11857             flags: DirectFBSurfaceCreateFlagsEXT::default(),
11858             dfb: ::std::ptr::null_mut(),
11859             surface: ::std::ptr::null_mut(),
11860         }
11861     }
11862 }
11863 unsafe impl TaggedStructure for DirectFBSurfaceCreateInfoEXT {
11864     const STRUCTURE_TYPE: StructureType = StructureType::DIRECTFB_SURFACE_CREATE_INFO_EXT;
11865 }
11866 impl DirectFBSurfaceCreateInfoEXT {
builder<'a>() -> DirectFBSurfaceCreateInfoEXTBuilder<'a>11867     pub fn builder<'a>() -> DirectFBSurfaceCreateInfoEXTBuilder<'a> {
11868         DirectFBSurfaceCreateInfoEXTBuilder {
11869             inner: Self::default(),
11870             marker: ::std::marker::PhantomData,
11871         }
11872     }
11873 }
11874 #[repr(transparent)]
11875 pub struct DirectFBSurfaceCreateInfoEXTBuilder<'a> {
11876     inner: DirectFBSurfaceCreateInfoEXT,
11877     marker: ::std::marker::PhantomData<&'a ()>,
11878 }
11879 impl<'a> ::std::ops::Deref for DirectFBSurfaceCreateInfoEXTBuilder<'a> {
11880     type Target = DirectFBSurfaceCreateInfoEXT;
deref(&self) -> &Self::Target11881     fn deref(&self) -> &Self::Target {
11882         &self.inner
11883     }
11884 }
11885 impl<'a> ::std::ops::DerefMut for DirectFBSurfaceCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target11886     fn deref_mut(&mut self) -> &mut Self::Target {
11887         &mut self.inner
11888     }
11889 }
11890 impl<'a> DirectFBSurfaceCreateInfoEXTBuilder<'a> {
11891     #[inline]
flags(mut self, flags: DirectFBSurfaceCreateFlagsEXT) -> Self11892     pub fn flags(mut self, flags: DirectFBSurfaceCreateFlagsEXT) -> Self {
11893         self.inner.flags = flags;
11894         self
11895     }
11896     #[inline]
dfb(mut self, dfb: *mut IDirectFB) -> Self11897     pub fn dfb(mut self, dfb: *mut IDirectFB) -> Self {
11898         self.inner.dfb = dfb;
11899         self
11900     }
11901     #[inline]
surface(mut self, surface: *mut IDirectFBSurface) -> Self11902     pub fn surface(mut self, surface: *mut IDirectFBSurface) -> Self {
11903         self.inner.surface = surface;
11904         self
11905     }
11906     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11907     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11908     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DirectFBSurfaceCreateInfoEXT11909     pub fn build(self) -> DirectFBSurfaceCreateInfoEXT {
11910         self.inner
11911     }
11912 }
11913 #[repr(C)]
11914 #[cfg_attr(feature = "debug", derive(Debug))]
11915 #[derive(Copy, Clone)]
11916 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImagePipeSurfaceCreateInfoFUCHSIA.html>"]
11917 pub struct ImagePipeSurfaceCreateInfoFUCHSIA {
11918     pub s_type: StructureType,
11919     pub p_next: *const c_void,
11920     pub flags: ImagePipeSurfaceCreateFlagsFUCHSIA,
11921     pub image_pipe_handle: zx_handle_t,
11922 }
11923 impl ::std::default::Default for ImagePipeSurfaceCreateInfoFUCHSIA {
11924     #[inline]
default() -> Self11925     fn default() -> Self {
11926         Self {
11927             s_type: Self::STRUCTURE_TYPE,
11928             p_next: ::std::ptr::null(),
11929             flags: ImagePipeSurfaceCreateFlagsFUCHSIA::default(),
11930             image_pipe_handle: zx_handle_t::default(),
11931         }
11932     }
11933 }
11934 unsafe impl TaggedStructure for ImagePipeSurfaceCreateInfoFUCHSIA {
11935     const STRUCTURE_TYPE: StructureType = StructureType::IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA;
11936 }
11937 impl ImagePipeSurfaceCreateInfoFUCHSIA {
builder<'a>() -> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a>11938     pub fn builder<'a>() -> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
11939         ImagePipeSurfaceCreateInfoFUCHSIABuilder {
11940             inner: Self::default(),
11941             marker: ::std::marker::PhantomData,
11942         }
11943     }
11944 }
11945 #[repr(transparent)]
11946 pub struct ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
11947     inner: ImagePipeSurfaceCreateInfoFUCHSIA,
11948     marker: ::std::marker::PhantomData<&'a ()>,
11949 }
11950 impl<'a> ::std::ops::Deref for ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
11951     type Target = ImagePipeSurfaceCreateInfoFUCHSIA;
deref(&self) -> &Self::Target11952     fn deref(&self) -> &Self::Target {
11953         &self.inner
11954     }
11955 }
11956 impl<'a> ::std::ops::DerefMut for ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target11957     fn deref_mut(&mut self) -> &mut Self::Target {
11958         &mut self.inner
11959     }
11960 }
11961 impl<'a> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
11962     #[inline]
flags(mut self, flags: ImagePipeSurfaceCreateFlagsFUCHSIA) -> Self11963     pub fn flags(mut self, flags: ImagePipeSurfaceCreateFlagsFUCHSIA) -> Self {
11964         self.inner.flags = flags;
11965         self
11966     }
11967     #[inline]
image_pipe_handle(mut self, image_pipe_handle: zx_handle_t) -> Self11968     pub fn image_pipe_handle(mut self, image_pipe_handle: zx_handle_t) -> Self {
11969         self.inner.image_pipe_handle = image_pipe_handle;
11970         self
11971     }
11972     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11973     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11974     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImagePipeSurfaceCreateInfoFUCHSIA11975     pub fn build(self) -> ImagePipeSurfaceCreateInfoFUCHSIA {
11976         self.inner
11977     }
11978 }
11979 #[repr(C)]
11980 #[cfg_attr(feature = "debug", derive(Debug))]
11981 #[derive(Copy, Clone)]
11982 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkStreamDescriptorSurfaceCreateInfoGGP.html>"]
11983 pub struct StreamDescriptorSurfaceCreateInfoGGP {
11984     pub s_type: StructureType,
11985     pub p_next: *const c_void,
11986     pub flags: StreamDescriptorSurfaceCreateFlagsGGP,
11987     pub stream_descriptor: GgpStreamDescriptor,
11988 }
11989 impl ::std::default::Default for StreamDescriptorSurfaceCreateInfoGGP {
11990     #[inline]
default() -> Self11991     fn default() -> Self {
11992         Self {
11993             s_type: Self::STRUCTURE_TYPE,
11994             p_next: ::std::ptr::null(),
11995             flags: StreamDescriptorSurfaceCreateFlagsGGP::default(),
11996             stream_descriptor: GgpStreamDescriptor::default(),
11997         }
11998     }
11999 }
12000 unsafe impl TaggedStructure for StreamDescriptorSurfaceCreateInfoGGP {
12001     const STRUCTURE_TYPE: StructureType = StructureType::STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP;
12002 }
12003 impl StreamDescriptorSurfaceCreateInfoGGP {
builder<'a>() -> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a>12004     pub fn builder<'a>() -> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
12005         StreamDescriptorSurfaceCreateInfoGGPBuilder {
12006             inner: Self::default(),
12007             marker: ::std::marker::PhantomData,
12008         }
12009     }
12010 }
12011 #[repr(transparent)]
12012 pub struct StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
12013     inner: StreamDescriptorSurfaceCreateInfoGGP,
12014     marker: ::std::marker::PhantomData<&'a ()>,
12015 }
12016 impl<'a> ::std::ops::Deref for StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
12017     type Target = StreamDescriptorSurfaceCreateInfoGGP;
deref(&self) -> &Self::Target12018     fn deref(&self) -> &Self::Target {
12019         &self.inner
12020     }
12021 }
12022 impl<'a> ::std::ops::DerefMut for StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target12023     fn deref_mut(&mut self) -> &mut Self::Target {
12024         &mut self.inner
12025     }
12026 }
12027 impl<'a> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
12028     #[inline]
flags(mut self, flags: StreamDescriptorSurfaceCreateFlagsGGP) -> Self12029     pub fn flags(mut self, flags: StreamDescriptorSurfaceCreateFlagsGGP) -> Self {
12030         self.inner.flags = flags;
12031         self
12032     }
12033     #[inline]
stream_descriptor(mut self, stream_descriptor: GgpStreamDescriptor) -> Self12034     pub fn stream_descriptor(mut self, stream_descriptor: GgpStreamDescriptor) -> Self {
12035         self.inner.stream_descriptor = stream_descriptor;
12036         self
12037     }
12038     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12039     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12040     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> StreamDescriptorSurfaceCreateInfoGGP12041     pub fn build(self) -> StreamDescriptorSurfaceCreateInfoGGP {
12042         self.inner
12043     }
12044 }
12045 #[repr(C)]
12046 #[cfg_attr(feature = "debug", derive(Debug))]
12047 #[derive(Copy, Clone)]
12048 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkScreenSurfaceCreateInfoQNX.html>"]
12049 pub struct ScreenSurfaceCreateInfoQNX {
12050     pub s_type: StructureType,
12051     pub p_next: *const c_void,
12052     pub flags: ScreenSurfaceCreateFlagsQNX,
12053     pub context: *mut _screen_context,
12054     pub window: *mut _screen_window,
12055 }
12056 impl ::std::default::Default for ScreenSurfaceCreateInfoQNX {
12057     #[inline]
default() -> Self12058     fn default() -> Self {
12059         Self {
12060             s_type: Self::STRUCTURE_TYPE,
12061             p_next: ::std::ptr::null(),
12062             flags: ScreenSurfaceCreateFlagsQNX::default(),
12063             context: ::std::ptr::null_mut(),
12064             window: ::std::ptr::null_mut(),
12065         }
12066     }
12067 }
12068 unsafe impl TaggedStructure for ScreenSurfaceCreateInfoQNX {
12069     const STRUCTURE_TYPE: StructureType = StructureType::SCREEN_SURFACE_CREATE_INFO_QNX;
12070 }
12071 impl ScreenSurfaceCreateInfoQNX {
builder<'a>() -> ScreenSurfaceCreateInfoQNXBuilder<'a>12072     pub fn builder<'a>() -> ScreenSurfaceCreateInfoQNXBuilder<'a> {
12073         ScreenSurfaceCreateInfoQNXBuilder {
12074             inner: Self::default(),
12075             marker: ::std::marker::PhantomData,
12076         }
12077     }
12078 }
12079 #[repr(transparent)]
12080 pub struct ScreenSurfaceCreateInfoQNXBuilder<'a> {
12081     inner: ScreenSurfaceCreateInfoQNX,
12082     marker: ::std::marker::PhantomData<&'a ()>,
12083 }
12084 impl<'a> ::std::ops::Deref for ScreenSurfaceCreateInfoQNXBuilder<'a> {
12085     type Target = ScreenSurfaceCreateInfoQNX;
deref(&self) -> &Self::Target12086     fn deref(&self) -> &Self::Target {
12087         &self.inner
12088     }
12089 }
12090 impl<'a> ::std::ops::DerefMut for ScreenSurfaceCreateInfoQNXBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target12091     fn deref_mut(&mut self) -> &mut Self::Target {
12092         &mut self.inner
12093     }
12094 }
12095 impl<'a> ScreenSurfaceCreateInfoQNXBuilder<'a> {
12096     #[inline]
flags(mut self, flags: ScreenSurfaceCreateFlagsQNX) -> Self12097     pub fn flags(mut self, flags: ScreenSurfaceCreateFlagsQNX) -> Self {
12098         self.inner.flags = flags;
12099         self
12100     }
12101     #[inline]
context(mut self, context: &'a mut _screen_context) -> Self12102     pub fn context(mut self, context: &'a mut _screen_context) -> Self {
12103         self.inner.context = context;
12104         self
12105     }
12106     #[inline]
window(mut self, window: &'a mut _screen_window) -> Self12107     pub fn window(mut self, window: &'a mut _screen_window) -> Self {
12108         self.inner.window = window;
12109         self
12110     }
12111     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12112     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12113     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ScreenSurfaceCreateInfoQNX12114     pub fn build(self) -> ScreenSurfaceCreateInfoQNX {
12115         self.inner
12116     }
12117 }
12118 #[repr(C)]
12119 #[cfg_attr(feature = "debug", derive(Debug))]
12120 #[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
12121 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceFormatKHR.html>"]
12122 pub struct SurfaceFormatKHR {
12123     pub format: Format,
12124     pub color_space: ColorSpaceKHR,
12125 }
12126 impl SurfaceFormatKHR {
builder<'a>() -> SurfaceFormatKHRBuilder<'a>12127     pub fn builder<'a>() -> SurfaceFormatKHRBuilder<'a> {
12128         SurfaceFormatKHRBuilder {
12129             inner: Self::default(),
12130             marker: ::std::marker::PhantomData,
12131         }
12132     }
12133 }
12134 #[repr(transparent)]
12135 pub struct SurfaceFormatKHRBuilder<'a> {
12136     inner: SurfaceFormatKHR,
12137     marker: ::std::marker::PhantomData<&'a ()>,
12138 }
12139 impl<'a> ::std::ops::Deref for SurfaceFormatKHRBuilder<'a> {
12140     type Target = SurfaceFormatKHR;
deref(&self) -> &Self::Target12141     fn deref(&self) -> &Self::Target {
12142         &self.inner
12143     }
12144 }
12145 impl<'a> ::std::ops::DerefMut for SurfaceFormatKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target12146     fn deref_mut(&mut self) -> &mut Self::Target {
12147         &mut self.inner
12148     }
12149 }
12150 impl<'a> SurfaceFormatKHRBuilder<'a> {
12151     #[inline]
format(mut self, format: Format) -> Self12152     pub fn format(mut self, format: Format) -> Self {
12153         self.inner.format = format;
12154         self
12155     }
12156     #[inline]
color_space(mut self, color_space: ColorSpaceKHR) -> Self12157     pub fn color_space(mut self, color_space: ColorSpaceKHR) -> Self {
12158         self.inner.color_space = color_space;
12159         self
12160     }
12161     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12162     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12163     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SurfaceFormatKHR12164     pub fn build(self) -> SurfaceFormatKHR {
12165         self.inner
12166     }
12167 }
12168 #[repr(C)]
12169 #[cfg_attr(feature = "debug", derive(Debug))]
12170 #[derive(Copy, Clone)]
12171 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainCreateInfoKHR.html>"]
12172 pub struct SwapchainCreateInfoKHR {
12173     pub s_type: StructureType,
12174     pub p_next: *const c_void,
12175     pub flags: SwapchainCreateFlagsKHR,
12176     pub surface: SurfaceKHR,
12177     pub min_image_count: u32,
12178     pub image_format: Format,
12179     pub image_color_space: ColorSpaceKHR,
12180     pub image_extent: Extent2D,
12181     pub image_array_layers: u32,
12182     pub image_usage: ImageUsageFlags,
12183     pub image_sharing_mode: SharingMode,
12184     pub queue_family_index_count: u32,
12185     pub p_queue_family_indices: *const u32,
12186     pub pre_transform: SurfaceTransformFlagsKHR,
12187     pub composite_alpha: CompositeAlphaFlagsKHR,
12188     pub present_mode: PresentModeKHR,
12189     pub clipped: Bool32,
12190     pub old_swapchain: SwapchainKHR,
12191 }
12192 impl ::std::default::Default for SwapchainCreateInfoKHR {
12193     #[inline]
default() -> Self12194     fn default() -> Self {
12195         Self {
12196             s_type: Self::STRUCTURE_TYPE,
12197             p_next: ::std::ptr::null(),
12198             flags: SwapchainCreateFlagsKHR::default(),
12199             surface: SurfaceKHR::default(),
12200             min_image_count: u32::default(),
12201             image_format: Format::default(),
12202             image_color_space: ColorSpaceKHR::default(),
12203             image_extent: Extent2D::default(),
12204             image_array_layers: u32::default(),
12205             image_usage: ImageUsageFlags::default(),
12206             image_sharing_mode: SharingMode::default(),
12207             queue_family_index_count: u32::default(),
12208             p_queue_family_indices: ::std::ptr::null(),
12209             pre_transform: SurfaceTransformFlagsKHR::default(),
12210             composite_alpha: CompositeAlphaFlagsKHR::default(),
12211             present_mode: PresentModeKHR::default(),
12212             clipped: Bool32::default(),
12213             old_swapchain: SwapchainKHR::default(),
12214         }
12215     }
12216 }
12217 unsafe impl TaggedStructure for SwapchainCreateInfoKHR {
12218     const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_CREATE_INFO_KHR;
12219 }
12220 impl SwapchainCreateInfoKHR {
builder<'a>() -> SwapchainCreateInfoKHRBuilder<'a>12221     pub fn builder<'a>() -> SwapchainCreateInfoKHRBuilder<'a> {
12222         SwapchainCreateInfoKHRBuilder {
12223             inner: Self::default(),
12224             marker: ::std::marker::PhantomData,
12225         }
12226     }
12227 }
12228 #[repr(transparent)]
12229 pub struct SwapchainCreateInfoKHRBuilder<'a> {
12230     inner: SwapchainCreateInfoKHR,
12231     marker: ::std::marker::PhantomData<&'a ()>,
12232 }
12233 pub unsafe trait ExtendsSwapchainCreateInfoKHR {}
12234 impl<'a> ::std::ops::Deref for SwapchainCreateInfoKHRBuilder<'a> {
12235     type Target = SwapchainCreateInfoKHR;
deref(&self) -> &Self::Target12236     fn deref(&self) -> &Self::Target {
12237         &self.inner
12238     }
12239 }
12240 impl<'a> ::std::ops::DerefMut for SwapchainCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target12241     fn deref_mut(&mut self) -> &mut Self::Target {
12242         &mut self.inner
12243     }
12244 }
12245 impl<'a> SwapchainCreateInfoKHRBuilder<'a> {
12246     #[inline]
flags(mut self, flags: SwapchainCreateFlagsKHR) -> Self12247     pub fn flags(mut self, flags: SwapchainCreateFlagsKHR) -> Self {
12248         self.inner.flags = flags;
12249         self
12250     }
12251     #[inline]
surface(mut self, surface: SurfaceKHR) -> Self12252     pub fn surface(mut self, surface: SurfaceKHR) -> Self {
12253         self.inner.surface = surface;
12254         self
12255     }
12256     #[inline]
min_image_count(mut self, min_image_count: u32) -> Self12257     pub fn min_image_count(mut self, min_image_count: u32) -> Self {
12258         self.inner.min_image_count = min_image_count;
12259         self
12260     }
12261     #[inline]
image_format(mut self, image_format: Format) -> Self12262     pub fn image_format(mut self, image_format: Format) -> Self {
12263         self.inner.image_format = image_format;
12264         self
12265     }
12266     #[inline]
image_color_space(mut self, image_color_space: ColorSpaceKHR) -> Self12267     pub fn image_color_space(mut self, image_color_space: ColorSpaceKHR) -> Self {
12268         self.inner.image_color_space = image_color_space;
12269         self
12270     }
12271     #[inline]
image_extent(mut self, image_extent: Extent2D) -> Self12272     pub fn image_extent(mut self, image_extent: Extent2D) -> Self {
12273         self.inner.image_extent = image_extent;
12274         self
12275     }
12276     #[inline]
image_array_layers(mut self, image_array_layers: u32) -> Self12277     pub fn image_array_layers(mut self, image_array_layers: u32) -> Self {
12278         self.inner.image_array_layers = image_array_layers;
12279         self
12280     }
12281     #[inline]
image_usage(mut self, image_usage: ImageUsageFlags) -> Self12282     pub fn image_usage(mut self, image_usage: ImageUsageFlags) -> Self {
12283         self.inner.image_usage = image_usage;
12284         self
12285     }
12286     #[inline]
image_sharing_mode(mut self, image_sharing_mode: SharingMode) -> Self12287     pub fn image_sharing_mode(mut self, image_sharing_mode: SharingMode) -> Self {
12288         self.inner.image_sharing_mode = image_sharing_mode;
12289         self
12290     }
12291     #[inline]
queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self12292     pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self {
12293         self.inner.queue_family_index_count = queue_family_indices.len() as _;
12294         self.inner.p_queue_family_indices = queue_family_indices.as_ptr();
12295         self
12296     }
12297     #[inline]
pre_transform(mut self, pre_transform: SurfaceTransformFlagsKHR) -> Self12298     pub fn pre_transform(mut self, pre_transform: SurfaceTransformFlagsKHR) -> Self {
12299         self.inner.pre_transform = pre_transform;
12300         self
12301     }
12302     #[inline]
composite_alpha(mut self, composite_alpha: CompositeAlphaFlagsKHR) -> Self12303     pub fn composite_alpha(mut self, composite_alpha: CompositeAlphaFlagsKHR) -> Self {
12304         self.inner.composite_alpha = composite_alpha;
12305         self
12306     }
12307     #[inline]
present_mode(mut self, present_mode: PresentModeKHR) -> Self12308     pub fn present_mode(mut self, present_mode: PresentModeKHR) -> Self {
12309         self.inner.present_mode = present_mode;
12310         self
12311     }
12312     #[inline]
clipped(mut self, clipped: bool) -> Self12313     pub fn clipped(mut self, clipped: bool) -> Self {
12314         self.inner.clipped = clipped.into();
12315         self
12316     }
12317     #[inline]
old_swapchain(mut self, old_swapchain: SwapchainKHR) -> Self12318     pub fn old_swapchain(mut self, old_swapchain: SwapchainKHR) -> Self {
12319         self.inner.old_swapchain = old_swapchain;
12320         self
12321     }
12322     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
12323     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
12324     #[doc = r" valid extension structs can be pushed into the chain."]
12325     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
12326     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSwapchainCreateInfoKHR>(mut self, next: &'a mut T) -> Self12327     pub fn push_next<T: ExtendsSwapchainCreateInfoKHR>(mut self, next: &'a mut T) -> Self {
12328         unsafe {
12329             let next_ptr = <*const T>::cast(next);
12330             let last_next = ptr_chain_iter(next).last().unwrap();
12331             (*last_next).p_next = self.inner.p_next as _;
12332             self.inner.p_next = next_ptr;
12333         }
12334         self
12335     }
12336     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12337     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12338     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SwapchainCreateInfoKHR12339     pub fn build(self) -> SwapchainCreateInfoKHR {
12340         self.inner
12341     }
12342 }
12343 #[repr(C)]
12344 #[cfg_attr(feature = "debug", derive(Debug))]
12345 #[derive(Copy, Clone)]
12346 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentInfoKHR.html>"]
12347 pub struct PresentInfoKHR {
12348     pub s_type: StructureType,
12349     pub p_next: *const c_void,
12350     pub wait_semaphore_count: u32,
12351     pub p_wait_semaphores: *const Semaphore,
12352     pub swapchain_count: u32,
12353     pub p_swapchains: *const SwapchainKHR,
12354     pub p_image_indices: *const u32,
12355     pub p_results: *mut Result,
12356 }
12357 impl ::std::default::Default for PresentInfoKHR {
12358     #[inline]
default() -> Self12359     fn default() -> Self {
12360         Self {
12361             s_type: Self::STRUCTURE_TYPE,
12362             p_next: ::std::ptr::null(),
12363             wait_semaphore_count: u32::default(),
12364             p_wait_semaphores: ::std::ptr::null(),
12365             swapchain_count: u32::default(),
12366             p_swapchains: ::std::ptr::null(),
12367             p_image_indices: ::std::ptr::null(),
12368             p_results: ::std::ptr::null_mut(),
12369         }
12370     }
12371 }
12372 unsafe impl TaggedStructure for PresentInfoKHR {
12373     const STRUCTURE_TYPE: StructureType = StructureType::PRESENT_INFO_KHR;
12374 }
12375 impl PresentInfoKHR {
builder<'a>() -> PresentInfoKHRBuilder<'a>12376     pub fn builder<'a>() -> PresentInfoKHRBuilder<'a> {
12377         PresentInfoKHRBuilder {
12378             inner: Self::default(),
12379             marker: ::std::marker::PhantomData,
12380         }
12381     }
12382 }
12383 #[repr(transparent)]
12384 pub struct PresentInfoKHRBuilder<'a> {
12385     inner: PresentInfoKHR,
12386     marker: ::std::marker::PhantomData<&'a ()>,
12387 }
12388 pub unsafe trait ExtendsPresentInfoKHR {}
12389 impl<'a> ::std::ops::Deref for PresentInfoKHRBuilder<'a> {
12390     type Target = PresentInfoKHR;
deref(&self) -> &Self::Target12391     fn deref(&self) -> &Self::Target {
12392         &self.inner
12393     }
12394 }
12395 impl<'a> ::std::ops::DerefMut for PresentInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target12396     fn deref_mut(&mut self) -> &mut Self::Target {
12397         &mut self.inner
12398     }
12399 }
12400 impl<'a> PresentInfoKHRBuilder<'a> {
12401     #[inline]
wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> Self12402     pub fn wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> Self {
12403         self.inner.wait_semaphore_count = wait_semaphores.len() as _;
12404         self.inner.p_wait_semaphores = wait_semaphores.as_ptr();
12405         self
12406     }
12407     #[inline]
swapchains(mut self, swapchains: &'a [SwapchainKHR]) -> Self12408     pub fn swapchains(mut self, swapchains: &'a [SwapchainKHR]) -> Self {
12409         self.inner.swapchain_count = swapchains.len() as _;
12410         self.inner.p_swapchains = swapchains.as_ptr();
12411         self
12412     }
12413     #[inline]
image_indices(mut self, image_indices: &'a [u32]) -> Self12414     pub fn image_indices(mut self, image_indices: &'a [u32]) -> Self {
12415         self.inner.swapchain_count = image_indices.len() as _;
12416         self.inner.p_image_indices = image_indices.as_ptr();
12417         self
12418     }
12419     #[inline]
results(mut self, results: &'a mut [Result]) -> Self12420     pub fn results(mut self, results: &'a mut [Result]) -> Self {
12421         self.inner.swapchain_count = results.len() as _;
12422         self.inner.p_results = results.as_mut_ptr();
12423         self
12424     }
12425     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
12426     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
12427     #[doc = r" valid extension structs can be pushed into the chain."]
12428     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
12429     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPresentInfoKHR>(mut self, next: &'a mut T) -> Self12430     pub fn push_next<T: ExtendsPresentInfoKHR>(mut self, next: &'a mut T) -> Self {
12431         unsafe {
12432             let next_ptr = <*const T>::cast(next);
12433             let last_next = ptr_chain_iter(next).last().unwrap();
12434             (*last_next).p_next = self.inner.p_next as _;
12435             self.inner.p_next = next_ptr;
12436         }
12437         self
12438     }
12439     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12440     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12441     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PresentInfoKHR12442     pub fn build(self) -> PresentInfoKHR {
12443         self.inner
12444     }
12445 }
12446 #[repr(C)]
12447 #[derive(Copy, Clone)]
12448 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugReportCallbackCreateInfoEXT.html>"]
12449 pub struct DebugReportCallbackCreateInfoEXT {
12450     pub s_type: StructureType,
12451     pub p_next: *const c_void,
12452     pub flags: DebugReportFlagsEXT,
12453     pub pfn_callback: PFN_vkDebugReportCallbackEXT,
12454     pub p_user_data: *mut c_void,
12455 }
12456 #[cfg(feature = "debug")]
12457 impl fmt::Debug for DebugReportCallbackCreateInfoEXT {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result12458     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
12459         fmt.debug_struct("DebugReportCallbackCreateInfoEXT")
12460             .field("s_type", &self.s_type)
12461             .field("p_next", &self.p_next)
12462             .field("flags", &self.flags)
12463             .field("pfn_callback", &(self.pfn_callback.map(|x| x as *const ())))
12464             .field("p_user_data", &self.p_user_data)
12465             .finish()
12466     }
12467 }
12468 impl ::std::default::Default for DebugReportCallbackCreateInfoEXT {
12469     #[inline]
default() -> Self12470     fn default() -> Self {
12471         Self {
12472             s_type: Self::STRUCTURE_TYPE,
12473             p_next: ::std::ptr::null(),
12474             flags: DebugReportFlagsEXT::default(),
12475             pfn_callback: PFN_vkDebugReportCallbackEXT::default(),
12476             p_user_data: ::std::ptr::null_mut(),
12477         }
12478     }
12479 }
12480 unsafe impl TaggedStructure for DebugReportCallbackCreateInfoEXT {
12481     const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
12482 }
12483 impl DebugReportCallbackCreateInfoEXT {
builder<'a>() -> DebugReportCallbackCreateInfoEXTBuilder<'a>12484     pub fn builder<'a>() -> DebugReportCallbackCreateInfoEXTBuilder<'a> {
12485         DebugReportCallbackCreateInfoEXTBuilder {
12486             inner: Self::default(),
12487             marker: ::std::marker::PhantomData,
12488         }
12489     }
12490 }
12491 #[repr(transparent)]
12492 pub struct DebugReportCallbackCreateInfoEXTBuilder<'a> {
12493     inner: DebugReportCallbackCreateInfoEXT,
12494     marker: ::std::marker::PhantomData<&'a ()>,
12495 }
12496 unsafe impl ExtendsInstanceCreateInfo for DebugReportCallbackCreateInfoEXTBuilder<'_> {}
12497 unsafe impl ExtendsInstanceCreateInfo for DebugReportCallbackCreateInfoEXT {}
12498 impl<'a> ::std::ops::Deref for DebugReportCallbackCreateInfoEXTBuilder<'a> {
12499     type Target = DebugReportCallbackCreateInfoEXT;
deref(&self) -> &Self::Target12500     fn deref(&self) -> &Self::Target {
12501         &self.inner
12502     }
12503 }
12504 impl<'a> ::std::ops::DerefMut for DebugReportCallbackCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target12505     fn deref_mut(&mut self) -> &mut Self::Target {
12506         &mut self.inner
12507     }
12508 }
12509 impl<'a> DebugReportCallbackCreateInfoEXTBuilder<'a> {
12510     #[inline]
flags(mut self, flags: DebugReportFlagsEXT) -> Self12511     pub fn flags(mut self, flags: DebugReportFlagsEXT) -> Self {
12512         self.inner.flags = flags;
12513         self
12514     }
12515     #[inline]
pfn_callback(mut self, pfn_callback: PFN_vkDebugReportCallbackEXT) -> Self12516     pub fn pfn_callback(mut self, pfn_callback: PFN_vkDebugReportCallbackEXT) -> Self {
12517         self.inner.pfn_callback = pfn_callback;
12518         self
12519     }
12520     #[inline]
user_data(mut self, user_data: *mut c_void) -> Self12521     pub fn user_data(mut self, user_data: *mut c_void) -> Self {
12522         self.inner.p_user_data = user_data;
12523         self
12524     }
12525     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12526     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12527     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DebugReportCallbackCreateInfoEXT12528     pub fn build(self) -> DebugReportCallbackCreateInfoEXT {
12529         self.inner
12530     }
12531 }
12532 #[repr(C)]
12533 #[cfg_attr(feature = "debug", derive(Debug))]
12534 #[derive(Copy, Clone)]
12535 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationFlagsEXT.html>"]
12536 pub struct ValidationFlagsEXT {
12537     pub s_type: StructureType,
12538     pub p_next: *const c_void,
12539     pub disabled_validation_check_count: u32,
12540     pub p_disabled_validation_checks: *const ValidationCheckEXT,
12541 }
12542 impl ::std::default::Default for ValidationFlagsEXT {
12543     #[inline]
default() -> Self12544     fn default() -> Self {
12545         Self {
12546             s_type: Self::STRUCTURE_TYPE,
12547             p_next: ::std::ptr::null(),
12548             disabled_validation_check_count: u32::default(),
12549             p_disabled_validation_checks: ::std::ptr::null(),
12550         }
12551     }
12552 }
12553 unsafe impl TaggedStructure for ValidationFlagsEXT {
12554     const STRUCTURE_TYPE: StructureType = StructureType::VALIDATION_FLAGS_EXT;
12555 }
12556 impl ValidationFlagsEXT {
builder<'a>() -> ValidationFlagsEXTBuilder<'a>12557     pub fn builder<'a>() -> ValidationFlagsEXTBuilder<'a> {
12558         ValidationFlagsEXTBuilder {
12559             inner: Self::default(),
12560             marker: ::std::marker::PhantomData,
12561         }
12562     }
12563 }
12564 #[repr(transparent)]
12565 pub struct ValidationFlagsEXTBuilder<'a> {
12566     inner: ValidationFlagsEXT,
12567     marker: ::std::marker::PhantomData<&'a ()>,
12568 }
12569 unsafe impl ExtendsInstanceCreateInfo for ValidationFlagsEXTBuilder<'_> {}
12570 unsafe impl ExtendsInstanceCreateInfo for ValidationFlagsEXT {}
12571 impl<'a> ::std::ops::Deref for ValidationFlagsEXTBuilder<'a> {
12572     type Target = ValidationFlagsEXT;
deref(&self) -> &Self::Target12573     fn deref(&self) -> &Self::Target {
12574         &self.inner
12575     }
12576 }
12577 impl<'a> ::std::ops::DerefMut for ValidationFlagsEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target12578     fn deref_mut(&mut self) -> &mut Self::Target {
12579         &mut self.inner
12580     }
12581 }
12582 impl<'a> ValidationFlagsEXTBuilder<'a> {
12583     #[inline]
disabled_validation_checks( mut self, disabled_validation_checks: &'a [ValidationCheckEXT], ) -> Self12584     pub fn disabled_validation_checks(
12585         mut self,
12586         disabled_validation_checks: &'a [ValidationCheckEXT],
12587     ) -> Self {
12588         self.inner.disabled_validation_check_count = disabled_validation_checks.len() as _;
12589         self.inner.p_disabled_validation_checks = disabled_validation_checks.as_ptr();
12590         self
12591     }
12592     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12593     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12594     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ValidationFlagsEXT12595     pub fn build(self) -> ValidationFlagsEXT {
12596         self.inner
12597     }
12598 }
12599 #[repr(C)]
12600 #[cfg_attr(feature = "debug", derive(Debug))]
12601 #[derive(Copy, Clone)]
12602 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationFeaturesEXT.html>"]
12603 pub struct ValidationFeaturesEXT {
12604     pub s_type: StructureType,
12605     pub p_next: *const c_void,
12606     pub enabled_validation_feature_count: u32,
12607     pub p_enabled_validation_features: *const ValidationFeatureEnableEXT,
12608     pub disabled_validation_feature_count: u32,
12609     pub p_disabled_validation_features: *const ValidationFeatureDisableEXT,
12610 }
12611 impl ::std::default::Default for ValidationFeaturesEXT {
12612     #[inline]
default() -> Self12613     fn default() -> Self {
12614         Self {
12615             s_type: Self::STRUCTURE_TYPE,
12616             p_next: ::std::ptr::null(),
12617             enabled_validation_feature_count: u32::default(),
12618             p_enabled_validation_features: ::std::ptr::null(),
12619             disabled_validation_feature_count: u32::default(),
12620             p_disabled_validation_features: ::std::ptr::null(),
12621         }
12622     }
12623 }
12624 unsafe impl TaggedStructure for ValidationFeaturesEXT {
12625     const STRUCTURE_TYPE: StructureType = StructureType::VALIDATION_FEATURES_EXT;
12626 }
12627 impl ValidationFeaturesEXT {
builder<'a>() -> ValidationFeaturesEXTBuilder<'a>12628     pub fn builder<'a>() -> ValidationFeaturesEXTBuilder<'a> {
12629         ValidationFeaturesEXTBuilder {
12630             inner: Self::default(),
12631             marker: ::std::marker::PhantomData,
12632         }
12633     }
12634 }
12635 #[repr(transparent)]
12636 pub struct ValidationFeaturesEXTBuilder<'a> {
12637     inner: ValidationFeaturesEXT,
12638     marker: ::std::marker::PhantomData<&'a ()>,
12639 }
12640 unsafe impl ExtendsInstanceCreateInfo for ValidationFeaturesEXTBuilder<'_> {}
12641 unsafe impl ExtendsInstanceCreateInfo for ValidationFeaturesEXT {}
12642 impl<'a> ::std::ops::Deref for ValidationFeaturesEXTBuilder<'a> {
12643     type Target = ValidationFeaturesEXT;
deref(&self) -> &Self::Target12644     fn deref(&self) -> &Self::Target {
12645         &self.inner
12646     }
12647 }
12648 impl<'a> ::std::ops::DerefMut for ValidationFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target12649     fn deref_mut(&mut self) -> &mut Self::Target {
12650         &mut self.inner
12651     }
12652 }
12653 impl<'a> ValidationFeaturesEXTBuilder<'a> {
12654     #[inline]
enabled_validation_features( mut self, enabled_validation_features: &'a [ValidationFeatureEnableEXT], ) -> Self12655     pub fn enabled_validation_features(
12656         mut self,
12657         enabled_validation_features: &'a [ValidationFeatureEnableEXT],
12658     ) -> Self {
12659         self.inner.enabled_validation_feature_count = enabled_validation_features.len() as _;
12660         self.inner.p_enabled_validation_features = enabled_validation_features.as_ptr();
12661         self
12662     }
12663     #[inline]
disabled_validation_features( mut self, disabled_validation_features: &'a [ValidationFeatureDisableEXT], ) -> Self12664     pub fn disabled_validation_features(
12665         mut self,
12666         disabled_validation_features: &'a [ValidationFeatureDisableEXT],
12667     ) -> Self {
12668         self.inner.disabled_validation_feature_count = disabled_validation_features.len() as _;
12669         self.inner.p_disabled_validation_features = disabled_validation_features.as_ptr();
12670         self
12671     }
12672     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12673     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12674     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ValidationFeaturesEXT12675     pub fn build(self) -> ValidationFeaturesEXT {
12676         self.inner
12677     }
12678 }
12679 #[repr(C)]
12680 #[cfg_attr(feature = "debug", derive(Debug))]
12681 #[derive(Copy, Clone)]
12682 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationStateRasterizationOrderAMD.html>"]
12683 pub struct PipelineRasterizationStateRasterizationOrderAMD {
12684     pub s_type: StructureType,
12685     pub p_next: *const c_void,
12686     pub rasterization_order: RasterizationOrderAMD,
12687 }
12688 impl ::std::default::Default for PipelineRasterizationStateRasterizationOrderAMD {
12689     #[inline]
default() -> Self12690     fn default() -> Self {
12691         Self {
12692             s_type: Self::STRUCTURE_TYPE,
12693             p_next: ::std::ptr::null(),
12694             rasterization_order: RasterizationOrderAMD::default(),
12695         }
12696     }
12697 }
12698 unsafe impl TaggedStructure for PipelineRasterizationStateRasterizationOrderAMD {
12699     const STRUCTURE_TYPE: StructureType =
12700         StructureType::PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD;
12701 }
12702 impl PipelineRasterizationStateRasterizationOrderAMD {
builder<'a>() -> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a>12703     pub fn builder<'a>() -> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
12704         PipelineRasterizationStateRasterizationOrderAMDBuilder {
12705             inner: Self::default(),
12706             marker: ::std::marker::PhantomData,
12707         }
12708     }
12709 }
12710 #[repr(transparent)]
12711 pub struct PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
12712     inner: PipelineRasterizationStateRasterizationOrderAMD,
12713     marker: ::std::marker::PhantomData<&'a ()>,
12714 }
12715 unsafe impl ExtendsPipelineRasterizationStateCreateInfo
12716     for PipelineRasterizationStateRasterizationOrderAMDBuilder<'_>
12717 {
12718 }
12719 unsafe impl ExtendsPipelineRasterizationStateCreateInfo
12720     for PipelineRasterizationStateRasterizationOrderAMD
12721 {
12722 }
12723 impl<'a> ::std::ops::Deref for PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
12724     type Target = PipelineRasterizationStateRasterizationOrderAMD;
deref(&self) -> &Self::Target12725     fn deref(&self) -> &Self::Target {
12726         &self.inner
12727     }
12728 }
12729 impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target12730     fn deref_mut(&mut self) -> &mut Self::Target {
12731         &mut self.inner
12732     }
12733 }
12734 impl<'a> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
12735     #[inline]
rasterization_order(mut self, rasterization_order: RasterizationOrderAMD) -> Self12736     pub fn rasterization_order(mut self, rasterization_order: RasterizationOrderAMD) -> Self {
12737         self.inner.rasterization_order = rasterization_order;
12738         self
12739     }
12740     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12741     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12742     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineRasterizationStateRasterizationOrderAMD12743     pub fn build(self) -> PipelineRasterizationStateRasterizationOrderAMD {
12744         self.inner
12745     }
12746 }
12747 #[repr(C)]
12748 #[cfg_attr(feature = "debug", derive(Debug))]
12749 #[derive(Copy, Clone)]
12750 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugMarkerObjectNameInfoEXT.html>"]
12751 pub struct DebugMarkerObjectNameInfoEXT {
12752     pub s_type: StructureType,
12753     pub p_next: *const c_void,
12754     pub object_type: DebugReportObjectTypeEXT,
12755     pub object: u64,
12756     pub p_object_name: *const c_char,
12757 }
12758 impl ::std::default::Default for DebugMarkerObjectNameInfoEXT {
12759     #[inline]
default() -> Self12760     fn default() -> Self {
12761         Self {
12762             s_type: Self::STRUCTURE_TYPE,
12763             p_next: ::std::ptr::null(),
12764             object_type: DebugReportObjectTypeEXT::default(),
12765             object: u64::default(),
12766             p_object_name: ::std::ptr::null(),
12767         }
12768     }
12769 }
12770 unsafe impl TaggedStructure for DebugMarkerObjectNameInfoEXT {
12771     const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_MARKER_OBJECT_NAME_INFO_EXT;
12772 }
12773 impl DebugMarkerObjectNameInfoEXT {
builder<'a>() -> DebugMarkerObjectNameInfoEXTBuilder<'a>12774     pub fn builder<'a>() -> DebugMarkerObjectNameInfoEXTBuilder<'a> {
12775         DebugMarkerObjectNameInfoEXTBuilder {
12776             inner: Self::default(),
12777             marker: ::std::marker::PhantomData,
12778         }
12779     }
12780 }
12781 #[repr(transparent)]
12782 pub struct DebugMarkerObjectNameInfoEXTBuilder<'a> {
12783     inner: DebugMarkerObjectNameInfoEXT,
12784     marker: ::std::marker::PhantomData<&'a ()>,
12785 }
12786 impl<'a> ::std::ops::Deref for DebugMarkerObjectNameInfoEXTBuilder<'a> {
12787     type Target = DebugMarkerObjectNameInfoEXT;
deref(&self) -> &Self::Target12788     fn deref(&self) -> &Self::Target {
12789         &self.inner
12790     }
12791 }
12792 impl<'a> ::std::ops::DerefMut for DebugMarkerObjectNameInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target12793     fn deref_mut(&mut self) -> &mut Self::Target {
12794         &mut self.inner
12795     }
12796 }
12797 impl<'a> DebugMarkerObjectNameInfoEXTBuilder<'a> {
12798     #[inline]
object_type(mut self, object_type: DebugReportObjectTypeEXT) -> Self12799     pub fn object_type(mut self, object_type: DebugReportObjectTypeEXT) -> Self {
12800         self.inner.object_type = object_type;
12801         self
12802     }
12803     #[inline]
object(mut self, object: u64) -> Self12804     pub fn object(mut self, object: u64) -> Self {
12805         self.inner.object = object;
12806         self
12807     }
12808     #[inline]
object_name(mut self, object_name: &'a ::std::ffi::CStr) -> Self12809     pub fn object_name(mut self, object_name: &'a ::std::ffi::CStr) -> Self {
12810         self.inner.p_object_name = object_name.as_ptr();
12811         self
12812     }
12813     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12814     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12815     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DebugMarkerObjectNameInfoEXT12816     pub fn build(self) -> DebugMarkerObjectNameInfoEXT {
12817         self.inner
12818     }
12819 }
12820 #[repr(C)]
12821 #[cfg_attr(feature = "debug", derive(Debug))]
12822 #[derive(Copy, Clone)]
12823 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugMarkerObjectTagInfoEXT.html>"]
12824 pub struct DebugMarkerObjectTagInfoEXT {
12825     pub s_type: StructureType,
12826     pub p_next: *const c_void,
12827     pub object_type: DebugReportObjectTypeEXT,
12828     pub object: u64,
12829     pub tag_name: u64,
12830     pub tag_size: usize,
12831     pub p_tag: *const c_void,
12832 }
12833 impl ::std::default::Default for DebugMarkerObjectTagInfoEXT {
12834     #[inline]
default() -> Self12835     fn default() -> Self {
12836         Self {
12837             s_type: Self::STRUCTURE_TYPE,
12838             p_next: ::std::ptr::null(),
12839             object_type: DebugReportObjectTypeEXT::default(),
12840             object: u64::default(),
12841             tag_name: u64::default(),
12842             tag_size: usize::default(),
12843             p_tag: ::std::ptr::null(),
12844         }
12845     }
12846 }
12847 unsafe impl TaggedStructure for DebugMarkerObjectTagInfoEXT {
12848     const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_MARKER_OBJECT_TAG_INFO_EXT;
12849 }
12850 impl DebugMarkerObjectTagInfoEXT {
builder<'a>() -> DebugMarkerObjectTagInfoEXTBuilder<'a>12851     pub fn builder<'a>() -> DebugMarkerObjectTagInfoEXTBuilder<'a> {
12852         DebugMarkerObjectTagInfoEXTBuilder {
12853             inner: Self::default(),
12854             marker: ::std::marker::PhantomData,
12855         }
12856     }
12857 }
12858 #[repr(transparent)]
12859 pub struct DebugMarkerObjectTagInfoEXTBuilder<'a> {
12860     inner: DebugMarkerObjectTagInfoEXT,
12861     marker: ::std::marker::PhantomData<&'a ()>,
12862 }
12863 impl<'a> ::std::ops::Deref for DebugMarkerObjectTagInfoEXTBuilder<'a> {
12864     type Target = DebugMarkerObjectTagInfoEXT;
deref(&self) -> &Self::Target12865     fn deref(&self) -> &Self::Target {
12866         &self.inner
12867     }
12868 }
12869 impl<'a> ::std::ops::DerefMut for DebugMarkerObjectTagInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target12870     fn deref_mut(&mut self) -> &mut Self::Target {
12871         &mut self.inner
12872     }
12873 }
12874 impl<'a> DebugMarkerObjectTagInfoEXTBuilder<'a> {
12875     #[inline]
object_type(mut self, object_type: DebugReportObjectTypeEXT) -> Self12876     pub fn object_type(mut self, object_type: DebugReportObjectTypeEXT) -> Self {
12877         self.inner.object_type = object_type;
12878         self
12879     }
12880     #[inline]
object(mut self, object: u64) -> Self12881     pub fn object(mut self, object: u64) -> Self {
12882         self.inner.object = object;
12883         self
12884     }
12885     #[inline]
tag_name(mut self, tag_name: u64) -> Self12886     pub fn tag_name(mut self, tag_name: u64) -> Self {
12887         self.inner.tag_name = tag_name;
12888         self
12889     }
12890     #[inline]
tag(mut self, tag: &'a [u8]) -> Self12891     pub fn tag(mut self, tag: &'a [u8]) -> Self {
12892         self.inner.tag_size = tag.len();
12893         self.inner.p_tag = tag.as_ptr().cast();
12894         self
12895     }
12896     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12897     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12898     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DebugMarkerObjectTagInfoEXT12899     pub fn build(self) -> DebugMarkerObjectTagInfoEXT {
12900         self.inner
12901     }
12902 }
12903 #[repr(C)]
12904 #[cfg_attr(feature = "debug", derive(Debug))]
12905 #[derive(Copy, Clone)]
12906 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugMarkerMarkerInfoEXT.html>"]
12907 pub struct DebugMarkerMarkerInfoEXT {
12908     pub s_type: StructureType,
12909     pub p_next: *const c_void,
12910     pub p_marker_name: *const c_char,
12911     pub color: [f32; 4],
12912 }
12913 impl ::std::default::Default for DebugMarkerMarkerInfoEXT {
12914     #[inline]
default() -> Self12915     fn default() -> Self {
12916         Self {
12917             s_type: Self::STRUCTURE_TYPE,
12918             p_next: ::std::ptr::null(),
12919             p_marker_name: ::std::ptr::null(),
12920             color: unsafe { ::std::mem::zeroed() },
12921         }
12922     }
12923 }
12924 unsafe impl TaggedStructure for DebugMarkerMarkerInfoEXT {
12925     const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_MARKER_MARKER_INFO_EXT;
12926 }
12927 impl DebugMarkerMarkerInfoEXT {
builder<'a>() -> DebugMarkerMarkerInfoEXTBuilder<'a>12928     pub fn builder<'a>() -> DebugMarkerMarkerInfoEXTBuilder<'a> {
12929         DebugMarkerMarkerInfoEXTBuilder {
12930             inner: Self::default(),
12931             marker: ::std::marker::PhantomData,
12932         }
12933     }
12934 }
12935 #[repr(transparent)]
12936 pub struct DebugMarkerMarkerInfoEXTBuilder<'a> {
12937     inner: DebugMarkerMarkerInfoEXT,
12938     marker: ::std::marker::PhantomData<&'a ()>,
12939 }
12940 impl<'a> ::std::ops::Deref for DebugMarkerMarkerInfoEXTBuilder<'a> {
12941     type Target = DebugMarkerMarkerInfoEXT;
deref(&self) -> &Self::Target12942     fn deref(&self) -> &Self::Target {
12943         &self.inner
12944     }
12945 }
12946 impl<'a> ::std::ops::DerefMut for DebugMarkerMarkerInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target12947     fn deref_mut(&mut self) -> &mut Self::Target {
12948         &mut self.inner
12949     }
12950 }
12951 impl<'a> DebugMarkerMarkerInfoEXTBuilder<'a> {
12952     #[inline]
marker_name(mut self, marker_name: &'a ::std::ffi::CStr) -> Self12953     pub fn marker_name(mut self, marker_name: &'a ::std::ffi::CStr) -> Self {
12954         self.inner.p_marker_name = marker_name.as_ptr();
12955         self
12956     }
12957     #[inline]
color(mut self, color: [f32; 4]) -> Self12958     pub fn color(mut self, color: [f32; 4]) -> Self {
12959         self.inner.color = color;
12960         self
12961     }
12962     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12963     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12964     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DebugMarkerMarkerInfoEXT12965     pub fn build(self) -> DebugMarkerMarkerInfoEXT {
12966         self.inner
12967     }
12968 }
12969 #[repr(C)]
12970 #[cfg_attr(feature = "debug", derive(Debug))]
12971 #[derive(Copy, Clone)]
12972 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDedicatedAllocationImageCreateInfoNV.html>"]
12973 pub struct DedicatedAllocationImageCreateInfoNV {
12974     pub s_type: StructureType,
12975     pub p_next: *const c_void,
12976     pub dedicated_allocation: Bool32,
12977 }
12978 impl ::std::default::Default for DedicatedAllocationImageCreateInfoNV {
12979     #[inline]
default() -> Self12980     fn default() -> Self {
12981         Self {
12982             s_type: Self::STRUCTURE_TYPE,
12983             p_next: ::std::ptr::null(),
12984             dedicated_allocation: Bool32::default(),
12985         }
12986     }
12987 }
12988 unsafe impl TaggedStructure for DedicatedAllocationImageCreateInfoNV {
12989     const STRUCTURE_TYPE: StructureType = StructureType::DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV;
12990 }
12991 impl DedicatedAllocationImageCreateInfoNV {
builder<'a>() -> DedicatedAllocationImageCreateInfoNVBuilder<'a>12992     pub fn builder<'a>() -> DedicatedAllocationImageCreateInfoNVBuilder<'a> {
12993         DedicatedAllocationImageCreateInfoNVBuilder {
12994             inner: Self::default(),
12995             marker: ::std::marker::PhantomData,
12996         }
12997     }
12998 }
12999 #[repr(transparent)]
13000 pub struct DedicatedAllocationImageCreateInfoNVBuilder<'a> {
13001     inner: DedicatedAllocationImageCreateInfoNV,
13002     marker: ::std::marker::PhantomData<&'a ()>,
13003 }
13004 unsafe impl ExtendsImageCreateInfo for DedicatedAllocationImageCreateInfoNVBuilder<'_> {}
13005 unsafe impl ExtendsImageCreateInfo for DedicatedAllocationImageCreateInfoNV {}
13006 impl<'a> ::std::ops::Deref for DedicatedAllocationImageCreateInfoNVBuilder<'a> {
13007     type Target = DedicatedAllocationImageCreateInfoNV;
deref(&self) -> &Self::Target13008     fn deref(&self) -> &Self::Target {
13009         &self.inner
13010     }
13011 }
13012 impl<'a> ::std::ops::DerefMut for DedicatedAllocationImageCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target13013     fn deref_mut(&mut self) -> &mut Self::Target {
13014         &mut self.inner
13015     }
13016 }
13017 impl<'a> DedicatedAllocationImageCreateInfoNVBuilder<'a> {
13018     #[inline]
dedicated_allocation(mut self, dedicated_allocation: bool) -> Self13019     pub fn dedicated_allocation(mut self, dedicated_allocation: bool) -> Self {
13020         self.inner.dedicated_allocation = dedicated_allocation.into();
13021         self
13022     }
13023     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13024     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13025     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DedicatedAllocationImageCreateInfoNV13026     pub fn build(self) -> DedicatedAllocationImageCreateInfoNV {
13027         self.inner
13028     }
13029 }
13030 #[repr(C)]
13031 #[cfg_attr(feature = "debug", derive(Debug))]
13032 #[derive(Copy, Clone)]
13033 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDedicatedAllocationBufferCreateInfoNV.html>"]
13034 pub struct DedicatedAllocationBufferCreateInfoNV {
13035     pub s_type: StructureType,
13036     pub p_next: *const c_void,
13037     pub dedicated_allocation: Bool32,
13038 }
13039 impl ::std::default::Default for DedicatedAllocationBufferCreateInfoNV {
13040     #[inline]
default() -> Self13041     fn default() -> Self {
13042         Self {
13043             s_type: Self::STRUCTURE_TYPE,
13044             p_next: ::std::ptr::null(),
13045             dedicated_allocation: Bool32::default(),
13046         }
13047     }
13048 }
13049 unsafe impl TaggedStructure for DedicatedAllocationBufferCreateInfoNV {
13050     const STRUCTURE_TYPE: StructureType = StructureType::DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV;
13051 }
13052 impl DedicatedAllocationBufferCreateInfoNV {
builder<'a>() -> DedicatedAllocationBufferCreateInfoNVBuilder<'a>13053     pub fn builder<'a>() -> DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
13054         DedicatedAllocationBufferCreateInfoNVBuilder {
13055             inner: Self::default(),
13056             marker: ::std::marker::PhantomData,
13057         }
13058     }
13059 }
13060 #[repr(transparent)]
13061 pub struct DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
13062     inner: DedicatedAllocationBufferCreateInfoNV,
13063     marker: ::std::marker::PhantomData<&'a ()>,
13064 }
13065 unsafe impl ExtendsBufferCreateInfo for DedicatedAllocationBufferCreateInfoNVBuilder<'_> {}
13066 unsafe impl ExtendsBufferCreateInfo for DedicatedAllocationBufferCreateInfoNV {}
13067 impl<'a> ::std::ops::Deref for DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
13068     type Target = DedicatedAllocationBufferCreateInfoNV;
deref(&self) -> &Self::Target13069     fn deref(&self) -> &Self::Target {
13070         &self.inner
13071     }
13072 }
13073 impl<'a> ::std::ops::DerefMut for DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target13074     fn deref_mut(&mut self) -> &mut Self::Target {
13075         &mut self.inner
13076     }
13077 }
13078 impl<'a> DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
13079     #[inline]
dedicated_allocation(mut self, dedicated_allocation: bool) -> Self13080     pub fn dedicated_allocation(mut self, dedicated_allocation: bool) -> Self {
13081         self.inner.dedicated_allocation = dedicated_allocation.into();
13082         self
13083     }
13084     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13085     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13086     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DedicatedAllocationBufferCreateInfoNV13087     pub fn build(self) -> DedicatedAllocationBufferCreateInfoNV {
13088         self.inner
13089     }
13090 }
13091 #[repr(C)]
13092 #[cfg_attr(feature = "debug", derive(Debug))]
13093 #[derive(Copy, Clone)]
13094 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDedicatedAllocationMemoryAllocateInfoNV.html>"]
13095 pub struct DedicatedAllocationMemoryAllocateInfoNV {
13096     pub s_type: StructureType,
13097     pub p_next: *const c_void,
13098     pub image: Image,
13099     pub buffer: Buffer,
13100 }
13101 impl ::std::default::Default for DedicatedAllocationMemoryAllocateInfoNV {
13102     #[inline]
default() -> Self13103     fn default() -> Self {
13104         Self {
13105             s_type: Self::STRUCTURE_TYPE,
13106             p_next: ::std::ptr::null(),
13107             image: Image::default(),
13108             buffer: Buffer::default(),
13109         }
13110     }
13111 }
13112 unsafe impl TaggedStructure for DedicatedAllocationMemoryAllocateInfoNV {
13113     const STRUCTURE_TYPE: StructureType =
13114         StructureType::DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV;
13115 }
13116 impl DedicatedAllocationMemoryAllocateInfoNV {
builder<'a>() -> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a>13117     pub fn builder<'a>() -> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
13118         DedicatedAllocationMemoryAllocateInfoNVBuilder {
13119             inner: Self::default(),
13120             marker: ::std::marker::PhantomData,
13121         }
13122     }
13123 }
13124 #[repr(transparent)]
13125 pub struct DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
13126     inner: DedicatedAllocationMemoryAllocateInfoNV,
13127     marker: ::std::marker::PhantomData<&'a ()>,
13128 }
13129 unsafe impl ExtendsMemoryAllocateInfo for DedicatedAllocationMemoryAllocateInfoNVBuilder<'_> {}
13130 unsafe impl ExtendsMemoryAllocateInfo for DedicatedAllocationMemoryAllocateInfoNV {}
13131 impl<'a> ::std::ops::Deref for DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
13132     type Target = DedicatedAllocationMemoryAllocateInfoNV;
deref(&self) -> &Self::Target13133     fn deref(&self) -> &Self::Target {
13134         &self.inner
13135     }
13136 }
13137 impl<'a> ::std::ops::DerefMut for DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target13138     fn deref_mut(&mut self) -> &mut Self::Target {
13139         &mut self.inner
13140     }
13141 }
13142 impl<'a> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
13143     #[inline]
image(mut self, image: Image) -> Self13144     pub fn image(mut self, image: Image) -> Self {
13145         self.inner.image = image;
13146         self
13147     }
13148     #[inline]
buffer(mut self, buffer: Buffer) -> Self13149     pub fn buffer(mut self, buffer: Buffer) -> Self {
13150         self.inner.buffer = buffer;
13151         self
13152     }
13153     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13154     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13155     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DedicatedAllocationMemoryAllocateInfoNV13156     pub fn build(self) -> DedicatedAllocationMemoryAllocateInfoNV {
13157         self.inner
13158     }
13159 }
13160 #[repr(C)]
13161 #[cfg_attr(feature = "debug", derive(Debug))]
13162 #[derive(Copy, Clone, Default)]
13163 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalImageFormatPropertiesNV.html>"]
13164 pub struct ExternalImageFormatPropertiesNV {
13165     pub image_format_properties: ImageFormatProperties,
13166     pub external_memory_features: ExternalMemoryFeatureFlagsNV,
13167     pub export_from_imported_handle_types: ExternalMemoryHandleTypeFlagsNV,
13168     pub compatible_handle_types: ExternalMemoryHandleTypeFlagsNV,
13169 }
13170 impl ExternalImageFormatPropertiesNV {
builder<'a>() -> ExternalImageFormatPropertiesNVBuilder<'a>13171     pub fn builder<'a>() -> ExternalImageFormatPropertiesNVBuilder<'a> {
13172         ExternalImageFormatPropertiesNVBuilder {
13173             inner: Self::default(),
13174             marker: ::std::marker::PhantomData,
13175         }
13176     }
13177 }
13178 #[repr(transparent)]
13179 pub struct ExternalImageFormatPropertiesNVBuilder<'a> {
13180     inner: ExternalImageFormatPropertiesNV,
13181     marker: ::std::marker::PhantomData<&'a ()>,
13182 }
13183 impl<'a> ::std::ops::Deref for ExternalImageFormatPropertiesNVBuilder<'a> {
13184     type Target = ExternalImageFormatPropertiesNV;
deref(&self) -> &Self::Target13185     fn deref(&self) -> &Self::Target {
13186         &self.inner
13187     }
13188 }
13189 impl<'a> ::std::ops::DerefMut for ExternalImageFormatPropertiesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target13190     fn deref_mut(&mut self) -> &mut Self::Target {
13191         &mut self.inner
13192     }
13193 }
13194 impl<'a> ExternalImageFormatPropertiesNVBuilder<'a> {
13195     #[inline]
image_format_properties( mut self, image_format_properties: ImageFormatProperties, ) -> Self13196     pub fn image_format_properties(
13197         mut self,
13198         image_format_properties: ImageFormatProperties,
13199     ) -> Self {
13200         self.inner.image_format_properties = image_format_properties;
13201         self
13202     }
13203     #[inline]
external_memory_features( mut self, external_memory_features: ExternalMemoryFeatureFlagsNV, ) -> Self13204     pub fn external_memory_features(
13205         mut self,
13206         external_memory_features: ExternalMemoryFeatureFlagsNV,
13207     ) -> Self {
13208         self.inner.external_memory_features = external_memory_features;
13209         self
13210     }
13211     #[inline]
export_from_imported_handle_types( mut self, export_from_imported_handle_types: ExternalMemoryHandleTypeFlagsNV, ) -> Self13212     pub fn export_from_imported_handle_types(
13213         mut self,
13214         export_from_imported_handle_types: ExternalMemoryHandleTypeFlagsNV,
13215     ) -> Self {
13216         self.inner.export_from_imported_handle_types = export_from_imported_handle_types;
13217         self
13218     }
13219     #[inline]
compatible_handle_types( mut self, compatible_handle_types: ExternalMemoryHandleTypeFlagsNV, ) -> Self13220     pub fn compatible_handle_types(
13221         mut self,
13222         compatible_handle_types: ExternalMemoryHandleTypeFlagsNV,
13223     ) -> Self {
13224         self.inner.compatible_handle_types = compatible_handle_types;
13225         self
13226     }
13227     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13228     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13229     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExternalImageFormatPropertiesNV13230     pub fn build(self) -> ExternalImageFormatPropertiesNV {
13231         self.inner
13232     }
13233 }
13234 #[repr(C)]
13235 #[cfg_attr(feature = "debug", derive(Debug))]
13236 #[derive(Copy, Clone)]
13237 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryImageCreateInfoNV.html>"]
13238 pub struct ExternalMemoryImageCreateInfoNV {
13239     pub s_type: StructureType,
13240     pub p_next: *const c_void,
13241     pub handle_types: ExternalMemoryHandleTypeFlagsNV,
13242 }
13243 impl ::std::default::Default for ExternalMemoryImageCreateInfoNV {
13244     #[inline]
default() -> Self13245     fn default() -> Self {
13246         Self {
13247             s_type: Self::STRUCTURE_TYPE,
13248             p_next: ::std::ptr::null(),
13249             handle_types: ExternalMemoryHandleTypeFlagsNV::default(),
13250         }
13251     }
13252 }
13253 unsafe impl TaggedStructure for ExternalMemoryImageCreateInfoNV {
13254     const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV;
13255 }
13256 impl ExternalMemoryImageCreateInfoNV {
builder<'a>() -> ExternalMemoryImageCreateInfoNVBuilder<'a>13257     pub fn builder<'a>() -> ExternalMemoryImageCreateInfoNVBuilder<'a> {
13258         ExternalMemoryImageCreateInfoNVBuilder {
13259             inner: Self::default(),
13260             marker: ::std::marker::PhantomData,
13261         }
13262     }
13263 }
13264 #[repr(transparent)]
13265 pub struct ExternalMemoryImageCreateInfoNVBuilder<'a> {
13266     inner: ExternalMemoryImageCreateInfoNV,
13267     marker: ::std::marker::PhantomData<&'a ()>,
13268 }
13269 unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoNVBuilder<'_> {}
13270 unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoNV {}
13271 impl<'a> ::std::ops::Deref for ExternalMemoryImageCreateInfoNVBuilder<'a> {
13272     type Target = ExternalMemoryImageCreateInfoNV;
deref(&self) -> &Self::Target13273     fn deref(&self) -> &Self::Target {
13274         &self.inner
13275     }
13276 }
13277 impl<'a> ::std::ops::DerefMut for ExternalMemoryImageCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target13278     fn deref_mut(&mut self) -> &mut Self::Target {
13279         &mut self.inner
13280     }
13281 }
13282 impl<'a> ExternalMemoryImageCreateInfoNVBuilder<'a> {
13283     #[inline]
handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlagsNV) -> Self13284     pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlagsNV) -> Self {
13285         self.inner.handle_types = handle_types;
13286         self
13287     }
13288     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13289     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13290     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExternalMemoryImageCreateInfoNV13291     pub fn build(self) -> ExternalMemoryImageCreateInfoNV {
13292         self.inner
13293     }
13294 }
13295 #[repr(C)]
13296 #[cfg_attr(feature = "debug", derive(Debug))]
13297 #[derive(Copy, Clone)]
13298 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMemoryAllocateInfoNV.html>"]
13299 pub struct ExportMemoryAllocateInfoNV {
13300     pub s_type: StructureType,
13301     pub p_next: *const c_void,
13302     pub handle_types: ExternalMemoryHandleTypeFlagsNV,
13303 }
13304 impl ::std::default::Default for ExportMemoryAllocateInfoNV {
13305     #[inline]
default() -> Self13306     fn default() -> Self {
13307         Self {
13308             s_type: Self::STRUCTURE_TYPE,
13309             p_next: ::std::ptr::null(),
13310             handle_types: ExternalMemoryHandleTypeFlagsNV::default(),
13311         }
13312     }
13313 }
13314 unsafe impl TaggedStructure for ExportMemoryAllocateInfoNV {
13315     const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_MEMORY_ALLOCATE_INFO_NV;
13316 }
13317 impl ExportMemoryAllocateInfoNV {
builder<'a>() -> ExportMemoryAllocateInfoNVBuilder<'a>13318     pub fn builder<'a>() -> ExportMemoryAllocateInfoNVBuilder<'a> {
13319         ExportMemoryAllocateInfoNVBuilder {
13320             inner: Self::default(),
13321             marker: ::std::marker::PhantomData,
13322         }
13323     }
13324 }
13325 #[repr(transparent)]
13326 pub struct ExportMemoryAllocateInfoNVBuilder<'a> {
13327     inner: ExportMemoryAllocateInfoNV,
13328     marker: ::std::marker::PhantomData<&'a ()>,
13329 }
13330 unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoNVBuilder<'_> {}
13331 unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoNV {}
13332 impl<'a> ::std::ops::Deref for ExportMemoryAllocateInfoNVBuilder<'a> {
13333     type Target = ExportMemoryAllocateInfoNV;
deref(&self) -> &Self::Target13334     fn deref(&self) -> &Self::Target {
13335         &self.inner
13336     }
13337 }
13338 impl<'a> ::std::ops::DerefMut for ExportMemoryAllocateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target13339     fn deref_mut(&mut self) -> &mut Self::Target {
13340         &mut self.inner
13341     }
13342 }
13343 impl<'a> ExportMemoryAllocateInfoNVBuilder<'a> {
13344     #[inline]
handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlagsNV) -> Self13345     pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlagsNV) -> Self {
13346         self.inner.handle_types = handle_types;
13347         self
13348     }
13349     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13350     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13351     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExportMemoryAllocateInfoNV13352     pub fn build(self) -> ExportMemoryAllocateInfoNV {
13353         self.inner
13354     }
13355 }
13356 #[repr(C)]
13357 #[cfg_attr(feature = "debug", derive(Debug))]
13358 #[derive(Copy, Clone)]
13359 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMemoryWin32HandleInfoNV.html>"]
13360 pub struct ImportMemoryWin32HandleInfoNV {
13361     pub s_type: StructureType,
13362     pub p_next: *const c_void,
13363     pub handle_type: ExternalMemoryHandleTypeFlagsNV,
13364     pub handle: HANDLE,
13365 }
13366 impl ::std::default::Default for ImportMemoryWin32HandleInfoNV {
13367     #[inline]
default() -> Self13368     fn default() -> Self {
13369         Self {
13370             s_type: Self::STRUCTURE_TYPE,
13371             p_next: ::std::ptr::null(),
13372             handle_type: ExternalMemoryHandleTypeFlagsNV::default(),
13373             handle: unsafe { ::std::mem::zeroed() },
13374         }
13375     }
13376 }
13377 unsafe impl TaggedStructure for ImportMemoryWin32HandleInfoNV {
13378     const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_MEMORY_WIN32_HANDLE_INFO_NV;
13379 }
13380 impl ImportMemoryWin32HandleInfoNV {
builder<'a>() -> ImportMemoryWin32HandleInfoNVBuilder<'a>13381     pub fn builder<'a>() -> ImportMemoryWin32HandleInfoNVBuilder<'a> {
13382         ImportMemoryWin32HandleInfoNVBuilder {
13383             inner: Self::default(),
13384             marker: ::std::marker::PhantomData,
13385         }
13386     }
13387 }
13388 #[repr(transparent)]
13389 pub struct ImportMemoryWin32HandleInfoNVBuilder<'a> {
13390     inner: ImportMemoryWin32HandleInfoNV,
13391     marker: ::std::marker::PhantomData<&'a ()>,
13392 }
13393 unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoNVBuilder<'_> {}
13394 unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoNV {}
13395 impl<'a> ::std::ops::Deref for ImportMemoryWin32HandleInfoNVBuilder<'a> {
13396     type Target = ImportMemoryWin32HandleInfoNV;
deref(&self) -> &Self::Target13397     fn deref(&self) -> &Self::Target {
13398         &self.inner
13399     }
13400 }
13401 impl<'a> ::std::ops::DerefMut for ImportMemoryWin32HandleInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target13402     fn deref_mut(&mut self) -> &mut Self::Target {
13403         &mut self.inner
13404     }
13405 }
13406 impl<'a> ImportMemoryWin32HandleInfoNVBuilder<'a> {
13407     #[inline]
handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlagsNV) -> Self13408     pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlagsNV) -> Self {
13409         self.inner.handle_type = handle_type;
13410         self
13411     }
13412     #[inline]
handle(mut self, handle: HANDLE) -> Self13413     pub fn handle(mut self, handle: HANDLE) -> Self {
13414         self.inner.handle = handle;
13415         self
13416     }
13417     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13418     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13419     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImportMemoryWin32HandleInfoNV13420     pub fn build(self) -> ImportMemoryWin32HandleInfoNV {
13421         self.inner
13422     }
13423 }
13424 #[repr(C)]
13425 #[cfg_attr(feature = "debug", derive(Debug))]
13426 #[derive(Copy, Clone)]
13427 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMemoryWin32HandleInfoNV.html>"]
13428 pub struct ExportMemoryWin32HandleInfoNV {
13429     pub s_type: StructureType,
13430     pub p_next: *const c_void,
13431     pub p_attributes: *const SECURITY_ATTRIBUTES,
13432     pub dw_access: DWORD,
13433 }
13434 impl ::std::default::Default for ExportMemoryWin32HandleInfoNV {
13435     #[inline]
default() -> Self13436     fn default() -> Self {
13437         Self {
13438             s_type: Self::STRUCTURE_TYPE,
13439             p_next: ::std::ptr::null(),
13440             p_attributes: ::std::ptr::null(),
13441             dw_access: DWORD::default(),
13442         }
13443     }
13444 }
13445 unsafe impl TaggedStructure for ExportMemoryWin32HandleInfoNV {
13446     const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_MEMORY_WIN32_HANDLE_INFO_NV;
13447 }
13448 impl ExportMemoryWin32HandleInfoNV {
builder<'a>() -> ExportMemoryWin32HandleInfoNVBuilder<'a>13449     pub fn builder<'a>() -> ExportMemoryWin32HandleInfoNVBuilder<'a> {
13450         ExportMemoryWin32HandleInfoNVBuilder {
13451             inner: Self::default(),
13452             marker: ::std::marker::PhantomData,
13453         }
13454     }
13455 }
13456 #[repr(transparent)]
13457 pub struct ExportMemoryWin32HandleInfoNVBuilder<'a> {
13458     inner: ExportMemoryWin32HandleInfoNV,
13459     marker: ::std::marker::PhantomData<&'a ()>,
13460 }
13461 unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoNVBuilder<'_> {}
13462 unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoNV {}
13463 impl<'a> ::std::ops::Deref for ExportMemoryWin32HandleInfoNVBuilder<'a> {
13464     type Target = ExportMemoryWin32HandleInfoNV;
deref(&self) -> &Self::Target13465     fn deref(&self) -> &Self::Target {
13466         &self.inner
13467     }
13468 }
13469 impl<'a> ::std::ops::DerefMut for ExportMemoryWin32HandleInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target13470     fn deref_mut(&mut self) -> &mut Self::Target {
13471         &mut self.inner
13472     }
13473 }
13474 impl<'a> ExportMemoryWin32HandleInfoNVBuilder<'a> {
13475     #[inline]
attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self13476     pub fn attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self {
13477         self.inner.p_attributes = attributes;
13478         self
13479     }
13480     #[inline]
dw_access(mut self, dw_access: DWORD) -> Self13481     pub fn dw_access(mut self, dw_access: DWORD) -> Self {
13482         self.inner.dw_access = dw_access;
13483         self
13484     }
13485     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13486     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13487     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExportMemoryWin32HandleInfoNV13488     pub fn build(self) -> ExportMemoryWin32HandleInfoNV {
13489         self.inner
13490     }
13491 }
13492 #[repr(C)]
13493 #[cfg_attr(feature = "debug", derive(Debug))]
13494 #[derive(Copy, Clone)]
13495 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWin32KeyedMutexAcquireReleaseInfoNV.html>"]
13496 pub struct Win32KeyedMutexAcquireReleaseInfoNV {
13497     pub s_type: StructureType,
13498     pub p_next: *const c_void,
13499     pub acquire_count: u32,
13500     pub p_acquire_syncs: *const DeviceMemory,
13501     pub p_acquire_keys: *const u64,
13502     pub p_acquire_timeout_milliseconds: *const u32,
13503     pub release_count: u32,
13504     pub p_release_syncs: *const DeviceMemory,
13505     pub p_release_keys: *const u64,
13506 }
13507 impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoNV {
13508     #[inline]
default() -> Self13509     fn default() -> Self {
13510         Self {
13511             s_type: Self::STRUCTURE_TYPE,
13512             p_next: ::std::ptr::null(),
13513             acquire_count: u32::default(),
13514             p_acquire_syncs: ::std::ptr::null(),
13515             p_acquire_keys: ::std::ptr::null(),
13516             p_acquire_timeout_milliseconds: ::std::ptr::null(),
13517             release_count: u32::default(),
13518             p_release_syncs: ::std::ptr::null(),
13519             p_release_keys: ::std::ptr::null(),
13520         }
13521     }
13522 }
13523 unsafe impl TaggedStructure for Win32KeyedMutexAcquireReleaseInfoNV {
13524     const STRUCTURE_TYPE: StructureType = StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV;
13525 }
13526 impl Win32KeyedMutexAcquireReleaseInfoNV {
builder<'a>() -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a>13527     pub fn builder<'a>() -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
13528         Win32KeyedMutexAcquireReleaseInfoNVBuilder {
13529             inner: Self::default(),
13530             marker: ::std::marker::PhantomData,
13531         }
13532     }
13533 }
13534 #[repr(transparent)]
13535 pub struct Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
13536     inner: Win32KeyedMutexAcquireReleaseInfoNV,
13537     marker: ::std::marker::PhantomData<&'a ()>,
13538 }
13539 unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'_> {}
13540 unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoNV {}
13541 unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'_> {}
13542 unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoNV {}
13543 impl<'a> ::std::ops::Deref for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
13544     type Target = Win32KeyedMutexAcquireReleaseInfoNV;
deref(&self) -> &Self::Target13545     fn deref(&self) -> &Self::Target {
13546         &self.inner
13547     }
13548 }
13549 impl<'a> ::std::ops::DerefMut for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target13550     fn deref_mut(&mut self) -> &mut Self::Target {
13551         &mut self.inner
13552     }
13553 }
13554 impl<'a> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
13555     #[inline]
acquire_syncs(mut self, acquire_syncs: &'a [DeviceMemory]) -> Self13556     pub fn acquire_syncs(mut self, acquire_syncs: &'a [DeviceMemory]) -> Self {
13557         self.inner.acquire_count = acquire_syncs.len() as _;
13558         self.inner.p_acquire_syncs = acquire_syncs.as_ptr();
13559         self
13560     }
13561     #[inline]
acquire_keys(mut self, acquire_keys: &'a [u64]) -> Self13562     pub fn acquire_keys(mut self, acquire_keys: &'a [u64]) -> Self {
13563         self.inner.acquire_count = acquire_keys.len() as _;
13564         self.inner.p_acquire_keys = acquire_keys.as_ptr();
13565         self
13566     }
13567     #[inline]
acquire_timeout_milliseconds(mut self, acquire_timeout_milliseconds: &'a [u32]) -> Self13568     pub fn acquire_timeout_milliseconds(mut self, acquire_timeout_milliseconds: &'a [u32]) -> Self {
13569         self.inner.acquire_count = acquire_timeout_milliseconds.len() as _;
13570         self.inner.p_acquire_timeout_milliseconds = acquire_timeout_milliseconds.as_ptr();
13571         self
13572     }
13573     #[inline]
release_syncs(mut self, release_syncs: &'a [DeviceMemory]) -> Self13574     pub fn release_syncs(mut self, release_syncs: &'a [DeviceMemory]) -> Self {
13575         self.inner.release_count = release_syncs.len() as _;
13576         self.inner.p_release_syncs = release_syncs.as_ptr();
13577         self
13578     }
13579     #[inline]
release_keys(mut self, release_keys: &'a [u64]) -> Self13580     pub fn release_keys(mut self, release_keys: &'a [u64]) -> Self {
13581         self.inner.release_count = release_keys.len() as _;
13582         self.inner.p_release_keys = release_keys.as_ptr();
13583         self
13584     }
13585     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13586     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13587     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> Win32KeyedMutexAcquireReleaseInfoNV13588     pub fn build(self) -> Win32KeyedMutexAcquireReleaseInfoNV {
13589         self.inner
13590     }
13591 }
13592 #[repr(C)]
13593 #[cfg_attr(feature = "debug", derive(Debug))]
13594 #[derive(Copy, Clone)]
13595 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV.html>"]
13596 pub struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
13597     pub s_type: StructureType,
13598     pub p_next: *mut c_void,
13599     pub device_generated_commands: Bool32,
13600 }
13601 impl ::std::default::Default for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
13602     #[inline]
default() -> Self13603     fn default() -> Self {
13604         Self {
13605             s_type: Self::STRUCTURE_TYPE,
13606             p_next: ::std::ptr::null_mut(),
13607             device_generated_commands: Bool32::default(),
13608         }
13609     }
13610 }
13611 unsafe impl TaggedStructure for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
13612     const STRUCTURE_TYPE: StructureType =
13613         StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
13614 }
13615 impl PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
builder<'a>() -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a>13616     pub fn builder<'a>() -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
13617         PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder {
13618             inner: Self::default(),
13619             marker: ::std::marker::PhantomData,
13620         }
13621     }
13622 }
13623 #[repr(transparent)]
13624 pub struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
13625     inner: PhysicalDeviceDeviceGeneratedCommandsFeaturesNV,
13626     marker: ::std::marker::PhantomData<&'a ()>,
13627 }
13628 unsafe impl ExtendsPhysicalDeviceFeatures2
13629     for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'_>
13630 {
13631 }
13632 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {}
13633 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'_> {}
13634 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {}
13635 impl<'a> ::std::ops::Deref for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
13636     type Target = PhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
deref(&self) -> &Self::Target13637     fn deref(&self) -> &Self::Target {
13638         &self.inner
13639     }
13640 }
13641 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target13642     fn deref_mut(&mut self) -> &mut Self::Target {
13643         &mut self.inner
13644     }
13645 }
13646 impl<'a> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
13647     #[inline]
device_generated_commands(mut self, device_generated_commands: bool) -> Self13648     pub fn device_generated_commands(mut self, device_generated_commands: bool) -> Self {
13649         self.inner.device_generated_commands = device_generated_commands.into();
13650         self
13651     }
13652     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13653     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13654     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNV13655     pub fn build(self) -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
13656         self.inner
13657     }
13658 }
13659 #[repr(C)]
13660 #[cfg_attr(feature = "debug", derive(Debug))]
13661 #[derive(Copy, Clone)]
13662 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDevicePrivateDataCreateInfo.html>"]
13663 pub struct DevicePrivateDataCreateInfo {
13664     pub s_type: StructureType,
13665     pub p_next: *const c_void,
13666     pub private_data_slot_request_count: u32,
13667 }
13668 impl ::std::default::Default for DevicePrivateDataCreateInfo {
13669     #[inline]
default() -> Self13670     fn default() -> Self {
13671         Self {
13672             s_type: Self::STRUCTURE_TYPE,
13673             p_next: ::std::ptr::null(),
13674             private_data_slot_request_count: u32::default(),
13675         }
13676     }
13677 }
13678 unsafe impl TaggedStructure for DevicePrivateDataCreateInfo {
13679     const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_PRIVATE_DATA_CREATE_INFO;
13680 }
13681 impl DevicePrivateDataCreateInfo {
builder<'a>() -> DevicePrivateDataCreateInfoBuilder<'a>13682     pub fn builder<'a>() -> DevicePrivateDataCreateInfoBuilder<'a> {
13683         DevicePrivateDataCreateInfoBuilder {
13684             inner: Self::default(),
13685             marker: ::std::marker::PhantomData,
13686         }
13687     }
13688 }
13689 #[repr(transparent)]
13690 pub struct DevicePrivateDataCreateInfoBuilder<'a> {
13691     inner: DevicePrivateDataCreateInfo,
13692     marker: ::std::marker::PhantomData<&'a ()>,
13693 }
13694 unsafe impl ExtendsDeviceCreateInfo for DevicePrivateDataCreateInfoBuilder<'_> {}
13695 unsafe impl ExtendsDeviceCreateInfo for DevicePrivateDataCreateInfo {}
13696 impl<'a> ::std::ops::Deref for DevicePrivateDataCreateInfoBuilder<'a> {
13697     type Target = DevicePrivateDataCreateInfo;
deref(&self) -> &Self::Target13698     fn deref(&self) -> &Self::Target {
13699         &self.inner
13700     }
13701 }
13702 impl<'a> ::std::ops::DerefMut for DevicePrivateDataCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target13703     fn deref_mut(&mut self) -> &mut Self::Target {
13704         &mut self.inner
13705     }
13706 }
13707 impl<'a> DevicePrivateDataCreateInfoBuilder<'a> {
13708     #[inline]
private_data_slot_request_count(mut self, private_data_slot_request_count: u32) -> Self13709     pub fn private_data_slot_request_count(mut self, private_data_slot_request_count: u32) -> Self {
13710         self.inner.private_data_slot_request_count = private_data_slot_request_count;
13711         self
13712     }
13713     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13714     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13715     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DevicePrivateDataCreateInfo13716     pub fn build(self) -> DevicePrivateDataCreateInfo {
13717         self.inner
13718     }
13719 }
13720 #[repr(C)]
13721 #[cfg_attr(feature = "debug", derive(Debug))]
13722 #[derive(Copy, Clone)]
13723 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPrivateDataSlotCreateInfo.html>"]
13724 pub struct PrivateDataSlotCreateInfo {
13725     pub s_type: StructureType,
13726     pub p_next: *const c_void,
13727     pub flags: PrivateDataSlotCreateFlags,
13728 }
13729 impl ::std::default::Default for PrivateDataSlotCreateInfo {
13730     #[inline]
default() -> Self13731     fn default() -> Self {
13732         Self {
13733             s_type: Self::STRUCTURE_TYPE,
13734             p_next: ::std::ptr::null(),
13735             flags: PrivateDataSlotCreateFlags::default(),
13736         }
13737     }
13738 }
13739 unsafe impl TaggedStructure for PrivateDataSlotCreateInfo {
13740     const STRUCTURE_TYPE: StructureType = StructureType::PRIVATE_DATA_SLOT_CREATE_INFO;
13741 }
13742 impl PrivateDataSlotCreateInfo {
builder<'a>() -> PrivateDataSlotCreateInfoBuilder<'a>13743     pub fn builder<'a>() -> PrivateDataSlotCreateInfoBuilder<'a> {
13744         PrivateDataSlotCreateInfoBuilder {
13745             inner: Self::default(),
13746             marker: ::std::marker::PhantomData,
13747         }
13748     }
13749 }
13750 #[repr(transparent)]
13751 pub struct PrivateDataSlotCreateInfoBuilder<'a> {
13752     inner: PrivateDataSlotCreateInfo,
13753     marker: ::std::marker::PhantomData<&'a ()>,
13754 }
13755 impl<'a> ::std::ops::Deref for PrivateDataSlotCreateInfoBuilder<'a> {
13756     type Target = PrivateDataSlotCreateInfo;
deref(&self) -> &Self::Target13757     fn deref(&self) -> &Self::Target {
13758         &self.inner
13759     }
13760 }
13761 impl<'a> ::std::ops::DerefMut for PrivateDataSlotCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target13762     fn deref_mut(&mut self) -> &mut Self::Target {
13763         &mut self.inner
13764     }
13765 }
13766 impl<'a> PrivateDataSlotCreateInfoBuilder<'a> {
13767     #[inline]
flags(mut self, flags: PrivateDataSlotCreateFlags) -> Self13768     pub fn flags(mut self, flags: PrivateDataSlotCreateFlags) -> Self {
13769         self.inner.flags = flags;
13770         self
13771     }
13772     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13773     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13774     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PrivateDataSlotCreateInfo13775     pub fn build(self) -> PrivateDataSlotCreateInfo {
13776         self.inner
13777     }
13778 }
13779 #[repr(C)]
13780 #[cfg_attr(feature = "debug", derive(Debug))]
13781 #[derive(Copy, Clone)]
13782 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePrivateDataFeatures.html>"]
13783 pub struct PhysicalDevicePrivateDataFeatures {
13784     pub s_type: StructureType,
13785     pub p_next: *mut c_void,
13786     pub private_data: Bool32,
13787 }
13788 impl ::std::default::Default for PhysicalDevicePrivateDataFeatures {
13789     #[inline]
default() -> Self13790     fn default() -> Self {
13791         Self {
13792             s_type: Self::STRUCTURE_TYPE,
13793             p_next: ::std::ptr::null_mut(),
13794             private_data: Bool32::default(),
13795         }
13796     }
13797 }
13798 unsafe impl TaggedStructure for PhysicalDevicePrivateDataFeatures {
13799     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
13800 }
13801 impl PhysicalDevicePrivateDataFeatures {
builder<'a>() -> PhysicalDevicePrivateDataFeaturesBuilder<'a>13802     pub fn builder<'a>() -> PhysicalDevicePrivateDataFeaturesBuilder<'a> {
13803         PhysicalDevicePrivateDataFeaturesBuilder {
13804             inner: Self::default(),
13805             marker: ::std::marker::PhantomData,
13806         }
13807     }
13808 }
13809 #[repr(transparent)]
13810 pub struct PhysicalDevicePrivateDataFeaturesBuilder<'a> {
13811     inner: PhysicalDevicePrivateDataFeatures,
13812     marker: ::std::marker::PhantomData<&'a ()>,
13813 }
13814 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePrivateDataFeaturesBuilder<'_> {}
13815 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePrivateDataFeatures {}
13816 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrivateDataFeaturesBuilder<'_> {}
13817 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrivateDataFeatures {}
13818 impl<'a> ::std::ops::Deref for PhysicalDevicePrivateDataFeaturesBuilder<'a> {
13819     type Target = PhysicalDevicePrivateDataFeatures;
deref(&self) -> &Self::Target13820     fn deref(&self) -> &Self::Target {
13821         &self.inner
13822     }
13823 }
13824 impl<'a> ::std::ops::DerefMut for PhysicalDevicePrivateDataFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target13825     fn deref_mut(&mut self) -> &mut Self::Target {
13826         &mut self.inner
13827     }
13828 }
13829 impl<'a> PhysicalDevicePrivateDataFeaturesBuilder<'a> {
13830     #[inline]
private_data(mut self, private_data: bool) -> Self13831     pub fn private_data(mut self, private_data: bool) -> Self {
13832         self.inner.private_data = private_data.into();
13833         self
13834     }
13835     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13836     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13837     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePrivateDataFeatures13838     pub fn build(self) -> PhysicalDevicePrivateDataFeatures {
13839         self.inner
13840     }
13841 }
13842 #[repr(C)]
13843 #[cfg_attr(feature = "debug", derive(Debug))]
13844 #[derive(Copy, Clone)]
13845 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV.html>"]
13846 pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
13847     pub s_type: StructureType,
13848     pub p_next: *mut c_void,
13849     pub max_graphics_shader_group_count: u32,
13850     pub max_indirect_sequence_count: u32,
13851     pub max_indirect_commands_token_count: u32,
13852     pub max_indirect_commands_stream_count: u32,
13853     pub max_indirect_commands_token_offset: u32,
13854     pub max_indirect_commands_stream_stride: u32,
13855     pub min_sequences_count_buffer_offset_alignment: u32,
13856     pub min_sequences_index_buffer_offset_alignment: u32,
13857     pub min_indirect_commands_buffer_offset_alignment: u32,
13858 }
13859 impl ::std::default::Default for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
13860     #[inline]
default() -> Self13861     fn default() -> Self {
13862         Self {
13863             s_type: Self::STRUCTURE_TYPE,
13864             p_next: ::std::ptr::null_mut(),
13865             max_graphics_shader_group_count: u32::default(),
13866             max_indirect_sequence_count: u32::default(),
13867             max_indirect_commands_token_count: u32::default(),
13868             max_indirect_commands_stream_count: u32::default(),
13869             max_indirect_commands_token_offset: u32::default(),
13870             max_indirect_commands_stream_stride: u32::default(),
13871             min_sequences_count_buffer_offset_alignment: u32::default(),
13872             min_sequences_index_buffer_offset_alignment: u32::default(),
13873             min_indirect_commands_buffer_offset_alignment: u32::default(),
13874         }
13875     }
13876 }
13877 unsafe impl TaggedStructure for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
13878     const STRUCTURE_TYPE: StructureType =
13879         StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV;
13880 }
13881 impl PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
builder<'a>() -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a>13882     pub fn builder<'a>() -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
13883         PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder {
13884             inner: Self::default(),
13885             marker: ::std::marker::PhantomData,
13886         }
13887     }
13888 }
13889 #[repr(transparent)]
13890 pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
13891     inner: PhysicalDeviceDeviceGeneratedCommandsPropertiesNV,
13892     marker: ::std::marker::PhantomData<&'a ()>,
13893 }
13894 unsafe impl ExtendsPhysicalDeviceProperties2
13895     for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'_>
13896 {
13897 }
13898 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {}
13899 impl<'a> ::std::ops::Deref for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
13900     type Target = PhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
deref(&self) -> &Self::Target13901     fn deref(&self) -> &Self::Target {
13902         &self.inner
13903     }
13904 }
13905 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target13906     fn deref_mut(&mut self) -> &mut Self::Target {
13907         &mut self.inner
13908     }
13909 }
13910 impl<'a> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
13911     #[inline]
max_graphics_shader_group_count(mut self, max_graphics_shader_group_count: u32) -> Self13912     pub fn max_graphics_shader_group_count(mut self, max_graphics_shader_group_count: u32) -> Self {
13913         self.inner.max_graphics_shader_group_count = max_graphics_shader_group_count;
13914         self
13915     }
13916     #[inline]
max_indirect_sequence_count(mut self, max_indirect_sequence_count: u32) -> Self13917     pub fn max_indirect_sequence_count(mut self, max_indirect_sequence_count: u32) -> Self {
13918         self.inner.max_indirect_sequence_count = max_indirect_sequence_count;
13919         self
13920     }
13921     #[inline]
max_indirect_commands_token_count( mut self, max_indirect_commands_token_count: u32, ) -> Self13922     pub fn max_indirect_commands_token_count(
13923         mut self,
13924         max_indirect_commands_token_count: u32,
13925     ) -> Self {
13926         self.inner.max_indirect_commands_token_count = max_indirect_commands_token_count;
13927         self
13928     }
13929     #[inline]
max_indirect_commands_stream_count( mut self, max_indirect_commands_stream_count: u32, ) -> Self13930     pub fn max_indirect_commands_stream_count(
13931         mut self,
13932         max_indirect_commands_stream_count: u32,
13933     ) -> Self {
13934         self.inner.max_indirect_commands_stream_count = max_indirect_commands_stream_count;
13935         self
13936     }
13937     #[inline]
max_indirect_commands_token_offset( mut self, max_indirect_commands_token_offset: u32, ) -> Self13938     pub fn max_indirect_commands_token_offset(
13939         mut self,
13940         max_indirect_commands_token_offset: u32,
13941     ) -> Self {
13942         self.inner.max_indirect_commands_token_offset = max_indirect_commands_token_offset;
13943         self
13944     }
13945     #[inline]
max_indirect_commands_stream_stride( mut self, max_indirect_commands_stream_stride: u32, ) -> Self13946     pub fn max_indirect_commands_stream_stride(
13947         mut self,
13948         max_indirect_commands_stream_stride: u32,
13949     ) -> Self {
13950         self.inner.max_indirect_commands_stream_stride = max_indirect_commands_stream_stride;
13951         self
13952     }
13953     #[inline]
min_sequences_count_buffer_offset_alignment( mut self, min_sequences_count_buffer_offset_alignment: u32, ) -> Self13954     pub fn min_sequences_count_buffer_offset_alignment(
13955         mut self,
13956         min_sequences_count_buffer_offset_alignment: u32,
13957     ) -> Self {
13958         self.inner.min_sequences_count_buffer_offset_alignment =
13959             min_sequences_count_buffer_offset_alignment;
13960         self
13961     }
13962     #[inline]
min_sequences_index_buffer_offset_alignment( mut self, min_sequences_index_buffer_offset_alignment: u32, ) -> Self13963     pub fn min_sequences_index_buffer_offset_alignment(
13964         mut self,
13965         min_sequences_index_buffer_offset_alignment: u32,
13966     ) -> Self {
13967         self.inner.min_sequences_index_buffer_offset_alignment =
13968             min_sequences_index_buffer_offset_alignment;
13969         self
13970     }
13971     #[inline]
min_indirect_commands_buffer_offset_alignment( mut self, min_indirect_commands_buffer_offset_alignment: u32, ) -> Self13972     pub fn min_indirect_commands_buffer_offset_alignment(
13973         mut self,
13974         min_indirect_commands_buffer_offset_alignment: u32,
13975     ) -> Self {
13976         self.inner.min_indirect_commands_buffer_offset_alignment =
13977             min_indirect_commands_buffer_offset_alignment;
13978         self
13979     }
13980     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13981     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13982     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNV13983     pub fn build(self) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
13984         self.inner
13985     }
13986 }
13987 #[repr(C)]
13988 #[cfg_attr(feature = "debug", derive(Debug))]
13989 #[derive(Copy, Clone)]
13990 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiDrawPropertiesEXT.html>"]
13991 pub struct PhysicalDeviceMultiDrawPropertiesEXT {
13992     pub s_type: StructureType,
13993     pub p_next: *mut c_void,
13994     pub max_multi_draw_count: u32,
13995 }
13996 impl ::std::default::Default for PhysicalDeviceMultiDrawPropertiesEXT {
13997     #[inline]
default() -> Self13998     fn default() -> Self {
13999         Self {
14000             s_type: Self::STRUCTURE_TYPE,
14001             p_next: ::std::ptr::null_mut(),
14002             max_multi_draw_count: u32::default(),
14003         }
14004     }
14005 }
14006 unsafe impl TaggedStructure for PhysicalDeviceMultiDrawPropertiesEXT {
14007     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT;
14008 }
14009 impl PhysicalDeviceMultiDrawPropertiesEXT {
builder<'a>() -> PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a>14010     pub fn builder<'a>() -> PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> {
14011         PhysicalDeviceMultiDrawPropertiesEXTBuilder {
14012             inner: Self::default(),
14013             marker: ::std::marker::PhantomData,
14014         }
14015     }
14016 }
14017 #[repr(transparent)]
14018 pub struct PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> {
14019     inner: PhysicalDeviceMultiDrawPropertiesEXT,
14020     marker: ::std::marker::PhantomData<&'a ()>,
14021 }
14022 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiDrawPropertiesEXTBuilder<'_> {}
14023 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiDrawPropertiesEXT {}
14024 impl<'a> ::std::ops::Deref for PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> {
14025     type Target = PhysicalDeviceMultiDrawPropertiesEXT;
deref(&self) -> &Self::Target14026     fn deref(&self) -> &Self::Target {
14027         &self.inner
14028     }
14029 }
14030 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target14031     fn deref_mut(&mut self) -> &mut Self::Target {
14032         &mut self.inner
14033     }
14034 }
14035 impl<'a> PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> {
14036     #[inline]
max_multi_draw_count(mut self, max_multi_draw_count: u32) -> Self14037     pub fn max_multi_draw_count(mut self, max_multi_draw_count: u32) -> Self {
14038         self.inner.max_multi_draw_count = max_multi_draw_count;
14039         self
14040     }
14041     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14042     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14043     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMultiDrawPropertiesEXT14044     pub fn build(self) -> PhysicalDeviceMultiDrawPropertiesEXT {
14045         self.inner
14046     }
14047 }
14048 #[repr(C)]
14049 #[cfg_attr(feature = "debug", derive(Debug))]
14050 #[derive(Copy, Clone)]
14051 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGraphicsShaderGroupCreateInfoNV.html>"]
14052 pub struct GraphicsShaderGroupCreateInfoNV {
14053     pub s_type: StructureType,
14054     pub p_next: *const c_void,
14055     pub stage_count: u32,
14056     pub p_stages: *const PipelineShaderStageCreateInfo,
14057     pub p_vertex_input_state: *const PipelineVertexInputStateCreateInfo,
14058     pub p_tessellation_state: *const PipelineTessellationStateCreateInfo,
14059 }
14060 impl ::std::default::Default for GraphicsShaderGroupCreateInfoNV {
14061     #[inline]
default() -> Self14062     fn default() -> Self {
14063         Self {
14064             s_type: Self::STRUCTURE_TYPE,
14065             p_next: ::std::ptr::null(),
14066             stage_count: u32::default(),
14067             p_stages: ::std::ptr::null(),
14068             p_vertex_input_state: ::std::ptr::null(),
14069             p_tessellation_state: ::std::ptr::null(),
14070         }
14071     }
14072 }
14073 unsafe impl TaggedStructure for GraphicsShaderGroupCreateInfoNV {
14074     const STRUCTURE_TYPE: StructureType = StructureType::GRAPHICS_SHADER_GROUP_CREATE_INFO_NV;
14075 }
14076 impl GraphicsShaderGroupCreateInfoNV {
builder<'a>() -> GraphicsShaderGroupCreateInfoNVBuilder<'a>14077     pub fn builder<'a>() -> GraphicsShaderGroupCreateInfoNVBuilder<'a> {
14078         GraphicsShaderGroupCreateInfoNVBuilder {
14079             inner: Self::default(),
14080             marker: ::std::marker::PhantomData,
14081         }
14082     }
14083 }
14084 #[repr(transparent)]
14085 pub struct GraphicsShaderGroupCreateInfoNVBuilder<'a> {
14086     inner: GraphicsShaderGroupCreateInfoNV,
14087     marker: ::std::marker::PhantomData<&'a ()>,
14088 }
14089 impl<'a> ::std::ops::Deref for GraphicsShaderGroupCreateInfoNVBuilder<'a> {
14090     type Target = GraphicsShaderGroupCreateInfoNV;
deref(&self) -> &Self::Target14091     fn deref(&self) -> &Self::Target {
14092         &self.inner
14093     }
14094 }
14095 impl<'a> ::std::ops::DerefMut for GraphicsShaderGroupCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target14096     fn deref_mut(&mut self) -> &mut Self::Target {
14097         &mut self.inner
14098     }
14099 }
14100 impl<'a> GraphicsShaderGroupCreateInfoNVBuilder<'a> {
14101     #[inline]
stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self14102     pub fn stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self {
14103         self.inner.stage_count = stages.len() as _;
14104         self.inner.p_stages = stages.as_ptr();
14105         self
14106     }
14107     #[inline]
vertex_input_state( mut self, vertex_input_state: &'a PipelineVertexInputStateCreateInfo, ) -> Self14108     pub fn vertex_input_state(
14109         mut self,
14110         vertex_input_state: &'a PipelineVertexInputStateCreateInfo,
14111     ) -> Self {
14112         self.inner.p_vertex_input_state = vertex_input_state;
14113         self
14114     }
14115     #[inline]
tessellation_state( mut self, tessellation_state: &'a PipelineTessellationStateCreateInfo, ) -> Self14116     pub fn tessellation_state(
14117         mut self,
14118         tessellation_state: &'a PipelineTessellationStateCreateInfo,
14119     ) -> Self {
14120         self.inner.p_tessellation_state = tessellation_state;
14121         self
14122     }
14123     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14124     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14125     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> GraphicsShaderGroupCreateInfoNV14126     pub fn build(self) -> GraphicsShaderGroupCreateInfoNV {
14127         self.inner
14128     }
14129 }
14130 #[repr(C)]
14131 #[cfg_attr(feature = "debug", derive(Debug))]
14132 #[derive(Copy, Clone)]
14133 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGraphicsPipelineShaderGroupsCreateInfoNV.html>"]
14134 pub struct GraphicsPipelineShaderGroupsCreateInfoNV {
14135     pub s_type: StructureType,
14136     pub p_next: *const c_void,
14137     pub group_count: u32,
14138     pub p_groups: *const GraphicsShaderGroupCreateInfoNV,
14139     pub pipeline_count: u32,
14140     pub p_pipelines: *const Pipeline,
14141 }
14142 impl ::std::default::Default for GraphicsPipelineShaderGroupsCreateInfoNV {
14143     #[inline]
default() -> Self14144     fn default() -> Self {
14145         Self {
14146             s_type: Self::STRUCTURE_TYPE,
14147             p_next: ::std::ptr::null(),
14148             group_count: u32::default(),
14149             p_groups: ::std::ptr::null(),
14150             pipeline_count: u32::default(),
14151             p_pipelines: ::std::ptr::null(),
14152         }
14153     }
14154 }
14155 unsafe impl TaggedStructure for GraphicsPipelineShaderGroupsCreateInfoNV {
14156     const STRUCTURE_TYPE: StructureType =
14157         StructureType::GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV;
14158 }
14159 impl GraphicsPipelineShaderGroupsCreateInfoNV {
builder<'a>() -> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a>14160     pub fn builder<'a>() -> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
14161         GraphicsPipelineShaderGroupsCreateInfoNVBuilder {
14162             inner: Self::default(),
14163             marker: ::std::marker::PhantomData,
14164         }
14165     }
14166 }
14167 #[repr(transparent)]
14168 pub struct GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
14169     inner: GraphicsPipelineShaderGroupsCreateInfoNV,
14170     marker: ::std::marker::PhantomData<&'a ()>,
14171 }
14172 unsafe impl ExtendsGraphicsPipelineCreateInfo
14173     for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'_>
14174 {
14175 }
14176 unsafe impl ExtendsGraphicsPipelineCreateInfo for GraphicsPipelineShaderGroupsCreateInfoNV {}
14177 impl<'a> ::std::ops::Deref for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
14178     type Target = GraphicsPipelineShaderGroupsCreateInfoNV;
deref(&self) -> &Self::Target14179     fn deref(&self) -> &Self::Target {
14180         &self.inner
14181     }
14182 }
14183 impl<'a> ::std::ops::DerefMut for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target14184     fn deref_mut(&mut self) -> &mut Self::Target {
14185         &mut self.inner
14186     }
14187 }
14188 impl<'a> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
14189     #[inline]
groups(mut self, groups: &'a [GraphicsShaderGroupCreateInfoNV]) -> Self14190     pub fn groups(mut self, groups: &'a [GraphicsShaderGroupCreateInfoNV]) -> Self {
14191         self.inner.group_count = groups.len() as _;
14192         self.inner.p_groups = groups.as_ptr();
14193         self
14194     }
14195     #[inline]
pipelines(mut self, pipelines: &'a [Pipeline]) -> Self14196     pub fn pipelines(mut self, pipelines: &'a [Pipeline]) -> Self {
14197         self.inner.pipeline_count = pipelines.len() as _;
14198         self.inner.p_pipelines = pipelines.as_ptr();
14199         self
14200     }
14201     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14202     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14203     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> GraphicsPipelineShaderGroupsCreateInfoNV14204     pub fn build(self) -> GraphicsPipelineShaderGroupsCreateInfoNV {
14205         self.inner
14206     }
14207 }
14208 #[repr(C)]
14209 #[cfg_attr(feature = "debug", derive(Debug))]
14210 #[derive(Copy, Clone, Default)]
14211 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindShaderGroupIndirectCommandNV.html>"]
14212 pub struct BindShaderGroupIndirectCommandNV {
14213     pub group_index: u32,
14214 }
14215 impl BindShaderGroupIndirectCommandNV {
builder<'a>() -> BindShaderGroupIndirectCommandNVBuilder<'a>14216     pub fn builder<'a>() -> BindShaderGroupIndirectCommandNVBuilder<'a> {
14217         BindShaderGroupIndirectCommandNVBuilder {
14218             inner: Self::default(),
14219             marker: ::std::marker::PhantomData,
14220         }
14221     }
14222 }
14223 #[repr(transparent)]
14224 pub struct BindShaderGroupIndirectCommandNVBuilder<'a> {
14225     inner: BindShaderGroupIndirectCommandNV,
14226     marker: ::std::marker::PhantomData<&'a ()>,
14227 }
14228 impl<'a> ::std::ops::Deref for BindShaderGroupIndirectCommandNVBuilder<'a> {
14229     type Target = BindShaderGroupIndirectCommandNV;
deref(&self) -> &Self::Target14230     fn deref(&self) -> &Self::Target {
14231         &self.inner
14232     }
14233 }
14234 impl<'a> ::std::ops::DerefMut for BindShaderGroupIndirectCommandNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target14235     fn deref_mut(&mut self) -> &mut Self::Target {
14236         &mut self.inner
14237     }
14238 }
14239 impl<'a> BindShaderGroupIndirectCommandNVBuilder<'a> {
14240     #[inline]
group_index(mut self, group_index: u32) -> Self14241     pub fn group_index(mut self, group_index: u32) -> Self {
14242         self.inner.group_index = group_index;
14243         self
14244     }
14245     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14246     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14247     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BindShaderGroupIndirectCommandNV14248     pub fn build(self) -> BindShaderGroupIndirectCommandNV {
14249         self.inner
14250     }
14251 }
14252 #[repr(C)]
14253 #[cfg_attr(feature = "debug", derive(Debug))]
14254 #[derive(Copy, Clone, Default)]
14255 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindIndexBufferIndirectCommandNV.html>"]
14256 pub struct BindIndexBufferIndirectCommandNV {
14257     pub buffer_address: DeviceAddress,
14258     pub size: u32,
14259     pub index_type: IndexType,
14260 }
14261 impl BindIndexBufferIndirectCommandNV {
builder<'a>() -> BindIndexBufferIndirectCommandNVBuilder<'a>14262     pub fn builder<'a>() -> BindIndexBufferIndirectCommandNVBuilder<'a> {
14263         BindIndexBufferIndirectCommandNVBuilder {
14264             inner: Self::default(),
14265             marker: ::std::marker::PhantomData,
14266         }
14267     }
14268 }
14269 #[repr(transparent)]
14270 pub struct BindIndexBufferIndirectCommandNVBuilder<'a> {
14271     inner: BindIndexBufferIndirectCommandNV,
14272     marker: ::std::marker::PhantomData<&'a ()>,
14273 }
14274 impl<'a> ::std::ops::Deref for BindIndexBufferIndirectCommandNVBuilder<'a> {
14275     type Target = BindIndexBufferIndirectCommandNV;
deref(&self) -> &Self::Target14276     fn deref(&self) -> &Self::Target {
14277         &self.inner
14278     }
14279 }
14280 impl<'a> ::std::ops::DerefMut for BindIndexBufferIndirectCommandNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target14281     fn deref_mut(&mut self) -> &mut Self::Target {
14282         &mut self.inner
14283     }
14284 }
14285 impl<'a> BindIndexBufferIndirectCommandNVBuilder<'a> {
14286     #[inline]
buffer_address(mut self, buffer_address: DeviceAddress) -> Self14287     pub fn buffer_address(mut self, buffer_address: DeviceAddress) -> Self {
14288         self.inner.buffer_address = buffer_address;
14289         self
14290     }
14291     #[inline]
size(mut self, size: u32) -> Self14292     pub fn size(mut self, size: u32) -> Self {
14293         self.inner.size = size;
14294         self
14295     }
14296     #[inline]
index_type(mut self, index_type: IndexType) -> Self14297     pub fn index_type(mut self, index_type: IndexType) -> Self {
14298         self.inner.index_type = index_type;
14299         self
14300     }
14301     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14302     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14303     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BindIndexBufferIndirectCommandNV14304     pub fn build(self) -> BindIndexBufferIndirectCommandNV {
14305         self.inner
14306     }
14307 }
14308 #[repr(C)]
14309 #[cfg_attr(feature = "debug", derive(Debug))]
14310 #[derive(Copy, Clone, Default)]
14311 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindVertexBufferIndirectCommandNV.html>"]
14312 pub struct BindVertexBufferIndirectCommandNV {
14313     pub buffer_address: DeviceAddress,
14314     pub size: u32,
14315     pub stride: u32,
14316 }
14317 impl BindVertexBufferIndirectCommandNV {
builder<'a>() -> BindVertexBufferIndirectCommandNVBuilder<'a>14318     pub fn builder<'a>() -> BindVertexBufferIndirectCommandNVBuilder<'a> {
14319         BindVertexBufferIndirectCommandNVBuilder {
14320             inner: Self::default(),
14321             marker: ::std::marker::PhantomData,
14322         }
14323     }
14324 }
14325 #[repr(transparent)]
14326 pub struct BindVertexBufferIndirectCommandNVBuilder<'a> {
14327     inner: BindVertexBufferIndirectCommandNV,
14328     marker: ::std::marker::PhantomData<&'a ()>,
14329 }
14330 impl<'a> ::std::ops::Deref for BindVertexBufferIndirectCommandNVBuilder<'a> {
14331     type Target = BindVertexBufferIndirectCommandNV;
deref(&self) -> &Self::Target14332     fn deref(&self) -> &Self::Target {
14333         &self.inner
14334     }
14335 }
14336 impl<'a> ::std::ops::DerefMut for BindVertexBufferIndirectCommandNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target14337     fn deref_mut(&mut self) -> &mut Self::Target {
14338         &mut self.inner
14339     }
14340 }
14341 impl<'a> BindVertexBufferIndirectCommandNVBuilder<'a> {
14342     #[inline]
buffer_address(mut self, buffer_address: DeviceAddress) -> Self14343     pub fn buffer_address(mut self, buffer_address: DeviceAddress) -> Self {
14344         self.inner.buffer_address = buffer_address;
14345         self
14346     }
14347     #[inline]
size(mut self, size: u32) -> Self14348     pub fn size(mut self, size: u32) -> Self {
14349         self.inner.size = size;
14350         self
14351     }
14352     #[inline]
stride(mut self, stride: u32) -> Self14353     pub fn stride(mut self, stride: u32) -> Self {
14354         self.inner.stride = stride;
14355         self
14356     }
14357     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14358     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14359     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BindVertexBufferIndirectCommandNV14360     pub fn build(self) -> BindVertexBufferIndirectCommandNV {
14361         self.inner
14362     }
14363 }
14364 #[repr(C)]
14365 #[cfg_attr(feature = "debug", derive(Debug))]
14366 #[derive(Copy, Clone, Default)]
14367 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSetStateFlagsIndirectCommandNV.html>"]
14368 pub struct SetStateFlagsIndirectCommandNV {
14369     pub data: u32,
14370 }
14371 impl SetStateFlagsIndirectCommandNV {
builder<'a>() -> SetStateFlagsIndirectCommandNVBuilder<'a>14372     pub fn builder<'a>() -> SetStateFlagsIndirectCommandNVBuilder<'a> {
14373         SetStateFlagsIndirectCommandNVBuilder {
14374             inner: Self::default(),
14375             marker: ::std::marker::PhantomData,
14376         }
14377     }
14378 }
14379 #[repr(transparent)]
14380 pub struct SetStateFlagsIndirectCommandNVBuilder<'a> {
14381     inner: SetStateFlagsIndirectCommandNV,
14382     marker: ::std::marker::PhantomData<&'a ()>,
14383 }
14384 impl<'a> ::std::ops::Deref for SetStateFlagsIndirectCommandNVBuilder<'a> {
14385     type Target = SetStateFlagsIndirectCommandNV;
deref(&self) -> &Self::Target14386     fn deref(&self) -> &Self::Target {
14387         &self.inner
14388     }
14389 }
14390 impl<'a> ::std::ops::DerefMut for SetStateFlagsIndirectCommandNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target14391     fn deref_mut(&mut self) -> &mut Self::Target {
14392         &mut self.inner
14393     }
14394 }
14395 impl<'a> SetStateFlagsIndirectCommandNVBuilder<'a> {
14396     #[inline]
data(mut self, data: u32) -> Self14397     pub fn data(mut self, data: u32) -> Self {
14398         self.inner.data = data;
14399         self
14400     }
14401     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14402     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14403     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SetStateFlagsIndirectCommandNV14404     pub fn build(self) -> SetStateFlagsIndirectCommandNV {
14405         self.inner
14406     }
14407 }
14408 #[repr(C)]
14409 #[cfg_attr(feature = "debug", derive(Debug))]
14410 #[derive(Copy, Clone, Default)]
14411 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIndirectCommandsStreamNV.html>"]
14412 pub struct IndirectCommandsStreamNV {
14413     pub buffer: Buffer,
14414     pub offset: DeviceSize,
14415 }
14416 impl IndirectCommandsStreamNV {
builder<'a>() -> IndirectCommandsStreamNVBuilder<'a>14417     pub fn builder<'a>() -> IndirectCommandsStreamNVBuilder<'a> {
14418         IndirectCommandsStreamNVBuilder {
14419             inner: Self::default(),
14420             marker: ::std::marker::PhantomData,
14421         }
14422     }
14423 }
14424 #[repr(transparent)]
14425 pub struct IndirectCommandsStreamNVBuilder<'a> {
14426     inner: IndirectCommandsStreamNV,
14427     marker: ::std::marker::PhantomData<&'a ()>,
14428 }
14429 impl<'a> ::std::ops::Deref for IndirectCommandsStreamNVBuilder<'a> {
14430     type Target = IndirectCommandsStreamNV;
deref(&self) -> &Self::Target14431     fn deref(&self) -> &Self::Target {
14432         &self.inner
14433     }
14434 }
14435 impl<'a> ::std::ops::DerefMut for IndirectCommandsStreamNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target14436     fn deref_mut(&mut self) -> &mut Self::Target {
14437         &mut self.inner
14438     }
14439 }
14440 impl<'a> IndirectCommandsStreamNVBuilder<'a> {
14441     #[inline]
buffer(mut self, buffer: Buffer) -> Self14442     pub fn buffer(mut self, buffer: Buffer) -> Self {
14443         self.inner.buffer = buffer;
14444         self
14445     }
14446     #[inline]
offset(mut self, offset: DeviceSize) -> Self14447     pub fn offset(mut self, offset: DeviceSize) -> Self {
14448         self.inner.offset = offset;
14449         self
14450     }
14451     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14452     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14453     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> IndirectCommandsStreamNV14454     pub fn build(self) -> IndirectCommandsStreamNV {
14455         self.inner
14456     }
14457 }
14458 #[repr(C)]
14459 #[cfg_attr(feature = "debug", derive(Debug))]
14460 #[derive(Copy, Clone)]
14461 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIndirectCommandsLayoutTokenNV.html>"]
14462 pub struct IndirectCommandsLayoutTokenNV {
14463     pub s_type: StructureType,
14464     pub p_next: *const c_void,
14465     pub token_type: IndirectCommandsTokenTypeNV,
14466     pub stream: u32,
14467     pub offset: u32,
14468     pub vertex_binding_unit: u32,
14469     pub vertex_dynamic_stride: Bool32,
14470     pub pushconstant_pipeline_layout: PipelineLayout,
14471     pub pushconstant_shader_stage_flags: ShaderStageFlags,
14472     pub pushconstant_offset: u32,
14473     pub pushconstant_size: u32,
14474     pub indirect_state_flags: IndirectStateFlagsNV,
14475     pub index_type_count: u32,
14476     pub p_index_types: *const IndexType,
14477     pub p_index_type_values: *const u32,
14478 }
14479 impl ::std::default::Default for IndirectCommandsLayoutTokenNV {
14480     #[inline]
default() -> Self14481     fn default() -> Self {
14482         Self {
14483             s_type: Self::STRUCTURE_TYPE,
14484             p_next: ::std::ptr::null(),
14485             token_type: IndirectCommandsTokenTypeNV::default(),
14486             stream: u32::default(),
14487             offset: u32::default(),
14488             vertex_binding_unit: u32::default(),
14489             vertex_dynamic_stride: Bool32::default(),
14490             pushconstant_pipeline_layout: PipelineLayout::default(),
14491             pushconstant_shader_stage_flags: ShaderStageFlags::default(),
14492             pushconstant_offset: u32::default(),
14493             pushconstant_size: u32::default(),
14494             indirect_state_flags: IndirectStateFlagsNV::default(),
14495             index_type_count: u32::default(),
14496             p_index_types: ::std::ptr::null(),
14497             p_index_type_values: ::std::ptr::null(),
14498         }
14499     }
14500 }
14501 unsafe impl TaggedStructure for IndirectCommandsLayoutTokenNV {
14502     const STRUCTURE_TYPE: StructureType = StructureType::INDIRECT_COMMANDS_LAYOUT_TOKEN_NV;
14503 }
14504 impl IndirectCommandsLayoutTokenNV {
builder<'a>() -> IndirectCommandsLayoutTokenNVBuilder<'a>14505     pub fn builder<'a>() -> IndirectCommandsLayoutTokenNVBuilder<'a> {
14506         IndirectCommandsLayoutTokenNVBuilder {
14507             inner: Self::default(),
14508             marker: ::std::marker::PhantomData,
14509         }
14510     }
14511 }
14512 #[repr(transparent)]
14513 pub struct IndirectCommandsLayoutTokenNVBuilder<'a> {
14514     inner: IndirectCommandsLayoutTokenNV,
14515     marker: ::std::marker::PhantomData<&'a ()>,
14516 }
14517 impl<'a> ::std::ops::Deref for IndirectCommandsLayoutTokenNVBuilder<'a> {
14518     type Target = IndirectCommandsLayoutTokenNV;
deref(&self) -> &Self::Target14519     fn deref(&self) -> &Self::Target {
14520         &self.inner
14521     }
14522 }
14523 impl<'a> ::std::ops::DerefMut for IndirectCommandsLayoutTokenNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target14524     fn deref_mut(&mut self) -> &mut Self::Target {
14525         &mut self.inner
14526     }
14527 }
14528 impl<'a> IndirectCommandsLayoutTokenNVBuilder<'a> {
14529     #[inline]
token_type(mut self, token_type: IndirectCommandsTokenTypeNV) -> Self14530     pub fn token_type(mut self, token_type: IndirectCommandsTokenTypeNV) -> Self {
14531         self.inner.token_type = token_type;
14532         self
14533     }
14534     #[inline]
stream(mut self, stream: u32) -> Self14535     pub fn stream(mut self, stream: u32) -> Self {
14536         self.inner.stream = stream;
14537         self
14538     }
14539     #[inline]
offset(mut self, offset: u32) -> Self14540     pub fn offset(mut self, offset: u32) -> Self {
14541         self.inner.offset = offset;
14542         self
14543     }
14544     #[inline]
vertex_binding_unit(mut self, vertex_binding_unit: u32) -> Self14545     pub fn vertex_binding_unit(mut self, vertex_binding_unit: u32) -> Self {
14546         self.inner.vertex_binding_unit = vertex_binding_unit;
14547         self
14548     }
14549     #[inline]
vertex_dynamic_stride(mut self, vertex_dynamic_stride: bool) -> Self14550     pub fn vertex_dynamic_stride(mut self, vertex_dynamic_stride: bool) -> Self {
14551         self.inner.vertex_dynamic_stride = vertex_dynamic_stride.into();
14552         self
14553     }
14554     #[inline]
pushconstant_pipeline_layout( mut self, pushconstant_pipeline_layout: PipelineLayout, ) -> Self14555     pub fn pushconstant_pipeline_layout(
14556         mut self,
14557         pushconstant_pipeline_layout: PipelineLayout,
14558     ) -> Self {
14559         self.inner.pushconstant_pipeline_layout = pushconstant_pipeline_layout;
14560         self
14561     }
14562     #[inline]
pushconstant_shader_stage_flags( mut self, pushconstant_shader_stage_flags: ShaderStageFlags, ) -> Self14563     pub fn pushconstant_shader_stage_flags(
14564         mut self,
14565         pushconstant_shader_stage_flags: ShaderStageFlags,
14566     ) -> Self {
14567         self.inner.pushconstant_shader_stage_flags = pushconstant_shader_stage_flags;
14568         self
14569     }
14570     #[inline]
pushconstant_offset(mut self, pushconstant_offset: u32) -> Self14571     pub fn pushconstant_offset(mut self, pushconstant_offset: u32) -> Self {
14572         self.inner.pushconstant_offset = pushconstant_offset;
14573         self
14574     }
14575     #[inline]
pushconstant_size(mut self, pushconstant_size: u32) -> Self14576     pub fn pushconstant_size(mut self, pushconstant_size: u32) -> Self {
14577         self.inner.pushconstant_size = pushconstant_size;
14578         self
14579     }
14580     #[inline]
indirect_state_flags(mut self, indirect_state_flags: IndirectStateFlagsNV) -> Self14581     pub fn indirect_state_flags(mut self, indirect_state_flags: IndirectStateFlagsNV) -> Self {
14582         self.inner.indirect_state_flags = indirect_state_flags;
14583         self
14584     }
14585     #[inline]
index_types(mut self, index_types: &'a [IndexType]) -> Self14586     pub fn index_types(mut self, index_types: &'a [IndexType]) -> Self {
14587         self.inner.index_type_count = index_types.len() as _;
14588         self.inner.p_index_types = index_types.as_ptr();
14589         self
14590     }
14591     #[inline]
index_type_values(mut self, index_type_values: &'a [u32]) -> Self14592     pub fn index_type_values(mut self, index_type_values: &'a [u32]) -> Self {
14593         self.inner.index_type_count = index_type_values.len() as _;
14594         self.inner.p_index_type_values = index_type_values.as_ptr();
14595         self
14596     }
14597     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14598     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14599     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> IndirectCommandsLayoutTokenNV14600     pub fn build(self) -> IndirectCommandsLayoutTokenNV {
14601         self.inner
14602     }
14603 }
14604 #[repr(C)]
14605 #[cfg_attr(feature = "debug", derive(Debug))]
14606 #[derive(Copy, Clone)]
14607 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIndirectCommandsLayoutCreateInfoNV.html>"]
14608 pub struct IndirectCommandsLayoutCreateInfoNV {
14609     pub s_type: StructureType,
14610     pub p_next: *const c_void,
14611     pub flags: IndirectCommandsLayoutUsageFlagsNV,
14612     pub pipeline_bind_point: PipelineBindPoint,
14613     pub token_count: u32,
14614     pub p_tokens: *const IndirectCommandsLayoutTokenNV,
14615     pub stream_count: u32,
14616     pub p_stream_strides: *const u32,
14617 }
14618 impl ::std::default::Default for IndirectCommandsLayoutCreateInfoNV {
14619     #[inline]
default() -> Self14620     fn default() -> Self {
14621         Self {
14622             s_type: Self::STRUCTURE_TYPE,
14623             p_next: ::std::ptr::null(),
14624             flags: IndirectCommandsLayoutUsageFlagsNV::default(),
14625             pipeline_bind_point: PipelineBindPoint::default(),
14626             token_count: u32::default(),
14627             p_tokens: ::std::ptr::null(),
14628             stream_count: u32::default(),
14629             p_stream_strides: ::std::ptr::null(),
14630         }
14631     }
14632 }
14633 unsafe impl TaggedStructure for IndirectCommandsLayoutCreateInfoNV {
14634     const STRUCTURE_TYPE: StructureType = StructureType::INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV;
14635 }
14636 impl IndirectCommandsLayoutCreateInfoNV {
builder<'a>() -> IndirectCommandsLayoutCreateInfoNVBuilder<'a>14637     pub fn builder<'a>() -> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
14638         IndirectCommandsLayoutCreateInfoNVBuilder {
14639             inner: Self::default(),
14640             marker: ::std::marker::PhantomData,
14641         }
14642     }
14643 }
14644 #[repr(transparent)]
14645 pub struct IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
14646     inner: IndirectCommandsLayoutCreateInfoNV,
14647     marker: ::std::marker::PhantomData<&'a ()>,
14648 }
14649 impl<'a> ::std::ops::Deref for IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
14650     type Target = IndirectCommandsLayoutCreateInfoNV;
deref(&self) -> &Self::Target14651     fn deref(&self) -> &Self::Target {
14652         &self.inner
14653     }
14654 }
14655 impl<'a> ::std::ops::DerefMut for IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target14656     fn deref_mut(&mut self) -> &mut Self::Target {
14657         &mut self.inner
14658     }
14659 }
14660 impl<'a> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
14661     #[inline]
flags(mut self, flags: IndirectCommandsLayoutUsageFlagsNV) -> Self14662     pub fn flags(mut self, flags: IndirectCommandsLayoutUsageFlagsNV) -> Self {
14663         self.inner.flags = flags;
14664         self
14665     }
14666     #[inline]
pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self14667     pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self {
14668         self.inner.pipeline_bind_point = pipeline_bind_point;
14669         self
14670     }
14671     #[inline]
tokens(mut self, tokens: &'a [IndirectCommandsLayoutTokenNV]) -> Self14672     pub fn tokens(mut self, tokens: &'a [IndirectCommandsLayoutTokenNV]) -> Self {
14673         self.inner.token_count = tokens.len() as _;
14674         self.inner.p_tokens = tokens.as_ptr();
14675         self
14676     }
14677     #[inline]
stream_strides(mut self, stream_strides: &'a [u32]) -> Self14678     pub fn stream_strides(mut self, stream_strides: &'a [u32]) -> Self {
14679         self.inner.stream_count = stream_strides.len() as _;
14680         self.inner.p_stream_strides = stream_strides.as_ptr();
14681         self
14682     }
14683     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14684     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14685     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> IndirectCommandsLayoutCreateInfoNV14686     pub fn build(self) -> IndirectCommandsLayoutCreateInfoNV {
14687         self.inner
14688     }
14689 }
14690 #[repr(C)]
14691 #[cfg_attr(feature = "debug", derive(Debug))]
14692 #[derive(Copy, Clone)]
14693 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeneratedCommandsInfoNV.html>"]
14694 pub struct GeneratedCommandsInfoNV {
14695     pub s_type: StructureType,
14696     pub p_next: *const c_void,
14697     pub pipeline_bind_point: PipelineBindPoint,
14698     pub pipeline: Pipeline,
14699     pub indirect_commands_layout: IndirectCommandsLayoutNV,
14700     pub stream_count: u32,
14701     pub p_streams: *const IndirectCommandsStreamNV,
14702     pub sequences_count: u32,
14703     pub preprocess_buffer: Buffer,
14704     pub preprocess_offset: DeviceSize,
14705     pub preprocess_size: DeviceSize,
14706     pub sequences_count_buffer: Buffer,
14707     pub sequences_count_offset: DeviceSize,
14708     pub sequences_index_buffer: Buffer,
14709     pub sequences_index_offset: DeviceSize,
14710 }
14711 impl ::std::default::Default for GeneratedCommandsInfoNV {
14712     #[inline]
default() -> Self14713     fn default() -> Self {
14714         Self {
14715             s_type: Self::STRUCTURE_TYPE,
14716             p_next: ::std::ptr::null(),
14717             pipeline_bind_point: PipelineBindPoint::default(),
14718             pipeline: Pipeline::default(),
14719             indirect_commands_layout: IndirectCommandsLayoutNV::default(),
14720             stream_count: u32::default(),
14721             p_streams: ::std::ptr::null(),
14722             sequences_count: u32::default(),
14723             preprocess_buffer: Buffer::default(),
14724             preprocess_offset: DeviceSize::default(),
14725             preprocess_size: DeviceSize::default(),
14726             sequences_count_buffer: Buffer::default(),
14727             sequences_count_offset: DeviceSize::default(),
14728             sequences_index_buffer: Buffer::default(),
14729             sequences_index_offset: DeviceSize::default(),
14730         }
14731     }
14732 }
14733 unsafe impl TaggedStructure for GeneratedCommandsInfoNV {
14734     const STRUCTURE_TYPE: StructureType = StructureType::GENERATED_COMMANDS_INFO_NV;
14735 }
14736 impl GeneratedCommandsInfoNV {
builder<'a>() -> GeneratedCommandsInfoNVBuilder<'a>14737     pub fn builder<'a>() -> GeneratedCommandsInfoNVBuilder<'a> {
14738         GeneratedCommandsInfoNVBuilder {
14739             inner: Self::default(),
14740             marker: ::std::marker::PhantomData,
14741         }
14742     }
14743 }
14744 #[repr(transparent)]
14745 pub struct GeneratedCommandsInfoNVBuilder<'a> {
14746     inner: GeneratedCommandsInfoNV,
14747     marker: ::std::marker::PhantomData<&'a ()>,
14748 }
14749 impl<'a> ::std::ops::Deref for GeneratedCommandsInfoNVBuilder<'a> {
14750     type Target = GeneratedCommandsInfoNV;
deref(&self) -> &Self::Target14751     fn deref(&self) -> &Self::Target {
14752         &self.inner
14753     }
14754 }
14755 impl<'a> ::std::ops::DerefMut for GeneratedCommandsInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target14756     fn deref_mut(&mut self) -> &mut Self::Target {
14757         &mut self.inner
14758     }
14759 }
14760 impl<'a> GeneratedCommandsInfoNVBuilder<'a> {
14761     #[inline]
pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self14762     pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self {
14763         self.inner.pipeline_bind_point = pipeline_bind_point;
14764         self
14765     }
14766     #[inline]
pipeline(mut self, pipeline: Pipeline) -> Self14767     pub fn pipeline(mut self, pipeline: Pipeline) -> Self {
14768         self.inner.pipeline = pipeline;
14769         self
14770     }
14771     #[inline]
indirect_commands_layout( mut self, indirect_commands_layout: IndirectCommandsLayoutNV, ) -> Self14772     pub fn indirect_commands_layout(
14773         mut self,
14774         indirect_commands_layout: IndirectCommandsLayoutNV,
14775     ) -> Self {
14776         self.inner.indirect_commands_layout = indirect_commands_layout;
14777         self
14778     }
14779     #[inline]
streams(mut self, streams: &'a [IndirectCommandsStreamNV]) -> Self14780     pub fn streams(mut self, streams: &'a [IndirectCommandsStreamNV]) -> Self {
14781         self.inner.stream_count = streams.len() as _;
14782         self.inner.p_streams = streams.as_ptr();
14783         self
14784     }
14785     #[inline]
sequences_count(mut self, sequences_count: u32) -> Self14786     pub fn sequences_count(mut self, sequences_count: u32) -> Self {
14787         self.inner.sequences_count = sequences_count;
14788         self
14789     }
14790     #[inline]
preprocess_buffer(mut self, preprocess_buffer: Buffer) -> Self14791     pub fn preprocess_buffer(mut self, preprocess_buffer: Buffer) -> Self {
14792         self.inner.preprocess_buffer = preprocess_buffer;
14793         self
14794     }
14795     #[inline]
preprocess_offset(mut self, preprocess_offset: DeviceSize) -> Self14796     pub fn preprocess_offset(mut self, preprocess_offset: DeviceSize) -> Self {
14797         self.inner.preprocess_offset = preprocess_offset;
14798         self
14799     }
14800     #[inline]
preprocess_size(mut self, preprocess_size: DeviceSize) -> Self14801     pub fn preprocess_size(mut self, preprocess_size: DeviceSize) -> Self {
14802         self.inner.preprocess_size = preprocess_size;
14803         self
14804     }
14805     #[inline]
sequences_count_buffer(mut self, sequences_count_buffer: Buffer) -> Self14806     pub fn sequences_count_buffer(mut self, sequences_count_buffer: Buffer) -> Self {
14807         self.inner.sequences_count_buffer = sequences_count_buffer;
14808         self
14809     }
14810     #[inline]
sequences_count_offset(mut self, sequences_count_offset: DeviceSize) -> Self14811     pub fn sequences_count_offset(mut self, sequences_count_offset: DeviceSize) -> Self {
14812         self.inner.sequences_count_offset = sequences_count_offset;
14813         self
14814     }
14815     #[inline]
sequences_index_buffer(mut self, sequences_index_buffer: Buffer) -> Self14816     pub fn sequences_index_buffer(mut self, sequences_index_buffer: Buffer) -> Self {
14817         self.inner.sequences_index_buffer = sequences_index_buffer;
14818         self
14819     }
14820     #[inline]
sequences_index_offset(mut self, sequences_index_offset: DeviceSize) -> Self14821     pub fn sequences_index_offset(mut self, sequences_index_offset: DeviceSize) -> Self {
14822         self.inner.sequences_index_offset = sequences_index_offset;
14823         self
14824     }
14825     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14826     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14827     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> GeneratedCommandsInfoNV14828     pub fn build(self) -> GeneratedCommandsInfoNV {
14829         self.inner
14830     }
14831 }
14832 #[repr(C)]
14833 #[cfg_attr(feature = "debug", derive(Debug))]
14834 #[derive(Copy, Clone)]
14835 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeneratedCommandsMemoryRequirementsInfoNV.html>"]
14836 pub struct GeneratedCommandsMemoryRequirementsInfoNV {
14837     pub s_type: StructureType,
14838     pub p_next: *const c_void,
14839     pub pipeline_bind_point: PipelineBindPoint,
14840     pub pipeline: Pipeline,
14841     pub indirect_commands_layout: IndirectCommandsLayoutNV,
14842     pub max_sequences_count: u32,
14843 }
14844 impl ::std::default::Default for GeneratedCommandsMemoryRequirementsInfoNV {
14845     #[inline]
default() -> Self14846     fn default() -> Self {
14847         Self {
14848             s_type: Self::STRUCTURE_TYPE,
14849             p_next: ::std::ptr::null(),
14850             pipeline_bind_point: PipelineBindPoint::default(),
14851             pipeline: Pipeline::default(),
14852             indirect_commands_layout: IndirectCommandsLayoutNV::default(),
14853             max_sequences_count: u32::default(),
14854         }
14855     }
14856 }
14857 unsafe impl TaggedStructure for GeneratedCommandsMemoryRequirementsInfoNV {
14858     const STRUCTURE_TYPE: StructureType =
14859         StructureType::GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV;
14860 }
14861 impl GeneratedCommandsMemoryRequirementsInfoNV {
builder<'a>() -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a>14862     pub fn builder<'a>() -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
14863         GeneratedCommandsMemoryRequirementsInfoNVBuilder {
14864             inner: Self::default(),
14865             marker: ::std::marker::PhantomData,
14866         }
14867     }
14868 }
14869 #[repr(transparent)]
14870 pub struct GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
14871     inner: GeneratedCommandsMemoryRequirementsInfoNV,
14872     marker: ::std::marker::PhantomData<&'a ()>,
14873 }
14874 impl<'a> ::std::ops::Deref for GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
14875     type Target = GeneratedCommandsMemoryRequirementsInfoNV;
deref(&self) -> &Self::Target14876     fn deref(&self) -> &Self::Target {
14877         &self.inner
14878     }
14879 }
14880 impl<'a> ::std::ops::DerefMut for GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target14881     fn deref_mut(&mut self) -> &mut Self::Target {
14882         &mut self.inner
14883     }
14884 }
14885 impl<'a> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
14886     #[inline]
pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self14887     pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self {
14888         self.inner.pipeline_bind_point = pipeline_bind_point;
14889         self
14890     }
14891     #[inline]
pipeline(mut self, pipeline: Pipeline) -> Self14892     pub fn pipeline(mut self, pipeline: Pipeline) -> Self {
14893         self.inner.pipeline = pipeline;
14894         self
14895     }
14896     #[inline]
indirect_commands_layout( mut self, indirect_commands_layout: IndirectCommandsLayoutNV, ) -> Self14897     pub fn indirect_commands_layout(
14898         mut self,
14899         indirect_commands_layout: IndirectCommandsLayoutNV,
14900     ) -> Self {
14901         self.inner.indirect_commands_layout = indirect_commands_layout;
14902         self
14903     }
14904     #[inline]
max_sequences_count(mut self, max_sequences_count: u32) -> Self14905     pub fn max_sequences_count(mut self, max_sequences_count: u32) -> Self {
14906         self.inner.max_sequences_count = max_sequences_count;
14907         self
14908     }
14909     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14910     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14911     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> GeneratedCommandsMemoryRequirementsInfoNV14912     pub fn build(self) -> GeneratedCommandsMemoryRequirementsInfoNV {
14913         self.inner
14914     }
14915 }
14916 #[repr(C)]
14917 #[cfg_attr(feature = "debug", derive(Debug))]
14918 #[derive(Copy, Clone)]
14919 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFeatures2.html>"]
14920 pub struct PhysicalDeviceFeatures2 {
14921     pub s_type: StructureType,
14922     pub p_next: *mut c_void,
14923     pub features: PhysicalDeviceFeatures,
14924 }
14925 impl ::std::default::Default for PhysicalDeviceFeatures2 {
14926     #[inline]
default() -> Self14927     fn default() -> Self {
14928         Self {
14929             s_type: Self::STRUCTURE_TYPE,
14930             p_next: ::std::ptr::null_mut(),
14931             features: PhysicalDeviceFeatures::default(),
14932         }
14933     }
14934 }
14935 unsafe impl TaggedStructure for PhysicalDeviceFeatures2 {
14936     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_FEATURES_2;
14937 }
14938 impl PhysicalDeviceFeatures2 {
builder<'a>() -> PhysicalDeviceFeatures2Builder<'a>14939     pub fn builder<'a>() -> PhysicalDeviceFeatures2Builder<'a> {
14940         PhysicalDeviceFeatures2Builder {
14941             inner: Self::default(),
14942             marker: ::std::marker::PhantomData,
14943         }
14944     }
14945 }
14946 #[repr(transparent)]
14947 pub struct PhysicalDeviceFeatures2Builder<'a> {
14948     inner: PhysicalDeviceFeatures2,
14949     marker: ::std::marker::PhantomData<&'a ()>,
14950 }
14951 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFeatures2Builder<'_> {}
14952 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFeatures2 {}
14953 pub unsafe trait ExtendsPhysicalDeviceFeatures2 {}
14954 impl<'a> ::std::ops::Deref for PhysicalDeviceFeatures2Builder<'a> {
14955     type Target = PhysicalDeviceFeatures2;
deref(&self) -> &Self::Target14956     fn deref(&self) -> &Self::Target {
14957         &self.inner
14958     }
14959 }
14960 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFeatures2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target14961     fn deref_mut(&mut self) -> &mut Self::Target {
14962         &mut self.inner
14963     }
14964 }
14965 impl<'a> PhysicalDeviceFeatures2Builder<'a> {
14966     #[inline]
features(mut self, features: PhysicalDeviceFeatures) -> Self14967     pub fn features(mut self, features: PhysicalDeviceFeatures) -> Self {
14968         self.inner.features = features;
14969         self
14970     }
14971     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
14972     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
14973     #[doc = r" valid extension structs can be pushed into the chain."]
14974     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
14975     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPhysicalDeviceFeatures2>(mut self, next: &'a mut T) -> Self14976     pub fn push_next<T: ExtendsPhysicalDeviceFeatures2>(mut self, next: &'a mut T) -> Self {
14977         unsafe {
14978             let next_ptr = <*mut T>::cast(next);
14979             let last_next = ptr_chain_iter(next).last().unwrap();
14980             (*last_next).p_next = self.inner.p_next as _;
14981             self.inner.p_next = next_ptr;
14982         }
14983         self
14984     }
14985     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14986     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14987     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFeatures214988     pub fn build(self) -> PhysicalDeviceFeatures2 {
14989         self.inner
14990     }
14991 }
14992 #[repr(C)]
14993 #[cfg_attr(feature = "debug", derive(Debug))]
14994 #[derive(Copy, Clone)]
14995 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProperties2.html>"]
14996 pub struct PhysicalDeviceProperties2 {
14997     pub s_type: StructureType,
14998     pub p_next: *mut c_void,
14999     pub properties: PhysicalDeviceProperties,
15000 }
15001 impl ::std::default::Default for PhysicalDeviceProperties2 {
15002     #[inline]
default() -> Self15003     fn default() -> Self {
15004         Self {
15005             s_type: Self::STRUCTURE_TYPE,
15006             p_next: ::std::ptr::null_mut(),
15007             properties: PhysicalDeviceProperties::default(),
15008         }
15009     }
15010 }
15011 unsafe impl TaggedStructure for PhysicalDeviceProperties2 {
15012     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_PROPERTIES_2;
15013 }
15014 impl PhysicalDeviceProperties2 {
builder<'a>() -> PhysicalDeviceProperties2Builder<'a>15015     pub fn builder<'a>() -> PhysicalDeviceProperties2Builder<'a> {
15016         PhysicalDeviceProperties2Builder {
15017             inner: Self::default(),
15018             marker: ::std::marker::PhantomData,
15019         }
15020     }
15021 }
15022 #[repr(transparent)]
15023 pub struct PhysicalDeviceProperties2Builder<'a> {
15024     inner: PhysicalDeviceProperties2,
15025     marker: ::std::marker::PhantomData<&'a ()>,
15026 }
15027 pub unsafe trait ExtendsPhysicalDeviceProperties2 {}
15028 impl<'a> ::std::ops::Deref for PhysicalDeviceProperties2Builder<'a> {
15029     type Target = PhysicalDeviceProperties2;
deref(&self) -> &Self::Target15030     fn deref(&self) -> &Self::Target {
15031         &self.inner
15032     }
15033 }
15034 impl<'a> ::std::ops::DerefMut for PhysicalDeviceProperties2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target15035     fn deref_mut(&mut self) -> &mut Self::Target {
15036         &mut self.inner
15037     }
15038 }
15039 impl<'a> PhysicalDeviceProperties2Builder<'a> {
15040     #[inline]
properties(mut self, properties: PhysicalDeviceProperties) -> Self15041     pub fn properties(mut self, properties: PhysicalDeviceProperties) -> Self {
15042         self.inner.properties = properties;
15043         self
15044     }
15045     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
15046     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
15047     #[doc = r" valid extension structs can be pushed into the chain."]
15048     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
15049     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPhysicalDeviceProperties2>(mut self, next: &'a mut T) -> Self15050     pub fn push_next<T: ExtendsPhysicalDeviceProperties2>(mut self, next: &'a mut T) -> Self {
15051         unsafe {
15052             let next_ptr = <*mut T>::cast(next);
15053             let last_next = ptr_chain_iter(next).last().unwrap();
15054             (*last_next).p_next = self.inner.p_next as _;
15055             self.inner.p_next = next_ptr;
15056         }
15057         self
15058     }
15059     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15060     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15061     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceProperties215062     pub fn build(self) -> PhysicalDeviceProperties2 {
15063         self.inner
15064     }
15065 }
15066 #[repr(C)]
15067 #[cfg_attr(feature = "debug", derive(Debug))]
15068 #[derive(Copy, Clone)]
15069 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFormatProperties2.html>"]
15070 pub struct FormatProperties2 {
15071     pub s_type: StructureType,
15072     pub p_next: *mut c_void,
15073     pub format_properties: FormatProperties,
15074 }
15075 impl ::std::default::Default for FormatProperties2 {
15076     #[inline]
default() -> Self15077     fn default() -> Self {
15078         Self {
15079             s_type: Self::STRUCTURE_TYPE,
15080             p_next: ::std::ptr::null_mut(),
15081             format_properties: FormatProperties::default(),
15082         }
15083     }
15084 }
15085 unsafe impl TaggedStructure for FormatProperties2 {
15086     const STRUCTURE_TYPE: StructureType = StructureType::FORMAT_PROPERTIES_2;
15087 }
15088 impl FormatProperties2 {
builder<'a>() -> FormatProperties2Builder<'a>15089     pub fn builder<'a>() -> FormatProperties2Builder<'a> {
15090         FormatProperties2Builder {
15091             inner: Self::default(),
15092             marker: ::std::marker::PhantomData,
15093         }
15094     }
15095 }
15096 #[repr(transparent)]
15097 pub struct FormatProperties2Builder<'a> {
15098     inner: FormatProperties2,
15099     marker: ::std::marker::PhantomData<&'a ()>,
15100 }
15101 pub unsafe trait ExtendsFormatProperties2 {}
15102 impl<'a> ::std::ops::Deref for FormatProperties2Builder<'a> {
15103     type Target = FormatProperties2;
deref(&self) -> &Self::Target15104     fn deref(&self) -> &Self::Target {
15105         &self.inner
15106     }
15107 }
15108 impl<'a> ::std::ops::DerefMut for FormatProperties2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target15109     fn deref_mut(&mut self) -> &mut Self::Target {
15110         &mut self.inner
15111     }
15112 }
15113 impl<'a> FormatProperties2Builder<'a> {
15114     #[inline]
format_properties(mut self, format_properties: FormatProperties) -> Self15115     pub fn format_properties(mut self, format_properties: FormatProperties) -> Self {
15116         self.inner.format_properties = format_properties;
15117         self
15118     }
15119     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
15120     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
15121     #[doc = r" valid extension structs can be pushed into the chain."]
15122     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
15123     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsFormatProperties2>(mut self, next: &'a mut T) -> Self15124     pub fn push_next<T: ExtendsFormatProperties2>(mut self, next: &'a mut T) -> Self {
15125         unsafe {
15126             let next_ptr = <*mut T>::cast(next);
15127             let last_next = ptr_chain_iter(next).last().unwrap();
15128             (*last_next).p_next = self.inner.p_next as _;
15129             self.inner.p_next = next_ptr;
15130         }
15131         self
15132     }
15133     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15134     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15135     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> FormatProperties215136     pub fn build(self) -> FormatProperties2 {
15137         self.inner
15138     }
15139 }
15140 #[repr(C)]
15141 #[cfg_attr(feature = "debug", derive(Debug))]
15142 #[derive(Copy, Clone)]
15143 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageFormatProperties2.html>"]
15144 pub struct ImageFormatProperties2 {
15145     pub s_type: StructureType,
15146     pub p_next: *mut c_void,
15147     pub image_format_properties: ImageFormatProperties,
15148 }
15149 impl ::std::default::Default for ImageFormatProperties2 {
15150     #[inline]
default() -> Self15151     fn default() -> Self {
15152         Self {
15153             s_type: Self::STRUCTURE_TYPE,
15154             p_next: ::std::ptr::null_mut(),
15155             image_format_properties: ImageFormatProperties::default(),
15156         }
15157     }
15158 }
15159 unsafe impl TaggedStructure for ImageFormatProperties2 {
15160     const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_FORMAT_PROPERTIES_2;
15161 }
15162 impl ImageFormatProperties2 {
builder<'a>() -> ImageFormatProperties2Builder<'a>15163     pub fn builder<'a>() -> ImageFormatProperties2Builder<'a> {
15164         ImageFormatProperties2Builder {
15165             inner: Self::default(),
15166             marker: ::std::marker::PhantomData,
15167         }
15168     }
15169 }
15170 #[repr(transparent)]
15171 pub struct ImageFormatProperties2Builder<'a> {
15172     inner: ImageFormatProperties2,
15173     marker: ::std::marker::PhantomData<&'a ()>,
15174 }
15175 pub unsafe trait ExtendsImageFormatProperties2 {}
15176 impl<'a> ::std::ops::Deref for ImageFormatProperties2Builder<'a> {
15177     type Target = ImageFormatProperties2;
deref(&self) -> &Self::Target15178     fn deref(&self) -> &Self::Target {
15179         &self.inner
15180     }
15181 }
15182 impl<'a> ::std::ops::DerefMut for ImageFormatProperties2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target15183     fn deref_mut(&mut self) -> &mut Self::Target {
15184         &mut self.inner
15185     }
15186 }
15187 impl<'a> ImageFormatProperties2Builder<'a> {
15188     #[inline]
image_format_properties( mut self, image_format_properties: ImageFormatProperties, ) -> Self15189     pub fn image_format_properties(
15190         mut self,
15191         image_format_properties: ImageFormatProperties,
15192     ) -> Self {
15193         self.inner.image_format_properties = image_format_properties;
15194         self
15195     }
15196     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
15197     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
15198     #[doc = r" valid extension structs can be pushed into the chain."]
15199     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
15200     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsImageFormatProperties2>(mut self, next: &'a mut T) -> Self15201     pub fn push_next<T: ExtendsImageFormatProperties2>(mut self, next: &'a mut T) -> Self {
15202         unsafe {
15203             let next_ptr = <*mut T>::cast(next);
15204             let last_next = ptr_chain_iter(next).last().unwrap();
15205             (*last_next).p_next = self.inner.p_next as _;
15206             self.inner.p_next = next_ptr;
15207         }
15208         self
15209     }
15210     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15211     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15212     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageFormatProperties215213     pub fn build(self) -> ImageFormatProperties2 {
15214         self.inner
15215     }
15216 }
15217 #[repr(C)]
15218 #[cfg_attr(feature = "debug", derive(Debug))]
15219 #[derive(Copy, Clone)]
15220 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageFormatInfo2.html>"]
15221 pub struct PhysicalDeviceImageFormatInfo2 {
15222     pub s_type: StructureType,
15223     pub p_next: *const c_void,
15224     pub format: Format,
15225     pub ty: ImageType,
15226     pub tiling: ImageTiling,
15227     pub usage: ImageUsageFlags,
15228     pub flags: ImageCreateFlags,
15229 }
15230 impl ::std::default::Default for PhysicalDeviceImageFormatInfo2 {
15231     #[inline]
default() -> Self15232     fn default() -> Self {
15233         Self {
15234             s_type: Self::STRUCTURE_TYPE,
15235             p_next: ::std::ptr::null(),
15236             format: Format::default(),
15237             ty: ImageType::default(),
15238             tiling: ImageTiling::default(),
15239             usage: ImageUsageFlags::default(),
15240             flags: ImageCreateFlags::default(),
15241         }
15242     }
15243 }
15244 unsafe impl TaggedStructure for PhysicalDeviceImageFormatInfo2 {
15245     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2;
15246 }
15247 impl PhysicalDeviceImageFormatInfo2 {
builder<'a>() -> PhysicalDeviceImageFormatInfo2Builder<'a>15248     pub fn builder<'a>() -> PhysicalDeviceImageFormatInfo2Builder<'a> {
15249         PhysicalDeviceImageFormatInfo2Builder {
15250             inner: Self::default(),
15251             marker: ::std::marker::PhantomData,
15252         }
15253     }
15254 }
15255 #[repr(transparent)]
15256 pub struct PhysicalDeviceImageFormatInfo2Builder<'a> {
15257     inner: PhysicalDeviceImageFormatInfo2,
15258     marker: ::std::marker::PhantomData<&'a ()>,
15259 }
15260 pub unsafe trait ExtendsPhysicalDeviceImageFormatInfo2 {}
15261 impl<'a> ::std::ops::Deref for PhysicalDeviceImageFormatInfo2Builder<'a> {
15262     type Target = PhysicalDeviceImageFormatInfo2;
deref(&self) -> &Self::Target15263     fn deref(&self) -> &Self::Target {
15264         &self.inner
15265     }
15266 }
15267 impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageFormatInfo2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target15268     fn deref_mut(&mut self) -> &mut Self::Target {
15269         &mut self.inner
15270     }
15271 }
15272 impl<'a> PhysicalDeviceImageFormatInfo2Builder<'a> {
15273     #[inline]
format(mut self, format: Format) -> Self15274     pub fn format(mut self, format: Format) -> Self {
15275         self.inner.format = format;
15276         self
15277     }
15278     #[inline]
ty(mut self, ty: ImageType) -> Self15279     pub fn ty(mut self, ty: ImageType) -> Self {
15280         self.inner.ty = ty;
15281         self
15282     }
15283     #[inline]
tiling(mut self, tiling: ImageTiling) -> Self15284     pub fn tiling(mut self, tiling: ImageTiling) -> Self {
15285         self.inner.tiling = tiling;
15286         self
15287     }
15288     #[inline]
usage(mut self, usage: ImageUsageFlags) -> Self15289     pub fn usage(mut self, usage: ImageUsageFlags) -> Self {
15290         self.inner.usage = usage;
15291         self
15292     }
15293     #[inline]
flags(mut self, flags: ImageCreateFlags) -> Self15294     pub fn flags(mut self, flags: ImageCreateFlags) -> Self {
15295         self.inner.flags = flags;
15296         self
15297     }
15298     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
15299     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
15300     #[doc = r" valid extension structs can be pushed into the chain."]
15301     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
15302     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPhysicalDeviceImageFormatInfo2>(mut self, next: &'a mut T) -> Self15303     pub fn push_next<T: ExtendsPhysicalDeviceImageFormatInfo2>(mut self, next: &'a mut T) -> Self {
15304         unsafe {
15305             let next_ptr = <*const T>::cast(next);
15306             let last_next = ptr_chain_iter(next).last().unwrap();
15307             (*last_next).p_next = self.inner.p_next as _;
15308             self.inner.p_next = next_ptr;
15309         }
15310         self
15311     }
15312     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15313     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15314     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceImageFormatInfo215315     pub fn build(self) -> PhysicalDeviceImageFormatInfo2 {
15316         self.inner
15317     }
15318 }
15319 #[repr(C)]
15320 #[cfg_attr(feature = "debug", derive(Debug))]
15321 #[derive(Copy, Clone)]
15322 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyProperties2.html>"]
15323 pub struct QueueFamilyProperties2 {
15324     pub s_type: StructureType,
15325     pub p_next: *mut c_void,
15326     pub queue_family_properties: QueueFamilyProperties,
15327 }
15328 impl ::std::default::Default for QueueFamilyProperties2 {
15329     #[inline]
default() -> Self15330     fn default() -> Self {
15331         Self {
15332             s_type: Self::STRUCTURE_TYPE,
15333             p_next: ::std::ptr::null_mut(),
15334             queue_family_properties: QueueFamilyProperties::default(),
15335         }
15336     }
15337 }
15338 unsafe impl TaggedStructure for QueueFamilyProperties2 {
15339     const STRUCTURE_TYPE: StructureType = StructureType::QUEUE_FAMILY_PROPERTIES_2;
15340 }
15341 impl QueueFamilyProperties2 {
builder<'a>() -> QueueFamilyProperties2Builder<'a>15342     pub fn builder<'a>() -> QueueFamilyProperties2Builder<'a> {
15343         QueueFamilyProperties2Builder {
15344             inner: Self::default(),
15345             marker: ::std::marker::PhantomData,
15346         }
15347     }
15348 }
15349 #[repr(transparent)]
15350 pub struct QueueFamilyProperties2Builder<'a> {
15351     inner: QueueFamilyProperties2,
15352     marker: ::std::marker::PhantomData<&'a ()>,
15353 }
15354 pub unsafe trait ExtendsQueueFamilyProperties2 {}
15355 impl<'a> ::std::ops::Deref for QueueFamilyProperties2Builder<'a> {
15356     type Target = QueueFamilyProperties2;
deref(&self) -> &Self::Target15357     fn deref(&self) -> &Self::Target {
15358         &self.inner
15359     }
15360 }
15361 impl<'a> ::std::ops::DerefMut for QueueFamilyProperties2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target15362     fn deref_mut(&mut self) -> &mut Self::Target {
15363         &mut self.inner
15364     }
15365 }
15366 impl<'a> QueueFamilyProperties2Builder<'a> {
15367     #[inline]
queue_family_properties( mut self, queue_family_properties: QueueFamilyProperties, ) -> Self15368     pub fn queue_family_properties(
15369         mut self,
15370         queue_family_properties: QueueFamilyProperties,
15371     ) -> Self {
15372         self.inner.queue_family_properties = queue_family_properties;
15373         self
15374     }
15375     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
15376     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
15377     #[doc = r" valid extension structs can be pushed into the chain."]
15378     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
15379     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsQueueFamilyProperties2>(mut self, next: &'a mut T) -> Self15380     pub fn push_next<T: ExtendsQueueFamilyProperties2>(mut self, next: &'a mut T) -> Self {
15381         unsafe {
15382             let next_ptr = <*mut T>::cast(next);
15383             let last_next = ptr_chain_iter(next).last().unwrap();
15384             (*last_next).p_next = self.inner.p_next as _;
15385             self.inner.p_next = next_ptr;
15386         }
15387         self
15388     }
15389     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15390     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15391     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> QueueFamilyProperties215392     pub fn build(self) -> QueueFamilyProperties2 {
15393         self.inner
15394     }
15395 }
15396 #[repr(C)]
15397 #[cfg_attr(feature = "debug", derive(Debug))]
15398 #[derive(Copy, Clone)]
15399 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMemoryProperties2.html>"]
15400 pub struct PhysicalDeviceMemoryProperties2 {
15401     pub s_type: StructureType,
15402     pub p_next: *mut c_void,
15403     pub memory_properties: PhysicalDeviceMemoryProperties,
15404 }
15405 impl ::std::default::Default for PhysicalDeviceMemoryProperties2 {
15406     #[inline]
default() -> Self15407     fn default() -> Self {
15408         Self {
15409             s_type: Self::STRUCTURE_TYPE,
15410             p_next: ::std::ptr::null_mut(),
15411             memory_properties: PhysicalDeviceMemoryProperties::default(),
15412         }
15413     }
15414 }
15415 unsafe impl TaggedStructure for PhysicalDeviceMemoryProperties2 {
15416     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
15417 }
15418 impl PhysicalDeviceMemoryProperties2 {
builder<'a>() -> PhysicalDeviceMemoryProperties2Builder<'a>15419     pub fn builder<'a>() -> PhysicalDeviceMemoryProperties2Builder<'a> {
15420         PhysicalDeviceMemoryProperties2Builder {
15421             inner: Self::default(),
15422             marker: ::std::marker::PhantomData,
15423         }
15424     }
15425 }
15426 #[repr(transparent)]
15427 pub struct PhysicalDeviceMemoryProperties2Builder<'a> {
15428     inner: PhysicalDeviceMemoryProperties2,
15429     marker: ::std::marker::PhantomData<&'a ()>,
15430 }
15431 pub unsafe trait ExtendsPhysicalDeviceMemoryProperties2 {}
15432 impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryProperties2Builder<'a> {
15433     type Target = PhysicalDeviceMemoryProperties2;
deref(&self) -> &Self::Target15434     fn deref(&self) -> &Self::Target {
15435         &self.inner
15436     }
15437 }
15438 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryProperties2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target15439     fn deref_mut(&mut self) -> &mut Self::Target {
15440         &mut self.inner
15441     }
15442 }
15443 impl<'a> PhysicalDeviceMemoryProperties2Builder<'a> {
15444     #[inline]
memory_properties(mut self, memory_properties: PhysicalDeviceMemoryProperties) -> Self15445     pub fn memory_properties(mut self, memory_properties: PhysicalDeviceMemoryProperties) -> Self {
15446         self.inner.memory_properties = memory_properties;
15447         self
15448     }
15449     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
15450     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
15451     #[doc = r" valid extension structs can be pushed into the chain."]
15452     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
15453     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPhysicalDeviceMemoryProperties2>(mut self, next: &'a mut T) -> Self15454     pub fn push_next<T: ExtendsPhysicalDeviceMemoryProperties2>(mut self, next: &'a mut T) -> Self {
15455         unsafe {
15456             let next_ptr = <*mut T>::cast(next);
15457             let last_next = ptr_chain_iter(next).last().unwrap();
15458             (*last_next).p_next = self.inner.p_next as _;
15459             self.inner.p_next = next_ptr;
15460         }
15461         self
15462     }
15463     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15464     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15465     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMemoryProperties215466     pub fn build(self) -> PhysicalDeviceMemoryProperties2 {
15467         self.inner
15468     }
15469 }
15470 #[repr(C)]
15471 #[cfg_attr(feature = "debug", derive(Debug))]
15472 #[derive(Copy, Clone)]
15473 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageFormatProperties2.html>"]
15474 pub struct SparseImageFormatProperties2 {
15475     pub s_type: StructureType,
15476     pub p_next: *mut c_void,
15477     pub properties: SparseImageFormatProperties,
15478 }
15479 impl ::std::default::Default for SparseImageFormatProperties2 {
15480     #[inline]
default() -> Self15481     fn default() -> Self {
15482         Self {
15483             s_type: Self::STRUCTURE_TYPE,
15484             p_next: ::std::ptr::null_mut(),
15485             properties: SparseImageFormatProperties::default(),
15486         }
15487     }
15488 }
15489 unsafe impl TaggedStructure for SparseImageFormatProperties2 {
15490     const STRUCTURE_TYPE: StructureType = StructureType::SPARSE_IMAGE_FORMAT_PROPERTIES_2;
15491 }
15492 impl SparseImageFormatProperties2 {
builder<'a>() -> SparseImageFormatProperties2Builder<'a>15493     pub fn builder<'a>() -> SparseImageFormatProperties2Builder<'a> {
15494         SparseImageFormatProperties2Builder {
15495             inner: Self::default(),
15496             marker: ::std::marker::PhantomData,
15497         }
15498     }
15499 }
15500 #[repr(transparent)]
15501 pub struct SparseImageFormatProperties2Builder<'a> {
15502     inner: SparseImageFormatProperties2,
15503     marker: ::std::marker::PhantomData<&'a ()>,
15504 }
15505 impl<'a> ::std::ops::Deref for SparseImageFormatProperties2Builder<'a> {
15506     type Target = SparseImageFormatProperties2;
deref(&self) -> &Self::Target15507     fn deref(&self) -> &Self::Target {
15508         &self.inner
15509     }
15510 }
15511 impl<'a> ::std::ops::DerefMut for SparseImageFormatProperties2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target15512     fn deref_mut(&mut self) -> &mut Self::Target {
15513         &mut self.inner
15514     }
15515 }
15516 impl<'a> SparseImageFormatProperties2Builder<'a> {
15517     #[inline]
properties(mut self, properties: SparseImageFormatProperties) -> Self15518     pub fn properties(mut self, properties: SparseImageFormatProperties) -> Self {
15519         self.inner.properties = properties;
15520         self
15521     }
15522     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15523     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15524     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SparseImageFormatProperties215525     pub fn build(self) -> SparseImageFormatProperties2 {
15526         self.inner
15527     }
15528 }
15529 #[repr(C)]
15530 #[cfg_attr(feature = "debug", derive(Debug))]
15531 #[derive(Copy, Clone)]
15532 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSparseImageFormatInfo2.html>"]
15533 pub struct PhysicalDeviceSparseImageFormatInfo2 {
15534     pub s_type: StructureType,
15535     pub p_next: *const c_void,
15536     pub format: Format,
15537     pub ty: ImageType,
15538     pub samples: SampleCountFlags,
15539     pub usage: ImageUsageFlags,
15540     pub tiling: ImageTiling,
15541 }
15542 impl ::std::default::Default for PhysicalDeviceSparseImageFormatInfo2 {
15543     #[inline]
default() -> Self15544     fn default() -> Self {
15545         Self {
15546             s_type: Self::STRUCTURE_TYPE,
15547             p_next: ::std::ptr::null(),
15548             format: Format::default(),
15549             ty: ImageType::default(),
15550             samples: SampleCountFlags::default(),
15551             usage: ImageUsageFlags::default(),
15552             tiling: ImageTiling::default(),
15553         }
15554     }
15555 }
15556 unsafe impl TaggedStructure for PhysicalDeviceSparseImageFormatInfo2 {
15557     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2;
15558 }
15559 impl PhysicalDeviceSparseImageFormatInfo2 {
builder<'a>() -> PhysicalDeviceSparseImageFormatInfo2Builder<'a>15560     pub fn builder<'a>() -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
15561         PhysicalDeviceSparseImageFormatInfo2Builder {
15562             inner: Self::default(),
15563             marker: ::std::marker::PhantomData,
15564         }
15565     }
15566 }
15567 #[repr(transparent)]
15568 pub struct PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
15569     inner: PhysicalDeviceSparseImageFormatInfo2,
15570     marker: ::std::marker::PhantomData<&'a ()>,
15571 }
15572 impl<'a> ::std::ops::Deref for PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
15573     type Target = PhysicalDeviceSparseImageFormatInfo2;
deref(&self) -> &Self::Target15574     fn deref(&self) -> &Self::Target {
15575         &self.inner
15576     }
15577 }
15578 impl<'a> ::std::ops::DerefMut for PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target15579     fn deref_mut(&mut self) -> &mut Self::Target {
15580         &mut self.inner
15581     }
15582 }
15583 impl<'a> PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
15584     #[inline]
format(mut self, format: Format) -> Self15585     pub fn format(mut self, format: Format) -> Self {
15586         self.inner.format = format;
15587         self
15588     }
15589     #[inline]
ty(mut self, ty: ImageType) -> Self15590     pub fn ty(mut self, ty: ImageType) -> Self {
15591         self.inner.ty = ty;
15592         self
15593     }
15594     #[inline]
samples(mut self, samples: SampleCountFlags) -> Self15595     pub fn samples(mut self, samples: SampleCountFlags) -> Self {
15596         self.inner.samples = samples;
15597         self
15598     }
15599     #[inline]
usage(mut self, usage: ImageUsageFlags) -> Self15600     pub fn usage(mut self, usage: ImageUsageFlags) -> Self {
15601         self.inner.usage = usage;
15602         self
15603     }
15604     #[inline]
tiling(mut self, tiling: ImageTiling) -> Self15605     pub fn tiling(mut self, tiling: ImageTiling) -> Self {
15606         self.inner.tiling = tiling;
15607         self
15608     }
15609     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15610     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15611     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceSparseImageFormatInfo215612     pub fn build(self) -> PhysicalDeviceSparseImageFormatInfo2 {
15613         self.inner
15614     }
15615 }
15616 #[repr(C)]
15617 #[cfg_attr(feature = "debug", derive(Debug))]
15618 #[derive(Copy, Clone)]
15619 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePushDescriptorPropertiesKHR.html>"]
15620 pub struct PhysicalDevicePushDescriptorPropertiesKHR {
15621     pub s_type: StructureType,
15622     pub p_next: *mut c_void,
15623     pub max_push_descriptors: u32,
15624 }
15625 impl ::std::default::Default for PhysicalDevicePushDescriptorPropertiesKHR {
15626     #[inline]
default() -> Self15627     fn default() -> Self {
15628         Self {
15629             s_type: Self::STRUCTURE_TYPE,
15630             p_next: ::std::ptr::null_mut(),
15631             max_push_descriptors: u32::default(),
15632         }
15633     }
15634 }
15635 unsafe impl TaggedStructure for PhysicalDevicePushDescriptorPropertiesKHR {
15636     const STRUCTURE_TYPE: StructureType =
15637         StructureType::PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR;
15638 }
15639 impl PhysicalDevicePushDescriptorPropertiesKHR {
builder<'a>() -> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a>15640     pub fn builder<'a>() -> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
15641         PhysicalDevicePushDescriptorPropertiesKHRBuilder {
15642             inner: Self::default(),
15643             marker: ::std::marker::PhantomData,
15644         }
15645     }
15646 }
15647 #[repr(transparent)]
15648 pub struct PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
15649     inner: PhysicalDevicePushDescriptorPropertiesKHR,
15650     marker: ::std::marker::PhantomData<&'a ()>,
15651 }
15652 unsafe impl ExtendsPhysicalDeviceProperties2
15653     for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'_>
15654 {
15655 }
15656 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePushDescriptorPropertiesKHR {}
15657 impl<'a> ::std::ops::Deref for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
15658     type Target = PhysicalDevicePushDescriptorPropertiesKHR;
deref(&self) -> &Self::Target15659     fn deref(&self) -> &Self::Target {
15660         &self.inner
15661     }
15662 }
15663 impl<'a> ::std::ops::DerefMut for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target15664     fn deref_mut(&mut self) -> &mut Self::Target {
15665         &mut self.inner
15666     }
15667 }
15668 impl<'a> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
15669     #[inline]
max_push_descriptors(mut self, max_push_descriptors: u32) -> Self15670     pub fn max_push_descriptors(mut self, max_push_descriptors: u32) -> Self {
15671         self.inner.max_push_descriptors = max_push_descriptors;
15672         self
15673     }
15674     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15675     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15676     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePushDescriptorPropertiesKHR15677     pub fn build(self) -> PhysicalDevicePushDescriptorPropertiesKHR {
15678         self.inner
15679     }
15680 }
15681 #[repr(C)]
15682 #[cfg_attr(feature = "debug", derive(Debug))]
15683 #[derive(Copy, Clone, Default)]
15684 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkConformanceVersion.html>"]
15685 pub struct ConformanceVersion {
15686     pub major: u8,
15687     pub minor: u8,
15688     pub subminor: u8,
15689     pub patch: u8,
15690 }
15691 impl ConformanceVersion {
builder<'a>() -> ConformanceVersionBuilder<'a>15692     pub fn builder<'a>() -> ConformanceVersionBuilder<'a> {
15693         ConformanceVersionBuilder {
15694             inner: Self::default(),
15695             marker: ::std::marker::PhantomData,
15696         }
15697     }
15698 }
15699 #[repr(transparent)]
15700 pub struct ConformanceVersionBuilder<'a> {
15701     inner: ConformanceVersion,
15702     marker: ::std::marker::PhantomData<&'a ()>,
15703 }
15704 impl<'a> ::std::ops::Deref for ConformanceVersionBuilder<'a> {
15705     type Target = ConformanceVersion;
deref(&self) -> &Self::Target15706     fn deref(&self) -> &Self::Target {
15707         &self.inner
15708     }
15709 }
15710 impl<'a> ::std::ops::DerefMut for ConformanceVersionBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target15711     fn deref_mut(&mut self) -> &mut Self::Target {
15712         &mut self.inner
15713     }
15714 }
15715 impl<'a> ConformanceVersionBuilder<'a> {
15716     #[inline]
major(mut self, major: u8) -> Self15717     pub fn major(mut self, major: u8) -> Self {
15718         self.inner.major = major;
15719         self
15720     }
15721     #[inline]
minor(mut self, minor: u8) -> Self15722     pub fn minor(mut self, minor: u8) -> Self {
15723         self.inner.minor = minor;
15724         self
15725     }
15726     #[inline]
subminor(mut self, subminor: u8) -> Self15727     pub fn subminor(mut self, subminor: u8) -> Self {
15728         self.inner.subminor = subminor;
15729         self
15730     }
15731     #[inline]
patch(mut self, patch: u8) -> Self15732     pub fn patch(mut self, patch: u8) -> Self {
15733         self.inner.patch = patch;
15734         self
15735     }
15736     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15737     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15738     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ConformanceVersion15739     pub fn build(self) -> ConformanceVersion {
15740         self.inner
15741     }
15742 }
15743 #[repr(C)]
15744 #[derive(Copy, Clone)]
15745 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDriverProperties.html>"]
15746 pub struct PhysicalDeviceDriverProperties {
15747     pub s_type: StructureType,
15748     pub p_next: *mut c_void,
15749     pub driver_id: DriverId,
15750     pub driver_name: [c_char; MAX_DRIVER_NAME_SIZE],
15751     pub driver_info: [c_char; MAX_DRIVER_INFO_SIZE],
15752     pub conformance_version: ConformanceVersion,
15753 }
15754 #[cfg(feature = "debug")]
15755 impl fmt::Debug for PhysicalDeviceDriverProperties {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result15756     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
15757         fmt.debug_struct("PhysicalDeviceDriverProperties")
15758             .field("s_type", &self.s_type)
15759             .field("p_next", &self.p_next)
15760             .field("driver_id", &self.driver_id)
15761             .field("driver_name", &unsafe {
15762                 ::std::ffi::CStr::from_ptr(self.driver_name.as_ptr())
15763             })
15764             .field("driver_info", &unsafe {
15765                 ::std::ffi::CStr::from_ptr(self.driver_info.as_ptr())
15766             })
15767             .field("conformance_version", &self.conformance_version)
15768             .finish()
15769     }
15770 }
15771 impl ::std::default::Default for PhysicalDeviceDriverProperties {
15772     #[inline]
default() -> Self15773     fn default() -> Self {
15774         Self {
15775             s_type: Self::STRUCTURE_TYPE,
15776             p_next: ::std::ptr::null_mut(),
15777             driver_id: DriverId::default(),
15778             driver_name: unsafe { ::std::mem::zeroed() },
15779             driver_info: unsafe { ::std::mem::zeroed() },
15780             conformance_version: ConformanceVersion::default(),
15781         }
15782     }
15783 }
15784 unsafe impl TaggedStructure for PhysicalDeviceDriverProperties {
15785     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_DRIVER_PROPERTIES;
15786 }
15787 impl PhysicalDeviceDriverProperties {
builder<'a>() -> PhysicalDeviceDriverPropertiesBuilder<'a>15788     pub fn builder<'a>() -> PhysicalDeviceDriverPropertiesBuilder<'a> {
15789         PhysicalDeviceDriverPropertiesBuilder {
15790             inner: Self::default(),
15791             marker: ::std::marker::PhantomData,
15792         }
15793     }
15794 }
15795 #[repr(transparent)]
15796 pub struct PhysicalDeviceDriverPropertiesBuilder<'a> {
15797     inner: PhysicalDeviceDriverProperties,
15798     marker: ::std::marker::PhantomData<&'a ()>,
15799 }
15800 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDriverPropertiesBuilder<'_> {}
15801 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDriverProperties {}
15802 impl<'a> ::std::ops::Deref for PhysicalDeviceDriverPropertiesBuilder<'a> {
15803     type Target = PhysicalDeviceDriverProperties;
deref(&self) -> &Self::Target15804     fn deref(&self) -> &Self::Target {
15805         &self.inner
15806     }
15807 }
15808 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDriverPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target15809     fn deref_mut(&mut self) -> &mut Self::Target {
15810         &mut self.inner
15811     }
15812 }
15813 impl<'a> PhysicalDeviceDriverPropertiesBuilder<'a> {
15814     #[inline]
driver_id(mut self, driver_id: DriverId) -> Self15815     pub fn driver_id(mut self, driver_id: DriverId) -> Self {
15816         self.inner.driver_id = driver_id;
15817         self
15818     }
15819     #[inline]
driver_name(mut self, driver_name: [c_char; MAX_DRIVER_NAME_SIZE]) -> Self15820     pub fn driver_name(mut self, driver_name: [c_char; MAX_DRIVER_NAME_SIZE]) -> Self {
15821         self.inner.driver_name = driver_name;
15822         self
15823     }
15824     #[inline]
driver_info(mut self, driver_info: [c_char; MAX_DRIVER_INFO_SIZE]) -> Self15825     pub fn driver_info(mut self, driver_info: [c_char; MAX_DRIVER_INFO_SIZE]) -> Self {
15826         self.inner.driver_info = driver_info;
15827         self
15828     }
15829     #[inline]
conformance_version(mut self, conformance_version: ConformanceVersion) -> Self15830     pub fn conformance_version(mut self, conformance_version: ConformanceVersion) -> Self {
15831         self.inner.conformance_version = conformance_version;
15832         self
15833     }
15834     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15835     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15836     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDriverProperties15837     pub fn build(self) -> PhysicalDeviceDriverProperties {
15838         self.inner
15839     }
15840 }
15841 #[repr(C)]
15842 #[cfg_attr(feature = "debug", derive(Debug))]
15843 #[derive(Copy, Clone)]
15844 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentRegionsKHR.html>"]
15845 pub struct PresentRegionsKHR {
15846     pub s_type: StructureType,
15847     pub p_next: *const c_void,
15848     pub swapchain_count: u32,
15849     pub p_regions: *const PresentRegionKHR,
15850 }
15851 impl ::std::default::Default for PresentRegionsKHR {
15852     #[inline]
default() -> Self15853     fn default() -> Self {
15854         Self {
15855             s_type: Self::STRUCTURE_TYPE,
15856             p_next: ::std::ptr::null(),
15857             swapchain_count: u32::default(),
15858             p_regions: ::std::ptr::null(),
15859         }
15860     }
15861 }
15862 unsafe impl TaggedStructure for PresentRegionsKHR {
15863     const STRUCTURE_TYPE: StructureType = StructureType::PRESENT_REGIONS_KHR;
15864 }
15865 impl PresentRegionsKHR {
builder<'a>() -> PresentRegionsKHRBuilder<'a>15866     pub fn builder<'a>() -> PresentRegionsKHRBuilder<'a> {
15867         PresentRegionsKHRBuilder {
15868             inner: Self::default(),
15869             marker: ::std::marker::PhantomData,
15870         }
15871     }
15872 }
15873 #[repr(transparent)]
15874 pub struct PresentRegionsKHRBuilder<'a> {
15875     inner: PresentRegionsKHR,
15876     marker: ::std::marker::PhantomData<&'a ()>,
15877 }
15878 unsafe impl ExtendsPresentInfoKHR for PresentRegionsKHRBuilder<'_> {}
15879 unsafe impl ExtendsPresentInfoKHR for PresentRegionsKHR {}
15880 impl<'a> ::std::ops::Deref for PresentRegionsKHRBuilder<'a> {
15881     type Target = PresentRegionsKHR;
deref(&self) -> &Self::Target15882     fn deref(&self) -> &Self::Target {
15883         &self.inner
15884     }
15885 }
15886 impl<'a> ::std::ops::DerefMut for PresentRegionsKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target15887     fn deref_mut(&mut self) -> &mut Self::Target {
15888         &mut self.inner
15889     }
15890 }
15891 impl<'a> PresentRegionsKHRBuilder<'a> {
15892     #[inline]
regions(mut self, regions: &'a [PresentRegionKHR]) -> Self15893     pub fn regions(mut self, regions: &'a [PresentRegionKHR]) -> Self {
15894         self.inner.swapchain_count = regions.len() as _;
15895         self.inner.p_regions = regions.as_ptr();
15896         self
15897     }
15898     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15899     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15900     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PresentRegionsKHR15901     pub fn build(self) -> PresentRegionsKHR {
15902         self.inner
15903     }
15904 }
15905 #[repr(C)]
15906 #[cfg_attr(feature = "debug", derive(Debug))]
15907 #[derive(Copy, Clone)]
15908 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentRegionKHR.html>"]
15909 pub struct PresentRegionKHR {
15910     pub rectangle_count: u32,
15911     pub p_rectangles: *const RectLayerKHR,
15912 }
15913 impl ::std::default::Default for PresentRegionKHR {
15914     #[inline]
default() -> Self15915     fn default() -> Self {
15916         Self {
15917             rectangle_count: u32::default(),
15918             p_rectangles: ::std::ptr::null(),
15919         }
15920     }
15921 }
15922 impl PresentRegionKHR {
builder<'a>() -> PresentRegionKHRBuilder<'a>15923     pub fn builder<'a>() -> PresentRegionKHRBuilder<'a> {
15924         PresentRegionKHRBuilder {
15925             inner: Self::default(),
15926             marker: ::std::marker::PhantomData,
15927         }
15928     }
15929 }
15930 #[repr(transparent)]
15931 pub struct PresentRegionKHRBuilder<'a> {
15932     inner: PresentRegionKHR,
15933     marker: ::std::marker::PhantomData<&'a ()>,
15934 }
15935 impl<'a> ::std::ops::Deref for PresentRegionKHRBuilder<'a> {
15936     type Target = PresentRegionKHR;
deref(&self) -> &Self::Target15937     fn deref(&self) -> &Self::Target {
15938         &self.inner
15939     }
15940 }
15941 impl<'a> ::std::ops::DerefMut for PresentRegionKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target15942     fn deref_mut(&mut self) -> &mut Self::Target {
15943         &mut self.inner
15944     }
15945 }
15946 impl<'a> PresentRegionKHRBuilder<'a> {
15947     #[inline]
rectangles(mut self, rectangles: &'a [RectLayerKHR]) -> Self15948     pub fn rectangles(mut self, rectangles: &'a [RectLayerKHR]) -> Self {
15949         self.inner.rectangle_count = rectangles.len() as _;
15950         self.inner.p_rectangles = rectangles.as_ptr();
15951         self
15952     }
15953     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15954     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15955     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PresentRegionKHR15956     pub fn build(self) -> PresentRegionKHR {
15957         self.inner
15958     }
15959 }
15960 #[repr(C)]
15961 #[cfg_attr(feature = "debug", derive(Debug))]
15962 #[derive(Copy, Clone, Default)]
15963 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRectLayerKHR.html>"]
15964 pub struct RectLayerKHR {
15965     pub offset: Offset2D,
15966     pub extent: Extent2D,
15967     pub layer: u32,
15968 }
15969 impl RectLayerKHR {
builder<'a>() -> RectLayerKHRBuilder<'a>15970     pub fn builder<'a>() -> RectLayerKHRBuilder<'a> {
15971         RectLayerKHRBuilder {
15972             inner: Self::default(),
15973             marker: ::std::marker::PhantomData,
15974         }
15975     }
15976 }
15977 #[repr(transparent)]
15978 pub struct RectLayerKHRBuilder<'a> {
15979     inner: RectLayerKHR,
15980     marker: ::std::marker::PhantomData<&'a ()>,
15981 }
15982 impl<'a> ::std::ops::Deref for RectLayerKHRBuilder<'a> {
15983     type Target = RectLayerKHR;
deref(&self) -> &Self::Target15984     fn deref(&self) -> &Self::Target {
15985         &self.inner
15986     }
15987 }
15988 impl<'a> ::std::ops::DerefMut for RectLayerKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target15989     fn deref_mut(&mut self) -> &mut Self::Target {
15990         &mut self.inner
15991     }
15992 }
15993 impl<'a> RectLayerKHRBuilder<'a> {
15994     #[inline]
offset(mut self, offset: Offset2D) -> Self15995     pub fn offset(mut self, offset: Offset2D) -> Self {
15996         self.inner.offset = offset;
15997         self
15998     }
15999     #[inline]
extent(mut self, extent: Extent2D) -> Self16000     pub fn extent(mut self, extent: Extent2D) -> Self {
16001         self.inner.extent = extent;
16002         self
16003     }
16004     #[inline]
layer(mut self, layer: u32) -> Self16005     pub fn layer(mut self, layer: u32) -> Self {
16006         self.inner.layer = layer;
16007         self
16008     }
16009     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16010     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16011     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RectLayerKHR16012     pub fn build(self) -> RectLayerKHR {
16013         self.inner
16014     }
16015 }
16016 #[repr(C)]
16017 #[cfg_attr(feature = "debug", derive(Debug))]
16018 #[derive(Copy, Clone)]
16019 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVariablePointersFeatures.html>"]
16020 pub struct PhysicalDeviceVariablePointersFeatures {
16021     pub s_type: StructureType,
16022     pub p_next: *mut c_void,
16023     pub variable_pointers_storage_buffer: Bool32,
16024     pub variable_pointers: Bool32,
16025 }
16026 impl ::std::default::Default for PhysicalDeviceVariablePointersFeatures {
16027     #[inline]
default() -> Self16028     fn default() -> Self {
16029         Self {
16030             s_type: Self::STRUCTURE_TYPE,
16031             p_next: ::std::ptr::null_mut(),
16032             variable_pointers_storage_buffer: Bool32::default(),
16033             variable_pointers: Bool32::default(),
16034         }
16035     }
16036 }
16037 unsafe impl TaggedStructure for PhysicalDeviceVariablePointersFeatures {
16038     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
16039 }
16040 impl PhysicalDeviceVariablePointersFeatures {
builder<'a>() -> PhysicalDeviceVariablePointersFeaturesBuilder<'a>16041     pub fn builder<'a>() -> PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
16042         PhysicalDeviceVariablePointersFeaturesBuilder {
16043             inner: Self::default(),
16044             marker: ::std::marker::PhantomData,
16045         }
16046     }
16047 }
16048 #[repr(transparent)]
16049 pub struct PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
16050     inner: PhysicalDeviceVariablePointersFeatures,
16051     marker: ::std::marker::PhantomData<&'a ()>,
16052 }
16053 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVariablePointersFeaturesBuilder<'_> {}
16054 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVariablePointersFeatures {}
16055 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVariablePointersFeaturesBuilder<'_> {}
16056 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVariablePointersFeatures {}
16057 impl<'a> ::std::ops::Deref for PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
16058     type Target = PhysicalDeviceVariablePointersFeatures;
deref(&self) -> &Self::Target16059     fn deref(&self) -> &Self::Target {
16060         &self.inner
16061     }
16062 }
16063 impl<'a> ::std::ops::DerefMut for PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target16064     fn deref_mut(&mut self) -> &mut Self::Target {
16065         &mut self.inner
16066     }
16067 }
16068 impl<'a> PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
16069     #[inline]
variable_pointers_storage_buffer( mut self, variable_pointers_storage_buffer: bool, ) -> Self16070     pub fn variable_pointers_storage_buffer(
16071         mut self,
16072         variable_pointers_storage_buffer: bool,
16073     ) -> Self {
16074         self.inner.variable_pointers_storage_buffer = variable_pointers_storage_buffer.into();
16075         self
16076     }
16077     #[inline]
variable_pointers(mut self, variable_pointers: bool) -> Self16078     pub fn variable_pointers(mut self, variable_pointers: bool) -> Self {
16079         self.inner.variable_pointers = variable_pointers.into();
16080         self
16081     }
16082     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16083     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16084     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceVariablePointersFeatures16085     pub fn build(self) -> PhysicalDeviceVariablePointersFeatures {
16086         self.inner
16087     }
16088 }
16089 #[repr(C)]
16090 #[cfg_attr(feature = "debug", derive(Debug))]
16091 #[derive(Copy, Clone, Default)]
16092 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryProperties.html>"]
16093 pub struct ExternalMemoryProperties {
16094     pub external_memory_features: ExternalMemoryFeatureFlags,
16095     pub export_from_imported_handle_types: ExternalMemoryHandleTypeFlags,
16096     pub compatible_handle_types: ExternalMemoryHandleTypeFlags,
16097 }
16098 impl ExternalMemoryProperties {
builder<'a>() -> ExternalMemoryPropertiesBuilder<'a>16099     pub fn builder<'a>() -> ExternalMemoryPropertiesBuilder<'a> {
16100         ExternalMemoryPropertiesBuilder {
16101             inner: Self::default(),
16102             marker: ::std::marker::PhantomData,
16103         }
16104     }
16105 }
16106 #[repr(transparent)]
16107 pub struct ExternalMemoryPropertiesBuilder<'a> {
16108     inner: ExternalMemoryProperties,
16109     marker: ::std::marker::PhantomData<&'a ()>,
16110 }
16111 impl<'a> ::std::ops::Deref for ExternalMemoryPropertiesBuilder<'a> {
16112     type Target = ExternalMemoryProperties;
deref(&self) -> &Self::Target16113     fn deref(&self) -> &Self::Target {
16114         &self.inner
16115     }
16116 }
16117 impl<'a> ::std::ops::DerefMut for ExternalMemoryPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target16118     fn deref_mut(&mut self) -> &mut Self::Target {
16119         &mut self.inner
16120     }
16121 }
16122 impl<'a> ExternalMemoryPropertiesBuilder<'a> {
16123     #[inline]
external_memory_features( mut self, external_memory_features: ExternalMemoryFeatureFlags, ) -> Self16124     pub fn external_memory_features(
16125         mut self,
16126         external_memory_features: ExternalMemoryFeatureFlags,
16127     ) -> Self {
16128         self.inner.external_memory_features = external_memory_features;
16129         self
16130     }
16131     #[inline]
export_from_imported_handle_types( mut self, export_from_imported_handle_types: ExternalMemoryHandleTypeFlags, ) -> Self16132     pub fn export_from_imported_handle_types(
16133         mut self,
16134         export_from_imported_handle_types: ExternalMemoryHandleTypeFlags,
16135     ) -> Self {
16136         self.inner.export_from_imported_handle_types = export_from_imported_handle_types;
16137         self
16138     }
16139     #[inline]
compatible_handle_types( mut self, compatible_handle_types: ExternalMemoryHandleTypeFlags, ) -> Self16140     pub fn compatible_handle_types(
16141         mut self,
16142         compatible_handle_types: ExternalMemoryHandleTypeFlags,
16143     ) -> Self {
16144         self.inner.compatible_handle_types = compatible_handle_types;
16145         self
16146     }
16147     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16148     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16149     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExternalMemoryProperties16150     pub fn build(self) -> ExternalMemoryProperties {
16151         self.inner
16152     }
16153 }
16154 #[repr(C)]
16155 #[cfg_attr(feature = "debug", derive(Debug))]
16156 #[derive(Copy, Clone)]
16157 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalImageFormatInfo.html>"]
16158 pub struct PhysicalDeviceExternalImageFormatInfo {
16159     pub s_type: StructureType,
16160     pub p_next: *const c_void,
16161     pub handle_type: ExternalMemoryHandleTypeFlags,
16162 }
16163 impl ::std::default::Default for PhysicalDeviceExternalImageFormatInfo {
16164     #[inline]
default() -> Self16165     fn default() -> Self {
16166         Self {
16167             s_type: Self::STRUCTURE_TYPE,
16168             p_next: ::std::ptr::null(),
16169             handle_type: ExternalMemoryHandleTypeFlags::default(),
16170         }
16171     }
16172 }
16173 unsafe impl TaggedStructure for PhysicalDeviceExternalImageFormatInfo {
16174     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO;
16175 }
16176 impl PhysicalDeviceExternalImageFormatInfo {
builder<'a>() -> PhysicalDeviceExternalImageFormatInfoBuilder<'a>16177     pub fn builder<'a>() -> PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
16178         PhysicalDeviceExternalImageFormatInfoBuilder {
16179             inner: Self::default(),
16180             marker: ::std::marker::PhantomData,
16181         }
16182     }
16183 }
16184 #[repr(transparent)]
16185 pub struct PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
16186     inner: PhysicalDeviceExternalImageFormatInfo,
16187     marker: ::std::marker::PhantomData<&'a ()>,
16188 }
16189 unsafe impl ExtendsPhysicalDeviceImageFormatInfo2
16190     for PhysicalDeviceExternalImageFormatInfoBuilder<'_>
16191 {
16192 }
16193 unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceExternalImageFormatInfo {}
16194 impl<'a> ::std::ops::Deref for PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
16195     type Target = PhysicalDeviceExternalImageFormatInfo;
deref(&self) -> &Self::Target16196     fn deref(&self) -> &Self::Target {
16197         &self.inner
16198     }
16199 }
16200 impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target16201     fn deref_mut(&mut self) -> &mut Self::Target {
16202         &mut self.inner
16203     }
16204 }
16205 impl<'a> PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
16206     #[inline]
handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self16207     pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
16208         self.inner.handle_type = handle_type;
16209         self
16210     }
16211     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16212     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16213     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceExternalImageFormatInfo16214     pub fn build(self) -> PhysicalDeviceExternalImageFormatInfo {
16215         self.inner
16216     }
16217 }
16218 #[repr(C)]
16219 #[cfg_attr(feature = "debug", derive(Debug))]
16220 #[derive(Copy, Clone)]
16221 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalImageFormatProperties.html>"]
16222 pub struct ExternalImageFormatProperties {
16223     pub s_type: StructureType,
16224     pub p_next: *mut c_void,
16225     pub external_memory_properties: ExternalMemoryProperties,
16226 }
16227 impl ::std::default::Default for ExternalImageFormatProperties {
16228     #[inline]
default() -> Self16229     fn default() -> Self {
16230         Self {
16231             s_type: Self::STRUCTURE_TYPE,
16232             p_next: ::std::ptr::null_mut(),
16233             external_memory_properties: ExternalMemoryProperties::default(),
16234         }
16235     }
16236 }
16237 unsafe impl TaggedStructure for ExternalImageFormatProperties {
16238     const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_IMAGE_FORMAT_PROPERTIES;
16239 }
16240 impl ExternalImageFormatProperties {
builder<'a>() -> ExternalImageFormatPropertiesBuilder<'a>16241     pub fn builder<'a>() -> ExternalImageFormatPropertiesBuilder<'a> {
16242         ExternalImageFormatPropertiesBuilder {
16243             inner: Self::default(),
16244             marker: ::std::marker::PhantomData,
16245         }
16246     }
16247 }
16248 #[repr(transparent)]
16249 pub struct ExternalImageFormatPropertiesBuilder<'a> {
16250     inner: ExternalImageFormatProperties,
16251     marker: ::std::marker::PhantomData<&'a ()>,
16252 }
16253 unsafe impl ExtendsImageFormatProperties2 for ExternalImageFormatPropertiesBuilder<'_> {}
16254 unsafe impl ExtendsImageFormatProperties2 for ExternalImageFormatProperties {}
16255 impl<'a> ::std::ops::Deref for ExternalImageFormatPropertiesBuilder<'a> {
16256     type Target = ExternalImageFormatProperties;
deref(&self) -> &Self::Target16257     fn deref(&self) -> &Self::Target {
16258         &self.inner
16259     }
16260 }
16261 impl<'a> ::std::ops::DerefMut for ExternalImageFormatPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target16262     fn deref_mut(&mut self) -> &mut Self::Target {
16263         &mut self.inner
16264     }
16265 }
16266 impl<'a> ExternalImageFormatPropertiesBuilder<'a> {
16267     #[inline]
external_memory_properties( mut self, external_memory_properties: ExternalMemoryProperties, ) -> Self16268     pub fn external_memory_properties(
16269         mut self,
16270         external_memory_properties: ExternalMemoryProperties,
16271     ) -> Self {
16272         self.inner.external_memory_properties = external_memory_properties;
16273         self
16274     }
16275     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16276     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16277     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExternalImageFormatProperties16278     pub fn build(self) -> ExternalImageFormatProperties {
16279         self.inner
16280     }
16281 }
16282 #[repr(C)]
16283 #[cfg_attr(feature = "debug", derive(Debug))]
16284 #[derive(Copy, Clone)]
16285 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalBufferInfo.html>"]
16286 pub struct PhysicalDeviceExternalBufferInfo {
16287     pub s_type: StructureType,
16288     pub p_next: *const c_void,
16289     pub flags: BufferCreateFlags,
16290     pub usage: BufferUsageFlags,
16291     pub handle_type: ExternalMemoryHandleTypeFlags,
16292 }
16293 impl ::std::default::Default for PhysicalDeviceExternalBufferInfo {
16294     #[inline]
default() -> Self16295     fn default() -> Self {
16296         Self {
16297             s_type: Self::STRUCTURE_TYPE,
16298             p_next: ::std::ptr::null(),
16299             flags: BufferCreateFlags::default(),
16300             usage: BufferUsageFlags::default(),
16301             handle_type: ExternalMemoryHandleTypeFlags::default(),
16302         }
16303     }
16304 }
16305 unsafe impl TaggedStructure for PhysicalDeviceExternalBufferInfo {
16306     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO;
16307 }
16308 impl PhysicalDeviceExternalBufferInfo {
builder<'a>() -> PhysicalDeviceExternalBufferInfoBuilder<'a>16309     pub fn builder<'a>() -> PhysicalDeviceExternalBufferInfoBuilder<'a> {
16310         PhysicalDeviceExternalBufferInfoBuilder {
16311             inner: Self::default(),
16312             marker: ::std::marker::PhantomData,
16313         }
16314     }
16315 }
16316 #[repr(transparent)]
16317 pub struct PhysicalDeviceExternalBufferInfoBuilder<'a> {
16318     inner: PhysicalDeviceExternalBufferInfo,
16319     marker: ::std::marker::PhantomData<&'a ()>,
16320 }
16321 impl<'a> ::std::ops::Deref for PhysicalDeviceExternalBufferInfoBuilder<'a> {
16322     type Target = PhysicalDeviceExternalBufferInfo;
deref(&self) -> &Self::Target16323     fn deref(&self) -> &Self::Target {
16324         &self.inner
16325     }
16326 }
16327 impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalBufferInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target16328     fn deref_mut(&mut self) -> &mut Self::Target {
16329         &mut self.inner
16330     }
16331 }
16332 impl<'a> PhysicalDeviceExternalBufferInfoBuilder<'a> {
16333     #[inline]
flags(mut self, flags: BufferCreateFlags) -> Self16334     pub fn flags(mut self, flags: BufferCreateFlags) -> Self {
16335         self.inner.flags = flags;
16336         self
16337     }
16338     #[inline]
usage(mut self, usage: BufferUsageFlags) -> Self16339     pub fn usage(mut self, usage: BufferUsageFlags) -> Self {
16340         self.inner.usage = usage;
16341         self
16342     }
16343     #[inline]
handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self16344     pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
16345         self.inner.handle_type = handle_type;
16346         self
16347     }
16348     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16349     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16350     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceExternalBufferInfo16351     pub fn build(self) -> PhysicalDeviceExternalBufferInfo {
16352         self.inner
16353     }
16354 }
16355 #[repr(C)]
16356 #[cfg_attr(feature = "debug", derive(Debug))]
16357 #[derive(Copy, Clone)]
16358 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalBufferProperties.html>"]
16359 pub struct ExternalBufferProperties {
16360     pub s_type: StructureType,
16361     pub p_next: *mut c_void,
16362     pub external_memory_properties: ExternalMemoryProperties,
16363 }
16364 impl ::std::default::Default for ExternalBufferProperties {
16365     #[inline]
default() -> Self16366     fn default() -> Self {
16367         Self {
16368             s_type: Self::STRUCTURE_TYPE,
16369             p_next: ::std::ptr::null_mut(),
16370             external_memory_properties: ExternalMemoryProperties::default(),
16371         }
16372     }
16373 }
16374 unsafe impl TaggedStructure for ExternalBufferProperties {
16375     const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_BUFFER_PROPERTIES;
16376 }
16377 impl ExternalBufferProperties {
builder<'a>() -> ExternalBufferPropertiesBuilder<'a>16378     pub fn builder<'a>() -> ExternalBufferPropertiesBuilder<'a> {
16379         ExternalBufferPropertiesBuilder {
16380             inner: Self::default(),
16381             marker: ::std::marker::PhantomData,
16382         }
16383     }
16384 }
16385 #[repr(transparent)]
16386 pub struct ExternalBufferPropertiesBuilder<'a> {
16387     inner: ExternalBufferProperties,
16388     marker: ::std::marker::PhantomData<&'a ()>,
16389 }
16390 impl<'a> ::std::ops::Deref for ExternalBufferPropertiesBuilder<'a> {
16391     type Target = ExternalBufferProperties;
deref(&self) -> &Self::Target16392     fn deref(&self) -> &Self::Target {
16393         &self.inner
16394     }
16395 }
16396 impl<'a> ::std::ops::DerefMut for ExternalBufferPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target16397     fn deref_mut(&mut self) -> &mut Self::Target {
16398         &mut self.inner
16399     }
16400 }
16401 impl<'a> ExternalBufferPropertiesBuilder<'a> {
16402     #[inline]
external_memory_properties( mut self, external_memory_properties: ExternalMemoryProperties, ) -> Self16403     pub fn external_memory_properties(
16404         mut self,
16405         external_memory_properties: ExternalMemoryProperties,
16406     ) -> Self {
16407         self.inner.external_memory_properties = external_memory_properties;
16408         self
16409     }
16410     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16411     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16412     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExternalBufferProperties16413     pub fn build(self) -> ExternalBufferProperties {
16414         self.inner
16415     }
16416 }
16417 #[repr(C)]
16418 #[cfg_attr(feature = "debug", derive(Debug))]
16419 #[derive(Copy, Clone)]
16420 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceIDProperties.html>"]
16421 pub struct PhysicalDeviceIDProperties {
16422     pub s_type: StructureType,
16423     pub p_next: *mut c_void,
16424     pub device_uuid: [u8; UUID_SIZE],
16425     pub driver_uuid: [u8; UUID_SIZE],
16426     pub device_luid: [u8; LUID_SIZE],
16427     pub device_node_mask: u32,
16428     pub device_luid_valid: Bool32,
16429 }
16430 impl ::std::default::Default for PhysicalDeviceIDProperties {
16431     #[inline]
default() -> Self16432     fn default() -> Self {
16433         Self {
16434             s_type: Self::STRUCTURE_TYPE,
16435             p_next: ::std::ptr::null_mut(),
16436             device_uuid: unsafe { ::std::mem::zeroed() },
16437             driver_uuid: unsafe { ::std::mem::zeroed() },
16438             device_luid: unsafe { ::std::mem::zeroed() },
16439             device_node_mask: u32::default(),
16440             device_luid_valid: Bool32::default(),
16441         }
16442     }
16443 }
16444 unsafe impl TaggedStructure for PhysicalDeviceIDProperties {
16445     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_ID_PROPERTIES;
16446 }
16447 impl PhysicalDeviceIDProperties {
builder<'a>() -> PhysicalDeviceIDPropertiesBuilder<'a>16448     pub fn builder<'a>() -> PhysicalDeviceIDPropertiesBuilder<'a> {
16449         PhysicalDeviceIDPropertiesBuilder {
16450             inner: Self::default(),
16451             marker: ::std::marker::PhantomData,
16452         }
16453     }
16454 }
16455 #[repr(transparent)]
16456 pub struct PhysicalDeviceIDPropertiesBuilder<'a> {
16457     inner: PhysicalDeviceIDProperties,
16458     marker: ::std::marker::PhantomData<&'a ()>,
16459 }
16460 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceIDPropertiesBuilder<'_> {}
16461 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceIDProperties {}
16462 impl<'a> ::std::ops::Deref for PhysicalDeviceIDPropertiesBuilder<'a> {
16463     type Target = PhysicalDeviceIDProperties;
deref(&self) -> &Self::Target16464     fn deref(&self) -> &Self::Target {
16465         &self.inner
16466     }
16467 }
16468 impl<'a> ::std::ops::DerefMut for PhysicalDeviceIDPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target16469     fn deref_mut(&mut self) -> &mut Self::Target {
16470         &mut self.inner
16471     }
16472 }
16473 impl<'a> PhysicalDeviceIDPropertiesBuilder<'a> {
16474     #[inline]
device_uuid(mut self, device_uuid: [u8; UUID_SIZE]) -> Self16475     pub fn device_uuid(mut self, device_uuid: [u8; UUID_SIZE]) -> Self {
16476         self.inner.device_uuid = device_uuid;
16477         self
16478     }
16479     #[inline]
driver_uuid(mut self, driver_uuid: [u8; UUID_SIZE]) -> Self16480     pub fn driver_uuid(mut self, driver_uuid: [u8; UUID_SIZE]) -> Self {
16481         self.inner.driver_uuid = driver_uuid;
16482         self
16483     }
16484     #[inline]
device_luid(mut self, device_luid: [u8; LUID_SIZE]) -> Self16485     pub fn device_luid(mut self, device_luid: [u8; LUID_SIZE]) -> Self {
16486         self.inner.device_luid = device_luid;
16487         self
16488     }
16489     #[inline]
device_node_mask(mut self, device_node_mask: u32) -> Self16490     pub fn device_node_mask(mut self, device_node_mask: u32) -> Self {
16491         self.inner.device_node_mask = device_node_mask;
16492         self
16493     }
16494     #[inline]
device_luid_valid(mut self, device_luid_valid: bool) -> Self16495     pub fn device_luid_valid(mut self, device_luid_valid: bool) -> Self {
16496         self.inner.device_luid_valid = device_luid_valid.into();
16497         self
16498     }
16499     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16500     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16501     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceIDProperties16502     pub fn build(self) -> PhysicalDeviceIDProperties {
16503         self.inner
16504     }
16505 }
16506 #[repr(C)]
16507 #[cfg_attr(feature = "debug", derive(Debug))]
16508 #[derive(Copy, Clone)]
16509 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryImageCreateInfo.html>"]
16510 pub struct ExternalMemoryImageCreateInfo {
16511     pub s_type: StructureType,
16512     pub p_next: *const c_void,
16513     pub handle_types: ExternalMemoryHandleTypeFlags,
16514 }
16515 impl ::std::default::Default for ExternalMemoryImageCreateInfo {
16516     #[inline]
default() -> Self16517     fn default() -> Self {
16518         Self {
16519             s_type: Self::STRUCTURE_TYPE,
16520             p_next: ::std::ptr::null(),
16521             handle_types: ExternalMemoryHandleTypeFlags::default(),
16522         }
16523     }
16524 }
16525 unsafe impl TaggedStructure for ExternalMemoryImageCreateInfo {
16526     const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_MEMORY_IMAGE_CREATE_INFO;
16527 }
16528 impl ExternalMemoryImageCreateInfo {
builder<'a>() -> ExternalMemoryImageCreateInfoBuilder<'a>16529     pub fn builder<'a>() -> ExternalMemoryImageCreateInfoBuilder<'a> {
16530         ExternalMemoryImageCreateInfoBuilder {
16531             inner: Self::default(),
16532             marker: ::std::marker::PhantomData,
16533         }
16534     }
16535 }
16536 #[repr(transparent)]
16537 pub struct ExternalMemoryImageCreateInfoBuilder<'a> {
16538     inner: ExternalMemoryImageCreateInfo,
16539     marker: ::std::marker::PhantomData<&'a ()>,
16540 }
16541 unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoBuilder<'_> {}
16542 unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfo {}
16543 impl<'a> ::std::ops::Deref for ExternalMemoryImageCreateInfoBuilder<'a> {
16544     type Target = ExternalMemoryImageCreateInfo;
deref(&self) -> &Self::Target16545     fn deref(&self) -> &Self::Target {
16546         &self.inner
16547     }
16548 }
16549 impl<'a> ::std::ops::DerefMut for ExternalMemoryImageCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target16550     fn deref_mut(&mut self) -> &mut Self::Target {
16551         &mut self.inner
16552     }
16553 }
16554 impl<'a> ExternalMemoryImageCreateInfoBuilder<'a> {
16555     #[inline]
handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlags) -> Self16556     pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlags) -> Self {
16557         self.inner.handle_types = handle_types;
16558         self
16559     }
16560     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16561     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16562     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExternalMemoryImageCreateInfo16563     pub fn build(self) -> ExternalMemoryImageCreateInfo {
16564         self.inner
16565     }
16566 }
16567 #[repr(C)]
16568 #[cfg_attr(feature = "debug", derive(Debug))]
16569 #[derive(Copy, Clone)]
16570 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryBufferCreateInfo.html>"]
16571 pub struct ExternalMemoryBufferCreateInfo {
16572     pub s_type: StructureType,
16573     pub p_next: *const c_void,
16574     pub handle_types: ExternalMemoryHandleTypeFlags,
16575 }
16576 impl ::std::default::Default for ExternalMemoryBufferCreateInfo {
16577     #[inline]
default() -> Self16578     fn default() -> Self {
16579         Self {
16580             s_type: Self::STRUCTURE_TYPE,
16581             p_next: ::std::ptr::null(),
16582             handle_types: ExternalMemoryHandleTypeFlags::default(),
16583         }
16584     }
16585 }
16586 unsafe impl TaggedStructure for ExternalMemoryBufferCreateInfo {
16587     const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_MEMORY_BUFFER_CREATE_INFO;
16588 }
16589 impl ExternalMemoryBufferCreateInfo {
builder<'a>() -> ExternalMemoryBufferCreateInfoBuilder<'a>16590     pub fn builder<'a>() -> ExternalMemoryBufferCreateInfoBuilder<'a> {
16591         ExternalMemoryBufferCreateInfoBuilder {
16592             inner: Self::default(),
16593             marker: ::std::marker::PhantomData,
16594         }
16595     }
16596 }
16597 #[repr(transparent)]
16598 pub struct ExternalMemoryBufferCreateInfoBuilder<'a> {
16599     inner: ExternalMemoryBufferCreateInfo,
16600     marker: ::std::marker::PhantomData<&'a ()>,
16601 }
16602 unsafe impl ExtendsBufferCreateInfo for ExternalMemoryBufferCreateInfoBuilder<'_> {}
16603 unsafe impl ExtendsBufferCreateInfo for ExternalMemoryBufferCreateInfo {}
16604 impl<'a> ::std::ops::Deref for ExternalMemoryBufferCreateInfoBuilder<'a> {
16605     type Target = ExternalMemoryBufferCreateInfo;
deref(&self) -> &Self::Target16606     fn deref(&self) -> &Self::Target {
16607         &self.inner
16608     }
16609 }
16610 impl<'a> ::std::ops::DerefMut for ExternalMemoryBufferCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target16611     fn deref_mut(&mut self) -> &mut Self::Target {
16612         &mut self.inner
16613     }
16614 }
16615 impl<'a> ExternalMemoryBufferCreateInfoBuilder<'a> {
16616     #[inline]
handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlags) -> Self16617     pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlags) -> Self {
16618         self.inner.handle_types = handle_types;
16619         self
16620     }
16621     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16622     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16623     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExternalMemoryBufferCreateInfo16624     pub fn build(self) -> ExternalMemoryBufferCreateInfo {
16625         self.inner
16626     }
16627 }
16628 #[repr(C)]
16629 #[cfg_attr(feature = "debug", derive(Debug))]
16630 #[derive(Copy, Clone)]
16631 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMemoryAllocateInfo.html>"]
16632 pub struct ExportMemoryAllocateInfo {
16633     pub s_type: StructureType,
16634     pub p_next: *const c_void,
16635     pub handle_types: ExternalMemoryHandleTypeFlags,
16636 }
16637 impl ::std::default::Default for ExportMemoryAllocateInfo {
16638     #[inline]
default() -> Self16639     fn default() -> Self {
16640         Self {
16641             s_type: Self::STRUCTURE_TYPE,
16642             p_next: ::std::ptr::null(),
16643             handle_types: ExternalMemoryHandleTypeFlags::default(),
16644         }
16645     }
16646 }
16647 unsafe impl TaggedStructure for ExportMemoryAllocateInfo {
16648     const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_MEMORY_ALLOCATE_INFO;
16649 }
16650 impl ExportMemoryAllocateInfo {
builder<'a>() -> ExportMemoryAllocateInfoBuilder<'a>16651     pub fn builder<'a>() -> ExportMemoryAllocateInfoBuilder<'a> {
16652         ExportMemoryAllocateInfoBuilder {
16653             inner: Self::default(),
16654             marker: ::std::marker::PhantomData,
16655         }
16656     }
16657 }
16658 #[repr(transparent)]
16659 pub struct ExportMemoryAllocateInfoBuilder<'a> {
16660     inner: ExportMemoryAllocateInfo,
16661     marker: ::std::marker::PhantomData<&'a ()>,
16662 }
16663 unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoBuilder<'_> {}
16664 unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfo {}
16665 impl<'a> ::std::ops::Deref for ExportMemoryAllocateInfoBuilder<'a> {
16666     type Target = ExportMemoryAllocateInfo;
deref(&self) -> &Self::Target16667     fn deref(&self) -> &Self::Target {
16668         &self.inner
16669     }
16670 }
16671 impl<'a> ::std::ops::DerefMut for ExportMemoryAllocateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target16672     fn deref_mut(&mut self) -> &mut Self::Target {
16673         &mut self.inner
16674     }
16675 }
16676 impl<'a> ExportMemoryAllocateInfoBuilder<'a> {
16677     #[inline]
handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlags) -> Self16678     pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlags) -> Self {
16679         self.inner.handle_types = handle_types;
16680         self
16681     }
16682     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16683     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16684     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExportMemoryAllocateInfo16685     pub fn build(self) -> ExportMemoryAllocateInfo {
16686         self.inner
16687     }
16688 }
16689 #[repr(C)]
16690 #[cfg_attr(feature = "debug", derive(Debug))]
16691 #[derive(Copy, Clone)]
16692 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMemoryWin32HandleInfoKHR.html>"]
16693 pub struct ImportMemoryWin32HandleInfoKHR {
16694     pub s_type: StructureType,
16695     pub p_next: *const c_void,
16696     pub handle_type: ExternalMemoryHandleTypeFlags,
16697     pub handle: HANDLE,
16698     pub name: LPCWSTR,
16699 }
16700 impl ::std::default::Default for ImportMemoryWin32HandleInfoKHR {
16701     #[inline]
default() -> Self16702     fn default() -> Self {
16703         Self {
16704             s_type: Self::STRUCTURE_TYPE,
16705             p_next: ::std::ptr::null(),
16706             handle_type: ExternalMemoryHandleTypeFlags::default(),
16707             handle: unsafe { ::std::mem::zeroed() },
16708             name: unsafe { ::std::mem::zeroed() },
16709         }
16710     }
16711 }
16712 unsafe impl TaggedStructure for ImportMemoryWin32HandleInfoKHR {
16713     const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
16714 }
16715 impl ImportMemoryWin32HandleInfoKHR {
builder<'a>() -> ImportMemoryWin32HandleInfoKHRBuilder<'a>16716     pub fn builder<'a>() -> ImportMemoryWin32HandleInfoKHRBuilder<'a> {
16717         ImportMemoryWin32HandleInfoKHRBuilder {
16718             inner: Self::default(),
16719             marker: ::std::marker::PhantomData,
16720         }
16721     }
16722 }
16723 #[repr(transparent)]
16724 pub struct ImportMemoryWin32HandleInfoKHRBuilder<'a> {
16725     inner: ImportMemoryWin32HandleInfoKHR,
16726     marker: ::std::marker::PhantomData<&'a ()>,
16727 }
16728 unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoKHRBuilder<'_> {}
16729 unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoKHR {}
16730 impl<'a> ::std::ops::Deref for ImportMemoryWin32HandleInfoKHRBuilder<'a> {
16731     type Target = ImportMemoryWin32HandleInfoKHR;
deref(&self) -> &Self::Target16732     fn deref(&self) -> &Self::Target {
16733         &self.inner
16734     }
16735 }
16736 impl<'a> ::std::ops::DerefMut for ImportMemoryWin32HandleInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target16737     fn deref_mut(&mut self) -> &mut Self::Target {
16738         &mut self.inner
16739     }
16740 }
16741 impl<'a> ImportMemoryWin32HandleInfoKHRBuilder<'a> {
16742     #[inline]
handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self16743     pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
16744         self.inner.handle_type = handle_type;
16745         self
16746     }
16747     #[inline]
handle(mut self, handle: HANDLE) -> Self16748     pub fn handle(mut self, handle: HANDLE) -> Self {
16749         self.inner.handle = handle;
16750         self
16751     }
16752     #[inline]
name(mut self, name: LPCWSTR) -> Self16753     pub fn name(mut self, name: LPCWSTR) -> Self {
16754         self.inner.name = name;
16755         self
16756     }
16757     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16758     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16759     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImportMemoryWin32HandleInfoKHR16760     pub fn build(self) -> ImportMemoryWin32HandleInfoKHR {
16761         self.inner
16762     }
16763 }
16764 #[repr(C)]
16765 #[cfg_attr(feature = "debug", derive(Debug))]
16766 #[derive(Copy, Clone)]
16767 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMemoryWin32HandleInfoKHR.html>"]
16768 pub struct ExportMemoryWin32HandleInfoKHR {
16769     pub s_type: StructureType,
16770     pub p_next: *const c_void,
16771     pub p_attributes: *const SECURITY_ATTRIBUTES,
16772     pub dw_access: DWORD,
16773     pub name: LPCWSTR,
16774 }
16775 impl ::std::default::Default for ExportMemoryWin32HandleInfoKHR {
16776     #[inline]
default() -> Self16777     fn default() -> Self {
16778         Self {
16779             s_type: Self::STRUCTURE_TYPE,
16780             p_next: ::std::ptr::null(),
16781             p_attributes: ::std::ptr::null(),
16782             dw_access: DWORD::default(),
16783             name: unsafe { ::std::mem::zeroed() },
16784         }
16785     }
16786 }
16787 unsafe impl TaggedStructure for ExportMemoryWin32HandleInfoKHR {
16788     const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
16789 }
16790 impl ExportMemoryWin32HandleInfoKHR {
builder<'a>() -> ExportMemoryWin32HandleInfoKHRBuilder<'a>16791     pub fn builder<'a>() -> ExportMemoryWin32HandleInfoKHRBuilder<'a> {
16792         ExportMemoryWin32HandleInfoKHRBuilder {
16793             inner: Self::default(),
16794             marker: ::std::marker::PhantomData,
16795         }
16796     }
16797 }
16798 #[repr(transparent)]
16799 pub struct ExportMemoryWin32HandleInfoKHRBuilder<'a> {
16800     inner: ExportMemoryWin32HandleInfoKHR,
16801     marker: ::std::marker::PhantomData<&'a ()>,
16802 }
16803 unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoKHRBuilder<'_> {}
16804 unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoKHR {}
16805 impl<'a> ::std::ops::Deref for ExportMemoryWin32HandleInfoKHRBuilder<'a> {
16806     type Target = ExportMemoryWin32HandleInfoKHR;
deref(&self) -> &Self::Target16807     fn deref(&self) -> &Self::Target {
16808         &self.inner
16809     }
16810 }
16811 impl<'a> ::std::ops::DerefMut for ExportMemoryWin32HandleInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target16812     fn deref_mut(&mut self) -> &mut Self::Target {
16813         &mut self.inner
16814     }
16815 }
16816 impl<'a> ExportMemoryWin32HandleInfoKHRBuilder<'a> {
16817     #[inline]
attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self16818     pub fn attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self {
16819         self.inner.p_attributes = attributes;
16820         self
16821     }
16822     #[inline]
dw_access(mut self, dw_access: DWORD) -> Self16823     pub fn dw_access(mut self, dw_access: DWORD) -> Self {
16824         self.inner.dw_access = dw_access;
16825         self
16826     }
16827     #[inline]
name(mut self, name: LPCWSTR) -> Self16828     pub fn name(mut self, name: LPCWSTR) -> Self {
16829         self.inner.name = name;
16830         self
16831     }
16832     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16833     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16834     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExportMemoryWin32HandleInfoKHR16835     pub fn build(self) -> ExportMemoryWin32HandleInfoKHR {
16836         self.inner
16837     }
16838 }
16839 #[repr(C)]
16840 #[cfg_attr(feature = "debug", derive(Debug))]
16841 #[derive(Copy, Clone)]
16842 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMemoryZirconHandleInfoFUCHSIA.html>"]
16843 pub struct ImportMemoryZirconHandleInfoFUCHSIA {
16844     pub s_type: StructureType,
16845     pub p_next: *const c_void,
16846     pub handle_type: ExternalMemoryHandleTypeFlags,
16847     pub handle: zx_handle_t,
16848 }
16849 impl ::std::default::Default for ImportMemoryZirconHandleInfoFUCHSIA {
16850     #[inline]
default() -> Self16851     fn default() -> Self {
16852         Self {
16853             s_type: Self::STRUCTURE_TYPE,
16854             p_next: ::std::ptr::null(),
16855             handle_type: ExternalMemoryHandleTypeFlags::default(),
16856             handle: zx_handle_t::default(),
16857         }
16858     }
16859 }
16860 unsafe impl TaggedStructure for ImportMemoryZirconHandleInfoFUCHSIA {
16861     const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA;
16862 }
16863 impl ImportMemoryZirconHandleInfoFUCHSIA {
builder<'a>() -> ImportMemoryZirconHandleInfoFUCHSIABuilder<'a>16864     pub fn builder<'a>() -> ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> {
16865         ImportMemoryZirconHandleInfoFUCHSIABuilder {
16866             inner: Self::default(),
16867             marker: ::std::marker::PhantomData,
16868         }
16869     }
16870 }
16871 #[repr(transparent)]
16872 pub struct ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> {
16873     inner: ImportMemoryZirconHandleInfoFUCHSIA,
16874     marker: ::std::marker::PhantomData<&'a ()>,
16875 }
16876 unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryZirconHandleInfoFUCHSIABuilder<'_> {}
16877 unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryZirconHandleInfoFUCHSIA {}
16878 impl<'a> ::std::ops::Deref for ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> {
16879     type Target = ImportMemoryZirconHandleInfoFUCHSIA;
deref(&self) -> &Self::Target16880     fn deref(&self) -> &Self::Target {
16881         &self.inner
16882     }
16883 }
16884 impl<'a> ::std::ops::DerefMut for ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target16885     fn deref_mut(&mut self) -> &mut Self::Target {
16886         &mut self.inner
16887     }
16888 }
16889 impl<'a> ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> {
16890     #[inline]
handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self16891     pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
16892         self.inner.handle_type = handle_type;
16893         self
16894     }
16895     #[inline]
handle(mut self, handle: zx_handle_t) -> Self16896     pub fn handle(mut self, handle: zx_handle_t) -> Self {
16897         self.inner.handle = handle;
16898         self
16899     }
16900     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16901     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16902     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImportMemoryZirconHandleInfoFUCHSIA16903     pub fn build(self) -> ImportMemoryZirconHandleInfoFUCHSIA {
16904         self.inner
16905     }
16906 }
16907 #[repr(C)]
16908 #[cfg_attr(feature = "debug", derive(Debug))]
16909 #[derive(Copy, Clone)]
16910 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryZirconHandlePropertiesFUCHSIA.html>"]
16911 pub struct MemoryZirconHandlePropertiesFUCHSIA {
16912     pub s_type: StructureType,
16913     pub p_next: *mut c_void,
16914     pub memory_type_bits: u32,
16915 }
16916 impl ::std::default::Default for MemoryZirconHandlePropertiesFUCHSIA {
16917     #[inline]
default() -> Self16918     fn default() -> Self {
16919         Self {
16920             s_type: Self::STRUCTURE_TYPE,
16921             p_next: ::std::ptr::null_mut(),
16922             memory_type_bits: u32::default(),
16923         }
16924     }
16925 }
16926 unsafe impl TaggedStructure for MemoryZirconHandlePropertiesFUCHSIA {
16927     const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA;
16928 }
16929 impl MemoryZirconHandlePropertiesFUCHSIA {
builder<'a>() -> MemoryZirconHandlePropertiesFUCHSIABuilder<'a>16930     pub fn builder<'a>() -> MemoryZirconHandlePropertiesFUCHSIABuilder<'a> {
16931         MemoryZirconHandlePropertiesFUCHSIABuilder {
16932             inner: Self::default(),
16933             marker: ::std::marker::PhantomData,
16934         }
16935     }
16936 }
16937 #[repr(transparent)]
16938 pub struct MemoryZirconHandlePropertiesFUCHSIABuilder<'a> {
16939     inner: MemoryZirconHandlePropertiesFUCHSIA,
16940     marker: ::std::marker::PhantomData<&'a ()>,
16941 }
16942 impl<'a> ::std::ops::Deref for MemoryZirconHandlePropertiesFUCHSIABuilder<'a> {
16943     type Target = MemoryZirconHandlePropertiesFUCHSIA;
deref(&self) -> &Self::Target16944     fn deref(&self) -> &Self::Target {
16945         &self.inner
16946     }
16947 }
16948 impl<'a> ::std::ops::DerefMut for MemoryZirconHandlePropertiesFUCHSIABuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target16949     fn deref_mut(&mut self) -> &mut Self::Target {
16950         &mut self.inner
16951     }
16952 }
16953 impl<'a> MemoryZirconHandlePropertiesFUCHSIABuilder<'a> {
16954     #[inline]
memory_type_bits(mut self, memory_type_bits: u32) -> Self16955     pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self {
16956         self.inner.memory_type_bits = memory_type_bits;
16957         self
16958     }
16959     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16960     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16961     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryZirconHandlePropertiesFUCHSIA16962     pub fn build(self) -> MemoryZirconHandlePropertiesFUCHSIA {
16963         self.inner
16964     }
16965 }
16966 #[repr(C)]
16967 #[cfg_attr(feature = "debug", derive(Debug))]
16968 #[derive(Copy, Clone)]
16969 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryGetZirconHandleInfoFUCHSIA.html>"]
16970 pub struct MemoryGetZirconHandleInfoFUCHSIA {
16971     pub s_type: StructureType,
16972     pub p_next: *const c_void,
16973     pub memory: DeviceMemory,
16974     pub handle_type: ExternalMemoryHandleTypeFlags,
16975 }
16976 impl ::std::default::Default for MemoryGetZirconHandleInfoFUCHSIA {
16977     #[inline]
default() -> Self16978     fn default() -> Self {
16979         Self {
16980             s_type: Self::STRUCTURE_TYPE,
16981             p_next: ::std::ptr::null(),
16982             memory: DeviceMemory::default(),
16983             handle_type: ExternalMemoryHandleTypeFlags::default(),
16984         }
16985     }
16986 }
16987 unsafe impl TaggedStructure for MemoryGetZirconHandleInfoFUCHSIA {
16988     const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA;
16989 }
16990 impl MemoryGetZirconHandleInfoFUCHSIA {
builder<'a>() -> MemoryGetZirconHandleInfoFUCHSIABuilder<'a>16991     pub fn builder<'a>() -> MemoryGetZirconHandleInfoFUCHSIABuilder<'a> {
16992         MemoryGetZirconHandleInfoFUCHSIABuilder {
16993             inner: Self::default(),
16994             marker: ::std::marker::PhantomData,
16995         }
16996     }
16997 }
16998 #[repr(transparent)]
16999 pub struct MemoryGetZirconHandleInfoFUCHSIABuilder<'a> {
17000     inner: MemoryGetZirconHandleInfoFUCHSIA,
17001     marker: ::std::marker::PhantomData<&'a ()>,
17002 }
17003 impl<'a> ::std::ops::Deref for MemoryGetZirconHandleInfoFUCHSIABuilder<'a> {
17004     type Target = MemoryGetZirconHandleInfoFUCHSIA;
deref(&self) -> &Self::Target17005     fn deref(&self) -> &Self::Target {
17006         &self.inner
17007     }
17008 }
17009 impl<'a> ::std::ops::DerefMut for MemoryGetZirconHandleInfoFUCHSIABuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target17010     fn deref_mut(&mut self) -> &mut Self::Target {
17011         &mut self.inner
17012     }
17013 }
17014 impl<'a> MemoryGetZirconHandleInfoFUCHSIABuilder<'a> {
17015     #[inline]
memory(mut self, memory: DeviceMemory) -> Self17016     pub fn memory(mut self, memory: DeviceMemory) -> Self {
17017         self.inner.memory = memory;
17018         self
17019     }
17020     #[inline]
handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self17021     pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
17022         self.inner.handle_type = handle_type;
17023         self
17024     }
17025     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17026     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17027     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryGetZirconHandleInfoFUCHSIA17028     pub fn build(self) -> MemoryGetZirconHandleInfoFUCHSIA {
17029         self.inner
17030     }
17031 }
17032 #[repr(C)]
17033 #[cfg_attr(feature = "debug", derive(Debug))]
17034 #[derive(Copy, Clone)]
17035 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryWin32HandlePropertiesKHR.html>"]
17036 pub struct MemoryWin32HandlePropertiesKHR {
17037     pub s_type: StructureType,
17038     pub p_next: *mut c_void,
17039     pub memory_type_bits: u32,
17040 }
17041 impl ::std::default::Default for MemoryWin32HandlePropertiesKHR {
17042     #[inline]
default() -> Self17043     fn default() -> Self {
17044         Self {
17045             s_type: Self::STRUCTURE_TYPE,
17046             p_next: ::std::ptr::null_mut(),
17047             memory_type_bits: u32::default(),
17048         }
17049     }
17050 }
17051 unsafe impl TaggedStructure for MemoryWin32HandlePropertiesKHR {
17052     const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_WIN32_HANDLE_PROPERTIES_KHR;
17053 }
17054 impl MemoryWin32HandlePropertiesKHR {
builder<'a>() -> MemoryWin32HandlePropertiesKHRBuilder<'a>17055     pub fn builder<'a>() -> MemoryWin32HandlePropertiesKHRBuilder<'a> {
17056         MemoryWin32HandlePropertiesKHRBuilder {
17057             inner: Self::default(),
17058             marker: ::std::marker::PhantomData,
17059         }
17060     }
17061 }
17062 #[repr(transparent)]
17063 pub struct MemoryWin32HandlePropertiesKHRBuilder<'a> {
17064     inner: MemoryWin32HandlePropertiesKHR,
17065     marker: ::std::marker::PhantomData<&'a ()>,
17066 }
17067 impl<'a> ::std::ops::Deref for MemoryWin32HandlePropertiesKHRBuilder<'a> {
17068     type Target = MemoryWin32HandlePropertiesKHR;
deref(&self) -> &Self::Target17069     fn deref(&self) -> &Self::Target {
17070         &self.inner
17071     }
17072 }
17073 impl<'a> ::std::ops::DerefMut for MemoryWin32HandlePropertiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target17074     fn deref_mut(&mut self) -> &mut Self::Target {
17075         &mut self.inner
17076     }
17077 }
17078 impl<'a> MemoryWin32HandlePropertiesKHRBuilder<'a> {
17079     #[inline]
memory_type_bits(mut self, memory_type_bits: u32) -> Self17080     pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self {
17081         self.inner.memory_type_bits = memory_type_bits;
17082         self
17083     }
17084     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17085     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17086     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryWin32HandlePropertiesKHR17087     pub fn build(self) -> MemoryWin32HandlePropertiesKHR {
17088         self.inner
17089     }
17090 }
17091 #[repr(C)]
17092 #[cfg_attr(feature = "debug", derive(Debug))]
17093 #[derive(Copy, Clone)]
17094 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryGetWin32HandleInfoKHR.html>"]
17095 pub struct MemoryGetWin32HandleInfoKHR {
17096     pub s_type: StructureType,
17097     pub p_next: *const c_void,
17098     pub memory: DeviceMemory,
17099     pub handle_type: ExternalMemoryHandleTypeFlags,
17100 }
17101 impl ::std::default::Default for MemoryGetWin32HandleInfoKHR {
17102     #[inline]
default() -> Self17103     fn default() -> Self {
17104         Self {
17105             s_type: Self::STRUCTURE_TYPE,
17106             p_next: ::std::ptr::null(),
17107             memory: DeviceMemory::default(),
17108             handle_type: ExternalMemoryHandleTypeFlags::default(),
17109         }
17110     }
17111 }
17112 unsafe impl TaggedStructure for MemoryGetWin32HandleInfoKHR {
17113     const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_GET_WIN32_HANDLE_INFO_KHR;
17114 }
17115 impl MemoryGetWin32HandleInfoKHR {
builder<'a>() -> MemoryGetWin32HandleInfoKHRBuilder<'a>17116     pub fn builder<'a>() -> MemoryGetWin32HandleInfoKHRBuilder<'a> {
17117         MemoryGetWin32HandleInfoKHRBuilder {
17118             inner: Self::default(),
17119             marker: ::std::marker::PhantomData,
17120         }
17121     }
17122 }
17123 #[repr(transparent)]
17124 pub struct MemoryGetWin32HandleInfoKHRBuilder<'a> {
17125     inner: MemoryGetWin32HandleInfoKHR,
17126     marker: ::std::marker::PhantomData<&'a ()>,
17127 }
17128 impl<'a> ::std::ops::Deref for MemoryGetWin32HandleInfoKHRBuilder<'a> {
17129     type Target = MemoryGetWin32HandleInfoKHR;
deref(&self) -> &Self::Target17130     fn deref(&self) -> &Self::Target {
17131         &self.inner
17132     }
17133 }
17134 impl<'a> ::std::ops::DerefMut for MemoryGetWin32HandleInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target17135     fn deref_mut(&mut self) -> &mut Self::Target {
17136         &mut self.inner
17137     }
17138 }
17139 impl<'a> MemoryGetWin32HandleInfoKHRBuilder<'a> {
17140     #[inline]
memory(mut self, memory: DeviceMemory) -> Self17141     pub fn memory(mut self, memory: DeviceMemory) -> Self {
17142         self.inner.memory = memory;
17143         self
17144     }
17145     #[inline]
handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self17146     pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
17147         self.inner.handle_type = handle_type;
17148         self
17149     }
17150     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17151     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17152     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryGetWin32HandleInfoKHR17153     pub fn build(self) -> MemoryGetWin32HandleInfoKHR {
17154         self.inner
17155     }
17156 }
17157 #[repr(C)]
17158 #[cfg_attr(feature = "debug", derive(Debug))]
17159 #[derive(Copy, Clone)]
17160 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMemoryFdInfoKHR.html>"]
17161 pub struct ImportMemoryFdInfoKHR {
17162     pub s_type: StructureType,
17163     pub p_next: *const c_void,
17164     pub handle_type: ExternalMemoryHandleTypeFlags,
17165     pub fd: c_int,
17166 }
17167 impl ::std::default::Default for ImportMemoryFdInfoKHR {
17168     #[inline]
default() -> Self17169     fn default() -> Self {
17170         Self {
17171             s_type: Self::STRUCTURE_TYPE,
17172             p_next: ::std::ptr::null(),
17173             handle_type: ExternalMemoryHandleTypeFlags::default(),
17174             fd: c_int::default(),
17175         }
17176     }
17177 }
17178 unsafe impl TaggedStructure for ImportMemoryFdInfoKHR {
17179     const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_MEMORY_FD_INFO_KHR;
17180 }
17181 impl ImportMemoryFdInfoKHR {
builder<'a>() -> ImportMemoryFdInfoKHRBuilder<'a>17182     pub fn builder<'a>() -> ImportMemoryFdInfoKHRBuilder<'a> {
17183         ImportMemoryFdInfoKHRBuilder {
17184             inner: Self::default(),
17185             marker: ::std::marker::PhantomData,
17186         }
17187     }
17188 }
17189 #[repr(transparent)]
17190 pub struct ImportMemoryFdInfoKHRBuilder<'a> {
17191     inner: ImportMemoryFdInfoKHR,
17192     marker: ::std::marker::PhantomData<&'a ()>,
17193 }
17194 unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryFdInfoKHRBuilder<'_> {}
17195 unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryFdInfoKHR {}
17196 impl<'a> ::std::ops::Deref for ImportMemoryFdInfoKHRBuilder<'a> {
17197     type Target = ImportMemoryFdInfoKHR;
deref(&self) -> &Self::Target17198     fn deref(&self) -> &Self::Target {
17199         &self.inner
17200     }
17201 }
17202 impl<'a> ::std::ops::DerefMut for ImportMemoryFdInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target17203     fn deref_mut(&mut self) -> &mut Self::Target {
17204         &mut self.inner
17205     }
17206 }
17207 impl<'a> ImportMemoryFdInfoKHRBuilder<'a> {
17208     #[inline]
handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self17209     pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
17210         self.inner.handle_type = handle_type;
17211         self
17212     }
17213     #[inline]
fd(mut self, fd: c_int) -> Self17214     pub fn fd(mut self, fd: c_int) -> Self {
17215         self.inner.fd = fd;
17216         self
17217     }
17218     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17219     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17220     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImportMemoryFdInfoKHR17221     pub fn build(self) -> ImportMemoryFdInfoKHR {
17222         self.inner
17223     }
17224 }
17225 #[repr(C)]
17226 #[cfg_attr(feature = "debug", derive(Debug))]
17227 #[derive(Copy, Clone)]
17228 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryFdPropertiesKHR.html>"]
17229 pub struct MemoryFdPropertiesKHR {
17230     pub s_type: StructureType,
17231     pub p_next: *mut c_void,
17232     pub memory_type_bits: u32,
17233 }
17234 impl ::std::default::Default for MemoryFdPropertiesKHR {
17235     #[inline]
default() -> Self17236     fn default() -> Self {
17237         Self {
17238             s_type: Self::STRUCTURE_TYPE,
17239             p_next: ::std::ptr::null_mut(),
17240             memory_type_bits: u32::default(),
17241         }
17242     }
17243 }
17244 unsafe impl TaggedStructure for MemoryFdPropertiesKHR {
17245     const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_FD_PROPERTIES_KHR;
17246 }
17247 impl MemoryFdPropertiesKHR {
builder<'a>() -> MemoryFdPropertiesKHRBuilder<'a>17248     pub fn builder<'a>() -> MemoryFdPropertiesKHRBuilder<'a> {
17249         MemoryFdPropertiesKHRBuilder {
17250             inner: Self::default(),
17251             marker: ::std::marker::PhantomData,
17252         }
17253     }
17254 }
17255 #[repr(transparent)]
17256 pub struct MemoryFdPropertiesKHRBuilder<'a> {
17257     inner: MemoryFdPropertiesKHR,
17258     marker: ::std::marker::PhantomData<&'a ()>,
17259 }
17260 impl<'a> ::std::ops::Deref for MemoryFdPropertiesKHRBuilder<'a> {
17261     type Target = MemoryFdPropertiesKHR;
deref(&self) -> &Self::Target17262     fn deref(&self) -> &Self::Target {
17263         &self.inner
17264     }
17265 }
17266 impl<'a> ::std::ops::DerefMut for MemoryFdPropertiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target17267     fn deref_mut(&mut self) -> &mut Self::Target {
17268         &mut self.inner
17269     }
17270 }
17271 impl<'a> MemoryFdPropertiesKHRBuilder<'a> {
17272     #[inline]
memory_type_bits(mut self, memory_type_bits: u32) -> Self17273     pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self {
17274         self.inner.memory_type_bits = memory_type_bits;
17275         self
17276     }
17277     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17278     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17279     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryFdPropertiesKHR17280     pub fn build(self) -> MemoryFdPropertiesKHR {
17281         self.inner
17282     }
17283 }
17284 #[repr(C)]
17285 #[cfg_attr(feature = "debug", derive(Debug))]
17286 #[derive(Copy, Clone)]
17287 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryGetFdInfoKHR.html>"]
17288 pub struct MemoryGetFdInfoKHR {
17289     pub s_type: StructureType,
17290     pub p_next: *const c_void,
17291     pub memory: DeviceMemory,
17292     pub handle_type: ExternalMemoryHandleTypeFlags,
17293 }
17294 impl ::std::default::Default for MemoryGetFdInfoKHR {
17295     #[inline]
default() -> Self17296     fn default() -> Self {
17297         Self {
17298             s_type: Self::STRUCTURE_TYPE,
17299             p_next: ::std::ptr::null(),
17300             memory: DeviceMemory::default(),
17301             handle_type: ExternalMemoryHandleTypeFlags::default(),
17302         }
17303     }
17304 }
17305 unsafe impl TaggedStructure for MemoryGetFdInfoKHR {
17306     const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_GET_FD_INFO_KHR;
17307 }
17308 impl MemoryGetFdInfoKHR {
builder<'a>() -> MemoryGetFdInfoKHRBuilder<'a>17309     pub fn builder<'a>() -> MemoryGetFdInfoKHRBuilder<'a> {
17310         MemoryGetFdInfoKHRBuilder {
17311             inner: Self::default(),
17312             marker: ::std::marker::PhantomData,
17313         }
17314     }
17315 }
17316 #[repr(transparent)]
17317 pub struct MemoryGetFdInfoKHRBuilder<'a> {
17318     inner: MemoryGetFdInfoKHR,
17319     marker: ::std::marker::PhantomData<&'a ()>,
17320 }
17321 impl<'a> ::std::ops::Deref for MemoryGetFdInfoKHRBuilder<'a> {
17322     type Target = MemoryGetFdInfoKHR;
deref(&self) -> &Self::Target17323     fn deref(&self) -> &Self::Target {
17324         &self.inner
17325     }
17326 }
17327 impl<'a> ::std::ops::DerefMut for MemoryGetFdInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target17328     fn deref_mut(&mut self) -> &mut Self::Target {
17329         &mut self.inner
17330     }
17331 }
17332 impl<'a> MemoryGetFdInfoKHRBuilder<'a> {
17333     #[inline]
memory(mut self, memory: DeviceMemory) -> Self17334     pub fn memory(mut self, memory: DeviceMemory) -> Self {
17335         self.inner.memory = memory;
17336         self
17337     }
17338     #[inline]
handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self17339     pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
17340         self.inner.handle_type = handle_type;
17341         self
17342     }
17343     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17344     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17345     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryGetFdInfoKHR17346     pub fn build(self) -> MemoryGetFdInfoKHR {
17347         self.inner
17348     }
17349 }
17350 #[repr(C)]
17351 #[cfg_attr(feature = "debug", derive(Debug))]
17352 #[derive(Copy, Clone)]
17353 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWin32KeyedMutexAcquireReleaseInfoKHR.html>"]
17354 pub struct Win32KeyedMutexAcquireReleaseInfoKHR {
17355     pub s_type: StructureType,
17356     pub p_next: *const c_void,
17357     pub acquire_count: u32,
17358     pub p_acquire_syncs: *const DeviceMemory,
17359     pub p_acquire_keys: *const u64,
17360     pub p_acquire_timeouts: *const u32,
17361     pub release_count: u32,
17362     pub p_release_syncs: *const DeviceMemory,
17363     pub p_release_keys: *const u64,
17364 }
17365 impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoKHR {
17366     #[inline]
default() -> Self17367     fn default() -> Self {
17368         Self {
17369             s_type: Self::STRUCTURE_TYPE,
17370             p_next: ::std::ptr::null(),
17371             acquire_count: u32::default(),
17372             p_acquire_syncs: ::std::ptr::null(),
17373             p_acquire_keys: ::std::ptr::null(),
17374             p_acquire_timeouts: ::std::ptr::null(),
17375             release_count: u32::default(),
17376             p_release_syncs: ::std::ptr::null(),
17377             p_release_keys: ::std::ptr::null(),
17378         }
17379     }
17380 }
17381 unsafe impl TaggedStructure for Win32KeyedMutexAcquireReleaseInfoKHR {
17382     const STRUCTURE_TYPE: StructureType = StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR;
17383 }
17384 impl Win32KeyedMutexAcquireReleaseInfoKHR {
builder<'a>() -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a>17385     pub fn builder<'a>() -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
17386         Win32KeyedMutexAcquireReleaseInfoKHRBuilder {
17387             inner: Self::default(),
17388             marker: ::std::marker::PhantomData,
17389         }
17390     }
17391 }
17392 #[repr(transparent)]
17393 pub struct Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
17394     inner: Win32KeyedMutexAcquireReleaseInfoKHR,
17395     marker: ::std::marker::PhantomData<&'a ()>,
17396 }
17397 unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'_> {}
17398 unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoKHR {}
17399 unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'_> {}
17400 unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoKHR {}
17401 impl<'a> ::std::ops::Deref for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
17402     type Target = Win32KeyedMutexAcquireReleaseInfoKHR;
deref(&self) -> &Self::Target17403     fn deref(&self) -> &Self::Target {
17404         &self.inner
17405     }
17406 }
17407 impl<'a> ::std::ops::DerefMut for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target17408     fn deref_mut(&mut self) -> &mut Self::Target {
17409         &mut self.inner
17410     }
17411 }
17412 impl<'a> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
17413     #[inline]
acquire_syncs(mut self, acquire_syncs: &'a [DeviceMemory]) -> Self17414     pub fn acquire_syncs(mut self, acquire_syncs: &'a [DeviceMemory]) -> Self {
17415         self.inner.acquire_count = acquire_syncs.len() as _;
17416         self.inner.p_acquire_syncs = acquire_syncs.as_ptr();
17417         self
17418     }
17419     #[inline]
acquire_keys(mut self, acquire_keys: &'a [u64]) -> Self17420     pub fn acquire_keys(mut self, acquire_keys: &'a [u64]) -> Self {
17421         self.inner.acquire_count = acquire_keys.len() as _;
17422         self.inner.p_acquire_keys = acquire_keys.as_ptr();
17423         self
17424     }
17425     #[inline]
acquire_timeouts(mut self, acquire_timeouts: &'a [u32]) -> Self17426     pub fn acquire_timeouts(mut self, acquire_timeouts: &'a [u32]) -> Self {
17427         self.inner.acquire_count = acquire_timeouts.len() as _;
17428         self.inner.p_acquire_timeouts = acquire_timeouts.as_ptr();
17429         self
17430     }
17431     #[inline]
release_syncs(mut self, release_syncs: &'a [DeviceMemory]) -> Self17432     pub fn release_syncs(mut self, release_syncs: &'a [DeviceMemory]) -> Self {
17433         self.inner.release_count = release_syncs.len() as _;
17434         self.inner.p_release_syncs = release_syncs.as_ptr();
17435         self
17436     }
17437     #[inline]
release_keys(mut self, release_keys: &'a [u64]) -> Self17438     pub fn release_keys(mut self, release_keys: &'a [u64]) -> Self {
17439         self.inner.release_count = release_keys.len() as _;
17440         self.inner.p_release_keys = release_keys.as_ptr();
17441         self
17442     }
17443     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17444     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17445     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> Win32KeyedMutexAcquireReleaseInfoKHR17446     pub fn build(self) -> Win32KeyedMutexAcquireReleaseInfoKHR {
17447         self.inner
17448     }
17449 }
17450 #[repr(C)]
17451 #[cfg_attr(feature = "debug", derive(Debug))]
17452 #[derive(Copy, Clone)]
17453 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalSemaphoreInfo.html>"]
17454 pub struct PhysicalDeviceExternalSemaphoreInfo {
17455     pub s_type: StructureType,
17456     pub p_next: *const c_void,
17457     pub handle_type: ExternalSemaphoreHandleTypeFlags,
17458 }
17459 impl ::std::default::Default for PhysicalDeviceExternalSemaphoreInfo {
17460     #[inline]
default() -> Self17461     fn default() -> Self {
17462         Self {
17463             s_type: Self::STRUCTURE_TYPE,
17464             p_next: ::std::ptr::null(),
17465             handle_type: ExternalSemaphoreHandleTypeFlags::default(),
17466         }
17467     }
17468 }
17469 unsafe impl TaggedStructure for PhysicalDeviceExternalSemaphoreInfo {
17470     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO;
17471 }
17472 impl PhysicalDeviceExternalSemaphoreInfo {
builder<'a>() -> PhysicalDeviceExternalSemaphoreInfoBuilder<'a>17473     pub fn builder<'a>() -> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
17474         PhysicalDeviceExternalSemaphoreInfoBuilder {
17475             inner: Self::default(),
17476             marker: ::std::marker::PhantomData,
17477         }
17478     }
17479 }
17480 #[repr(transparent)]
17481 pub struct PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
17482     inner: PhysicalDeviceExternalSemaphoreInfo,
17483     marker: ::std::marker::PhantomData<&'a ()>,
17484 }
17485 pub unsafe trait ExtendsPhysicalDeviceExternalSemaphoreInfo {}
17486 impl<'a> ::std::ops::Deref for PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
17487     type Target = PhysicalDeviceExternalSemaphoreInfo;
deref(&self) -> &Self::Target17488     fn deref(&self) -> &Self::Target {
17489         &self.inner
17490     }
17491 }
17492 impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target17493     fn deref_mut(&mut self) -> &mut Self::Target {
17494         &mut self.inner
17495     }
17496 }
17497 impl<'a> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
17498     #[inline]
handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self17499     pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self {
17500         self.inner.handle_type = handle_type;
17501         self
17502     }
17503     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
17504     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
17505     #[doc = r" valid extension structs can be pushed into the chain."]
17506     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
17507     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPhysicalDeviceExternalSemaphoreInfo>( mut self, next: &'a mut T, ) -> Self17508     pub fn push_next<T: ExtendsPhysicalDeviceExternalSemaphoreInfo>(
17509         mut self,
17510         next: &'a mut T,
17511     ) -> Self {
17512         unsafe {
17513             let next_ptr = <*const T>::cast(next);
17514             let last_next = ptr_chain_iter(next).last().unwrap();
17515             (*last_next).p_next = self.inner.p_next as _;
17516             self.inner.p_next = next_ptr;
17517         }
17518         self
17519     }
17520     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17521     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17522     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceExternalSemaphoreInfo17523     pub fn build(self) -> PhysicalDeviceExternalSemaphoreInfo {
17524         self.inner
17525     }
17526 }
17527 #[repr(C)]
17528 #[cfg_attr(feature = "debug", derive(Debug))]
17529 #[derive(Copy, Clone)]
17530 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalSemaphoreProperties.html>"]
17531 pub struct ExternalSemaphoreProperties {
17532     pub s_type: StructureType,
17533     pub p_next: *mut c_void,
17534     pub export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags,
17535     pub compatible_handle_types: ExternalSemaphoreHandleTypeFlags,
17536     pub external_semaphore_features: ExternalSemaphoreFeatureFlags,
17537 }
17538 impl ::std::default::Default for ExternalSemaphoreProperties {
17539     #[inline]
default() -> Self17540     fn default() -> Self {
17541         Self {
17542             s_type: Self::STRUCTURE_TYPE,
17543             p_next: ::std::ptr::null_mut(),
17544             export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags::default(),
17545             compatible_handle_types: ExternalSemaphoreHandleTypeFlags::default(),
17546             external_semaphore_features: ExternalSemaphoreFeatureFlags::default(),
17547         }
17548     }
17549 }
17550 unsafe impl TaggedStructure for ExternalSemaphoreProperties {
17551     const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_SEMAPHORE_PROPERTIES;
17552 }
17553 impl ExternalSemaphoreProperties {
builder<'a>() -> ExternalSemaphorePropertiesBuilder<'a>17554     pub fn builder<'a>() -> ExternalSemaphorePropertiesBuilder<'a> {
17555         ExternalSemaphorePropertiesBuilder {
17556             inner: Self::default(),
17557             marker: ::std::marker::PhantomData,
17558         }
17559     }
17560 }
17561 #[repr(transparent)]
17562 pub struct ExternalSemaphorePropertiesBuilder<'a> {
17563     inner: ExternalSemaphoreProperties,
17564     marker: ::std::marker::PhantomData<&'a ()>,
17565 }
17566 impl<'a> ::std::ops::Deref for ExternalSemaphorePropertiesBuilder<'a> {
17567     type Target = ExternalSemaphoreProperties;
deref(&self) -> &Self::Target17568     fn deref(&self) -> &Self::Target {
17569         &self.inner
17570     }
17571 }
17572 impl<'a> ::std::ops::DerefMut for ExternalSemaphorePropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target17573     fn deref_mut(&mut self) -> &mut Self::Target {
17574         &mut self.inner
17575     }
17576 }
17577 impl<'a> ExternalSemaphorePropertiesBuilder<'a> {
17578     #[inline]
export_from_imported_handle_types( mut self, export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags, ) -> Self17579     pub fn export_from_imported_handle_types(
17580         mut self,
17581         export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags,
17582     ) -> Self {
17583         self.inner.export_from_imported_handle_types = export_from_imported_handle_types;
17584         self
17585     }
17586     #[inline]
compatible_handle_types( mut self, compatible_handle_types: ExternalSemaphoreHandleTypeFlags, ) -> Self17587     pub fn compatible_handle_types(
17588         mut self,
17589         compatible_handle_types: ExternalSemaphoreHandleTypeFlags,
17590     ) -> Self {
17591         self.inner.compatible_handle_types = compatible_handle_types;
17592         self
17593     }
17594     #[inline]
external_semaphore_features( mut self, external_semaphore_features: ExternalSemaphoreFeatureFlags, ) -> Self17595     pub fn external_semaphore_features(
17596         mut self,
17597         external_semaphore_features: ExternalSemaphoreFeatureFlags,
17598     ) -> Self {
17599         self.inner.external_semaphore_features = external_semaphore_features;
17600         self
17601     }
17602     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17603     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17604     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExternalSemaphoreProperties17605     pub fn build(self) -> ExternalSemaphoreProperties {
17606         self.inner
17607     }
17608 }
17609 #[repr(C)]
17610 #[cfg_attr(feature = "debug", derive(Debug))]
17611 #[derive(Copy, Clone)]
17612 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportSemaphoreCreateInfo.html>"]
17613 pub struct ExportSemaphoreCreateInfo {
17614     pub s_type: StructureType,
17615     pub p_next: *const c_void,
17616     pub handle_types: ExternalSemaphoreHandleTypeFlags,
17617 }
17618 impl ::std::default::Default for ExportSemaphoreCreateInfo {
17619     #[inline]
default() -> Self17620     fn default() -> Self {
17621         Self {
17622             s_type: Self::STRUCTURE_TYPE,
17623             p_next: ::std::ptr::null(),
17624             handle_types: ExternalSemaphoreHandleTypeFlags::default(),
17625         }
17626     }
17627 }
17628 unsafe impl TaggedStructure for ExportSemaphoreCreateInfo {
17629     const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_SEMAPHORE_CREATE_INFO;
17630 }
17631 impl ExportSemaphoreCreateInfo {
builder<'a>() -> ExportSemaphoreCreateInfoBuilder<'a>17632     pub fn builder<'a>() -> ExportSemaphoreCreateInfoBuilder<'a> {
17633         ExportSemaphoreCreateInfoBuilder {
17634             inner: Self::default(),
17635             marker: ::std::marker::PhantomData,
17636         }
17637     }
17638 }
17639 #[repr(transparent)]
17640 pub struct ExportSemaphoreCreateInfoBuilder<'a> {
17641     inner: ExportSemaphoreCreateInfo,
17642     marker: ::std::marker::PhantomData<&'a ()>,
17643 }
17644 unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreCreateInfoBuilder<'_> {}
17645 unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreCreateInfo {}
17646 impl<'a> ::std::ops::Deref for ExportSemaphoreCreateInfoBuilder<'a> {
17647     type Target = ExportSemaphoreCreateInfo;
deref(&self) -> &Self::Target17648     fn deref(&self) -> &Self::Target {
17649         &self.inner
17650     }
17651 }
17652 impl<'a> ::std::ops::DerefMut for ExportSemaphoreCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target17653     fn deref_mut(&mut self) -> &mut Self::Target {
17654         &mut self.inner
17655     }
17656 }
17657 impl<'a> ExportSemaphoreCreateInfoBuilder<'a> {
17658     #[inline]
handle_types(mut self, handle_types: ExternalSemaphoreHandleTypeFlags) -> Self17659     pub fn handle_types(mut self, handle_types: ExternalSemaphoreHandleTypeFlags) -> Self {
17660         self.inner.handle_types = handle_types;
17661         self
17662     }
17663     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17664     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17665     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExportSemaphoreCreateInfo17666     pub fn build(self) -> ExportSemaphoreCreateInfo {
17667         self.inner
17668     }
17669 }
17670 #[repr(C)]
17671 #[cfg_attr(feature = "debug", derive(Debug))]
17672 #[derive(Copy, Clone)]
17673 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportSemaphoreWin32HandleInfoKHR.html>"]
17674 pub struct ImportSemaphoreWin32HandleInfoKHR {
17675     pub s_type: StructureType,
17676     pub p_next: *const c_void,
17677     pub semaphore: Semaphore,
17678     pub flags: SemaphoreImportFlags,
17679     pub handle_type: ExternalSemaphoreHandleTypeFlags,
17680     pub handle: HANDLE,
17681     pub name: LPCWSTR,
17682 }
17683 impl ::std::default::Default for ImportSemaphoreWin32HandleInfoKHR {
17684     #[inline]
default() -> Self17685     fn default() -> Self {
17686         Self {
17687             s_type: Self::STRUCTURE_TYPE,
17688             p_next: ::std::ptr::null(),
17689             semaphore: Semaphore::default(),
17690             flags: SemaphoreImportFlags::default(),
17691             handle_type: ExternalSemaphoreHandleTypeFlags::default(),
17692             handle: unsafe { ::std::mem::zeroed() },
17693             name: unsafe { ::std::mem::zeroed() },
17694         }
17695     }
17696 }
17697 unsafe impl TaggedStructure for ImportSemaphoreWin32HandleInfoKHR {
17698     const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR;
17699 }
17700 impl ImportSemaphoreWin32HandleInfoKHR {
builder<'a>() -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a>17701     pub fn builder<'a>() -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
17702         ImportSemaphoreWin32HandleInfoKHRBuilder {
17703             inner: Self::default(),
17704             marker: ::std::marker::PhantomData,
17705         }
17706     }
17707 }
17708 #[repr(transparent)]
17709 pub struct ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
17710     inner: ImportSemaphoreWin32HandleInfoKHR,
17711     marker: ::std::marker::PhantomData<&'a ()>,
17712 }
17713 impl<'a> ::std::ops::Deref for ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
17714     type Target = ImportSemaphoreWin32HandleInfoKHR;
deref(&self) -> &Self::Target17715     fn deref(&self) -> &Self::Target {
17716         &self.inner
17717     }
17718 }
17719 impl<'a> ::std::ops::DerefMut for ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target17720     fn deref_mut(&mut self) -> &mut Self::Target {
17721         &mut self.inner
17722     }
17723 }
17724 impl<'a> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
17725     #[inline]
semaphore(mut self, semaphore: Semaphore) -> Self17726     pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
17727         self.inner.semaphore = semaphore;
17728         self
17729     }
17730     #[inline]
flags(mut self, flags: SemaphoreImportFlags) -> Self17731     pub fn flags(mut self, flags: SemaphoreImportFlags) -> Self {
17732         self.inner.flags = flags;
17733         self
17734     }
17735     #[inline]
handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self17736     pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self {
17737         self.inner.handle_type = handle_type;
17738         self
17739     }
17740     #[inline]
handle(mut self, handle: HANDLE) -> Self17741     pub fn handle(mut self, handle: HANDLE) -> Self {
17742         self.inner.handle = handle;
17743         self
17744     }
17745     #[inline]
name(mut self, name: LPCWSTR) -> Self17746     pub fn name(mut self, name: LPCWSTR) -> Self {
17747         self.inner.name = name;
17748         self
17749     }
17750     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17751     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17752     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImportSemaphoreWin32HandleInfoKHR17753     pub fn build(self) -> ImportSemaphoreWin32HandleInfoKHR {
17754         self.inner
17755     }
17756 }
17757 #[repr(C)]
17758 #[cfg_attr(feature = "debug", derive(Debug))]
17759 #[derive(Copy, Clone)]
17760 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportSemaphoreWin32HandleInfoKHR.html>"]
17761 pub struct ExportSemaphoreWin32HandleInfoKHR {
17762     pub s_type: StructureType,
17763     pub p_next: *const c_void,
17764     pub p_attributes: *const SECURITY_ATTRIBUTES,
17765     pub dw_access: DWORD,
17766     pub name: LPCWSTR,
17767 }
17768 impl ::std::default::Default for ExportSemaphoreWin32HandleInfoKHR {
17769     #[inline]
default() -> Self17770     fn default() -> Self {
17771         Self {
17772             s_type: Self::STRUCTURE_TYPE,
17773             p_next: ::std::ptr::null(),
17774             p_attributes: ::std::ptr::null(),
17775             dw_access: DWORD::default(),
17776             name: unsafe { ::std::mem::zeroed() },
17777         }
17778     }
17779 }
17780 unsafe impl TaggedStructure for ExportSemaphoreWin32HandleInfoKHR {
17781     const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR;
17782 }
17783 impl ExportSemaphoreWin32HandleInfoKHR {
builder<'a>() -> ExportSemaphoreWin32HandleInfoKHRBuilder<'a>17784     pub fn builder<'a>() -> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
17785         ExportSemaphoreWin32HandleInfoKHRBuilder {
17786             inner: Self::default(),
17787             marker: ::std::marker::PhantomData,
17788         }
17789     }
17790 }
17791 #[repr(transparent)]
17792 pub struct ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
17793     inner: ExportSemaphoreWin32HandleInfoKHR,
17794     marker: ::std::marker::PhantomData<&'a ()>,
17795 }
17796 unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreWin32HandleInfoKHRBuilder<'_> {}
17797 unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreWin32HandleInfoKHR {}
17798 impl<'a> ::std::ops::Deref for ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
17799     type Target = ExportSemaphoreWin32HandleInfoKHR;
deref(&self) -> &Self::Target17800     fn deref(&self) -> &Self::Target {
17801         &self.inner
17802     }
17803 }
17804 impl<'a> ::std::ops::DerefMut for ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target17805     fn deref_mut(&mut self) -> &mut Self::Target {
17806         &mut self.inner
17807     }
17808 }
17809 impl<'a> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
17810     #[inline]
attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self17811     pub fn attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self {
17812         self.inner.p_attributes = attributes;
17813         self
17814     }
17815     #[inline]
dw_access(mut self, dw_access: DWORD) -> Self17816     pub fn dw_access(mut self, dw_access: DWORD) -> Self {
17817         self.inner.dw_access = dw_access;
17818         self
17819     }
17820     #[inline]
name(mut self, name: LPCWSTR) -> Self17821     pub fn name(mut self, name: LPCWSTR) -> Self {
17822         self.inner.name = name;
17823         self
17824     }
17825     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17826     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17827     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExportSemaphoreWin32HandleInfoKHR17828     pub fn build(self) -> ExportSemaphoreWin32HandleInfoKHR {
17829         self.inner
17830     }
17831 }
17832 #[repr(C)]
17833 #[cfg_attr(feature = "debug", derive(Debug))]
17834 #[derive(Copy, Clone)]
17835 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkD3D12FenceSubmitInfoKHR.html>"]
17836 pub struct D3D12FenceSubmitInfoKHR {
17837     pub s_type: StructureType,
17838     pub p_next: *const c_void,
17839     pub wait_semaphore_values_count: u32,
17840     pub p_wait_semaphore_values: *const u64,
17841     pub signal_semaphore_values_count: u32,
17842     pub p_signal_semaphore_values: *const u64,
17843 }
17844 impl ::std::default::Default for D3D12FenceSubmitInfoKHR {
17845     #[inline]
default() -> Self17846     fn default() -> Self {
17847         Self {
17848             s_type: Self::STRUCTURE_TYPE,
17849             p_next: ::std::ptr::null(),
17850             wait_semaphore_values_count: u32::default(),
17851             p_wait_semaphore_values: ::std::ptr::null(),
17852             signal_semaphore_values_count: u32::default(),
17853             p_signal_semaphore_values: ::std::ptr::null(),
17854         }
17855     }
17856 }
17857 unsafe impl TaggedStructure for D3D12FenceSubmitInfoKHR {
17858     const STRUCTURE_TYPE: StructureType = StructureType::D3D12_FENCE_SUBMIT_INFO_KHR;
17859 }
17860 impl D3D12FenceSubmitInfoKHR {
builder<'a>() -> D3D12FenceSubmitInfoKHRBuilder<'a>17861     pub fn builder<'a>() -> D3D12FenceSubmitInfoKHRBuilder<'a> {
17862         D3D12FenceSubmitInfoKHRBuilder {
17863             inner: Self::default(),
17864             marker: ::std::marker::PhantomData,
17865         }
17866     }
17867 }
17868 #[repr(transparent)]
17869 pub struct D3D12FenceSubmitInfoKHRBuilder<'a> {
17870     inner: D3D12FenceSubmitInfoKHR,
17871     marker: ::std::marker::PhantomData<&'a ()>,
17872 }
17873 unsafe impl ExtendsSubmitInfo for D3D12FenceSubmitInfoKHRBuilder<'_> {}
17874 unsafe impl ExtendsSubmitInfo for D3D12FenceSubmitInfoKHR {}
17875 impl<'a> ::std::ops::Deref for D3D12FenceSubmitInfoKHRBuilder<'a> {
17876     type Target = D3D12FenceSubmitInfoKHR;
deref(&self) -> &Self::Target17877     fn deref(&self) -> &Self::Target {
17878         &self.inner
17879     }
17880 }
17881 impl<'a> ::std::ops::DerefMut for D3D12FenceSubmitInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target17882     fn deref_mut(&mut self) -> &mut Self::Target {
17883         &mut self.inner
17884     }
17885 }
17886 impl<'a> D3D12FenceSubmitInfoKHRBuilder<'a> {
17887     #[inline]
wait_semaphore_values(mut self, wait_semaphore_values: &'a [u64]) -> Self17888     pub fn wait_semaphore_values(mut self, wait_semaphore_values: &'a [u64]) -> Self {
17889         self.inner.wait_semaphore_values_count = wait_semaphore_values.len() as _;
17890         self.inner.p_wait_semaphore_values = wait_semaphore_values.as_ptr();
17891         self
17892     }
17893     #[inline]
signal_semaphore_values(mut self, signal_semaphore_values: &'a [u64]) -> Self17894     pub fn signal_semaphore_values(mut self, signal_semaphore_values: &'a [u64]) -> Self {
17895         self.inner.signal_semaphore_values_count = signal_semaphore_values.len() as _;
17896         self.inner.p_signal_semaphore_values = signal_semaphore_values.as_ptr();
17897         self
17898     }
17899     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17900     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17901     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> D3D12FenceSubmitInfoKHR17902     pub fn build(self) -> D3D12FenceSubmitInfoKHR {
17903         self.inner
17904     }
17905 }
17906 #[repr(C)]
17907 #[cfg_attr(feature = "debug", derive(Debug))]
17908 #[derive(Copy, Clone)]
17909 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreGetWin32HandleInfoKHR.html>"]
17910 pub struct SemaphoreGetWin32HandleInfoKHR {
17911     pub s_type: StructureType,
17912     pub p_next: *const c_void,
17913     pub semaphore: Semaphore,
17914     pub handle_type: ExternalSemaphoreHandleTypeFlags,
17915 }
17916 impl ::std::default::Default for SemaphoreGetWin32HandleInfoKHR {
17917     #[inline]
default() -> Self17918     fn default() -> Self {
17919         Self {
17920             s_type: Self::STRUCTURE_TYPE,
17921             p_next: ::std::ptr::null(),
17922             semaphore: Semaphore::default(),
17923             handle_type: ExternalSemaphoreHandleTypeFlags::default(),
17924         }
17925     }
17926 }
17927 unsafe impl TaggedStructure for SemaphoreGetWin32HandleInfoKHR {
17928     const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR;
17929 }
17930 impl SemaphoreGetWin32HandleInfoKHR {
builder<'a>() -> SemaphoreGetWin32HandleInfoKHRBuilder<'a>17931     pub fn builder<'a>() -> SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
17932         SemaphoreGetWin32HandleInfoKHRBuilder {
17933             inner: Self::default(),
17934             marker: ::std::marker::PhantomData,
17935         }
17936     }
17937 }
17938 #[repr(transparent)]
17939 pub struct SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
17940     inner: SemaphoreGetWin32HandleInfoKHR,
17941     marker: ::std::marker::PhantomData<&'a ()>,
17942 }
17943 impl<'a> ::std::ops::Deref for SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
17944     type Target = SemaphoreGetWin32HandleInfoKHR;
deref(&self) -> &Self::Target17945     fn deref(&self) -> &Self::Target {
17946         &self.inner
17947     }
17948 }
17949 impl<'a> ::std::ops::DerefMut for SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target17950     fn deref_mut(&mut self) -> &mut Self::Target {
17951         &mut self.inner
17952     }
17953 }
17954 impl<'a> SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
17955     #[inline]
semaphore(mut self, semaphore: Semaphore) -> Self17956     pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
17957         self.inner.semaphore = semaphore;
17958         self
17959     }
17960     #[inline]
handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self17961     pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self {
17962         self.inner.handle_type = handle_type;
17963         self
17964     }
17965     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17966     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17967     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SemaphoreGetWin32HandleInfoKHR17968     pub fn build(self) -> SemaphoreGetWin32HandleInfoKHR {
17969         self.inner
17970     }
17971 }
17972 #[repr(C)]
17973 #[cfg_attr(feature = "debug", derive(Debug))]
17974 #[derive(Copy, Clone)]
17975 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportSemaphoreFdInfoKHR.html>"]
17976 pub struct ImportSemaphoreFdInfoKHR {
17977     pub s_type: StructureType,
17978     pub p_next: *const c_void,
17979     pub semaphore: Semaphore,
17980     pub flags: SemaphoreImportFlags,
17981     pub handle_type: ExternalSemaphoreHandleTypeFlags,
17982     pub fd: c_int,
17983 }
17984 impl ::std::default::Default for ImportSemaphoreFdInfoKHR {
17985     #[inline]
default() -> Self17986     fn default() -> Self {
17987         Self {
17988             s_type: Self::STRUCTURE_TYPE,
17989             p_next: ::std::ptr::null(),
17990             semaphore: Semaphore::default(),
17991             flags: SemaphoreImportFlags::default(),
17992             handle_type: ExternalSemaphoreHandleTypeFlags::default(),
17993             fd: c_int::default(),
17994         }
17995     }
17996 }
17997 unsafe impl TaggedStructure for ImportSemaphoreFdInfoKHR {
17998     const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_SEMAPHORE_FD_INFO_KHR;
17999 }
18000 impl ImportSemaphoreFdInfoKHR {
builder<'a>() -> ImportSemaphoreFdInfoKHRBuilder<'a>18001     pub fn builder<'a>() -> ImportSemaphoreFdInfoKHRBuilder<'a> {
18002         ImportSemaphoreFdInfoKHRBuilder {
18003             inner: Self::default(),
18004             marker: ::std::marker::PhantomData,
18005         }
18006     }
18007 }
18008 #[repr(transparent)]
18009 pub struct ImportSemaphoreFdInfoKHRBuilder<'a> {
18010     inner: ImportSemaphoreFdInfoKHR,
18011     marker: ::std::marker::PhantomData<&'a ()>,
18012 }
18013 impl<'a> ::std::ops::Deref for ImportSemaphoreFdInfoKHRBuilder<'a> {
18014     type Target = ImportSemaphoreFdInfoKHR;
deref(&self) -> &Self::Target18015     fn deref(&self) -> &Self::Target {
18016         &self.inner
18017     }
18018 }
18019 impl<'a> ::std::ops::DerefMut for ImportSemaphoreFdInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target18020     fn deref_mut(&mut self) -> &mut Self::Target {
18021         &mut self.inner
18022     }
18023 }
18024 impl<'a> ImportSemaphoreFdInfoKHRBuilder<'a> {
18025     #[inline]
semaphore(mut self, semaphore: Semaphore) -> Self18026     pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
18027         self.inner.semaphore = semaphore;
18028         self
18029     }
18030     #[inline]
flags(mut self, flags: SemaphoreImportFlags) -> Self18031     pub fn flags(mut self, flags: SemaphoreImportFlags) -> Self {
18032         self.inner.flags = flags;
18033         self
18034     }
18035     #[inline]
handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self18036     pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self {
18037         self.inner.handle_type = handle_type;
18038         self
18039     }
18040     #[inline]
fd(mut self, fd: c_int) -> Self18041     pub fn fd(mut self, fd: c_int) -> Self {
18042         self.inner.fd = fd;
18043         self
18044     }
18045     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18046     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18047     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImportSemaphoreFdInfoKHR18048     pub fn build(self) -> ImportSemaphoreFdInfoKHR {
18049         self.inner
18050     }
18051 }
18052 #[repr(C)]
18053 #[cfg_attr(feature = "debug", derive(Debug))]
18054 #[derive(Copy, Clone)]
18055 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreGetFdInfoKHR.html>"]
18056 pub struct SemaphoreGetFdInfoKHR {
18057     pub s_type: StructureType,
18058     pub p_next: *const c_void,
18059     pub semaphore: Semaphore,
18060     pub handle_type: ExternalSemaphoreHandleTypeFlags,
18061 }
18062 impl ::std::default::Default for SemaphoreGetFdInfoKHR {
18063     #[inline]
default() -> Self18064     fn default() -> Self {
18065         Self {
18066             s_type: Self::STRUCTURE_TYPE,
18067             p_next: ::std::ptr::null(),
18068             semaphore: Semaphore::default(),
18069             handle_type: ExternalSemaphoreHandleTypeFlags::default(),
18070         }
18071     }
18072 }
18073 unsafe impl TaggedStructure for SemaphoreGetFdInfoKHR {
18074     const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_GET_FD_INFO_KHR;
18075 }
18076 impl SemaphoreGetFdInfoKHR {
builder<'a>() -> SemaphoreGetFdInfoKHRBuilder<'a>18077     pub fn builder<'a>() -> SemaphoreGetFdInfoKHRBuilder<'a> {
18078         SemaphoreGetFdInfoKHRBuilder {
18079             inner: Self::default(),
18080             marker: ::std::marker::PhantomData,
18081         }
18082     }
18083 }
18084 #[repr(transparent)]
18085 pub struct SemaphoreGetFdInfoKHRBuilder<'a> {
18086     inner: SemaphoreGetFdInfoKHR,
18087     marker: ::std::marker::PhantomData<&'a ()>,
18088 }
18089 impl<'a> ::std::ops::Deref for SemaphoreGetFdInfoKHRBuilder<'a> {
18090     type Target = SemaphoreGetFdInfoKHR;
deref(&self) -> &Self::Target18091     fn deref(&self) -> &Self::Target {
18092         &self.inner
18093     }
18094 }
18095 impl<'a> ::std::ops::DerefMut for SemaphoreGetFdInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target18096     fn deref_mut(&mut self) -> &mut Self::Target {
18097         &mut self.inner
18098     }
18099 }
18100 impl<'a> SemaphoreGetFdInfoKHRBuilder<'a> {
18101     #[inline]
semaphore(mut self, semaphore: Semaphore) -> Self18102     pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
18103         self.inner.semaphore = semaphore;
18104         self
18105     }
18106     #[inline]
handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self18107     pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self {
18108         self.inner.handle_type = handle_type;
18109         self
18110     }
18111     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18112     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18113     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SemaphoreGetFdInfoKHR18114     pub fn build(self) -> SemaphoreGetFdInfoKHR {
18115         self.inner
18116     }
18117 }
18118 #[repr(C)]
18119 #[cfg_attr(feature = "debug", derive(Debug))]
18120 #[derive(Copy, Clone)]
18121 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportSemaphoreZirconHandleInfoFUCHSIA.html>"]
18122 pub struct ImportSemaphoreZirconHandleInfoFUCHSIA {
18123     pub s_type: StructureType,
18124     pub p_next: *const c_void,
18125     pub semaphore: Semaphore,
18126     pub flags: SemaphoreImportFlags,
18127     pub handle_type: ExternalSemaphoreHandleTypeFlags,
18128     pub zircon_handle: zx_handle_t,
18129 }
18130 impl ::std::default::Default for ImportSemaphoreZirconHandleInfoFUCHSIA {
18131     #[inline]
default() -> Self18132     fn default() -> Self {
18133         Self {
18134             s_type: Self::STRUCTURE_TYPE,
18135             p_next: ::std::ptr::null(),
18136             semaphore: Semaphore::default(),
18137             flags: SemaphoreImportFlags::default(),
18138             handle_type: ExternalSemaphoreHandleTypeFlags::default(),
18139             zircon_handle: zx_handle_t::default(),
18140         }
18141     }
18142 }
18143 unsafe impl TaggedStructure for ImportSemaphoreZirconHandleInfoFUCHSIA {
18144     const STRUCTURE_TYPE: StructureType =
18145         StructureType::IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA;
18146 }
18147 impl ImportSemaphoreZirconHandleInfoFUCHSIA {
builder<'a>() -> ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a>18148     pub fn builder<'a>() -> ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> {
18149         ImportSemaphoreZirconHandleInfoFUCHSIABuilder {
18150             inner: Self::default(),
18151             marker: ::std::marker::PhantomData,
18152         }
18153     }
18154 }
18155 #[repr(transparent)]
18156 pub struct ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> {
18157     inner: ImportSemaphoreZirconHandleInfoFUCHSIA,
18158     marker: ::std::marker::PhantomData<&'a ()>,
18159 }
18160 impl<'a> ::std::ops::Deref for ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> {
18161     type Target = ImportSemaphoreZirconHandleInfoFUCHSIA;
deref(&self) -> &Self::Target18162     fn deref(&self) -> &Self::Target {
18163         &self.inner
18164     }
18165 }
18166 impl<'a> ::std::ops::DerefMut for ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target18167     fn deref_mut(&mut self) -> &mut Self::Target {
18168         &mut self.inner
18169     }
18170 }
18171 impl<'a> ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> {
18172     #[inline]
semaphore(mut self, semaphore: Semaphore) -> Self18173     pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
18174         self.inner.semaphore = semaphore;
18175         self
18176     }
18177     #[inline]
flags(mut self, flags: SemaphoreImportFlags) -> Self18178     pub fn flags(mut self, flags: SemaphoreImportFlags) -> Self {
18179         self.inner.flags = flags;
18180         self
18181     }
18182     #[inline]
handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self18183     pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self {
18184         self.inner.handle_type = handle_type;
18185         self
18186     }
18187     #[inline]
zircon_handle(mut self, zircon_handle: zx_handle_t) -> Self18188     pub fn zircon_handle(mut self, zircon_handle: zx_handle_t) -> Self {
18189         self.inner.zircon_handle = zircon_handle;
18190         self
18191     }
18192     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18193     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18194     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImportSemaphoreZirconHandleInfoFUCHSIA18195     pub fn build(self) -> ImportSemaphoreZirconHandleInfoFUCHSIA {
18196         self.inner
18197     }
18198 }
18199 #[repr(C)]
18200 #[cfg_attr(feature = "debug", derive(Debug))]
18201 #[derive(Copy, Clone)]
18202 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreGetZirconHandleInfoFUCHSIA.html>"]
18203 pub struct SemaphoreGetZirconHandleInfoFUCHSIA {
18204     pub s_type: StructureType,
18205     pub p_next: *const c_void,
18206     pub semaphore: Semaphore,
18207     pub handle_type: ExternalSemaphoreHandleTypeFlags,
18208 }
18209 impl ::std::default::Default for SemaphoreGetZirconHandleInfoFUCHSIA {
18210     #[inline]
default() -> Self18211     fn default() -> Self {
18212         Self {
18213             s_type: Self::STRUCTURE_TYPE,
18214             p_next: ::std::ptr::null(),
18215             semaphore: Semaphore::default(),
18216             handle_type: ExternalSemaphoreHandleTypeFlags::default(),
18217         }
18218     }
18219 }
18220 unsafe impl TaggedStructure for SemaphoreGetZirconHandleInfoFUCHSIA {
18221     const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA;
18222 }
18223 impl SemaphoreGetZirconHandleInfoFUCHSIA {
builder<'a>() -> SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a>18224     pub fn builder<'a>() -> SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> {
18225         SemaphoreGetZirconHandleInfoFUCHSIABuilder {
18226             inner: Self::default(),
18227             marker: ::std::marker::PhantomData,
18228         }
18229     }
18230 }
18231 #[repr(transparent)]
18232 pub struct SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> {
18233     inner: SemaphoreGetZirconHandleInfoFUCHSIA,
18234     marker: ::std::marker::PhantomData<&'a ()>,
18235 }
18236 impl<'a> ::std::ops::Deref for SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> {
18237     type Target = SemaphoreGetZirconHandleInfoFUCHSIA;
deref(&self) -> &Self::Target18238     fn deref(&self) -> &Self::Target {
18239         &self.inner
18240     }
18241 }
18242 impl<'a> ::std::ops::DerefMut for SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target18243     fn deref_mut(&mut self) -> &mut Self::Target {
18244         &mut self.inner
18245     }
18246 }
18247 impl<'a> SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> {
18248     #[inline]
semaphore(mut self, semaphore: Semaphore) -> Self18249     pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
18250         self.inner.semaphore = semaphore;
18251         self
18252     }
18253     #[inline]
handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self18254     pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self {
18255         self.inner.handle_type = handle_type;
18256         self
18257     }
18258     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18259     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18260     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SemaphoreGetZirconHandleInfoFUCHSIA18261     pub fn build(self) -> SemaphoreGetZirconHandleInfoFUCHSIA {
18262         self.inner
18263     }
18264 }
18265 #[repr(C)]
18266 #[cfg_attr(feature = "debug", derive(Debug))]
18267 #[derive(Copy, Clone)]
18268 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalFenceInfo.html>"]
18269 pub struct PhysicalDeviceExternalFenceInfo {
18270     pub s_type: StructureType,
18271     pub p_next: *const c_void,
18272     pub handle_type: ExternalFenceHandleTypeFlags,
18273 }
18274 impl ::std::default::Default for PhysicalDeviceExternalFenceInfo {
18275     #[inline]
default() -> Self18276     fn default() -> Self {
18277         Self {
18278             s_type: Self::STRUCTURE_TYPE,
18279             p_next: ::std::ptr::null(),
18280             handle_type: ExternalFenceHandleTypeFlags::default(),
18281         }
18282     }
18283 }
18284 unsafe impl TaggedStructure for PhysicalDeviceExternalFenceInfo {
18285     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO;
18286 }
18287 impl PhysicalDeviceExternalFenceInfo {
builder<'a>() -> PhysicalDeviceExternalFenceInfoBuilder<'a>18288     pub fn builder<'a>() -> PhysicalDeviceExternalFenceInfoBuilder<'a> {
18289         PhysicalDeviceExternalFenceInfoBuilder {
18290             inner: Self::default(),
18291             marker: ::std::marker::PhantomData,
18292         }
18293     }
18294 }
18295 #[repr(transparent)]
18296 pub struct PhysicalDeviceExternalFenceInfoBuilder<'a> {
18297     inner: PhysicalDeviceExternalFenceInfo,
18298     marker: ::std::marker::PhantomData<&'a ()>,
18299 }
18300 impl<'a> ::std::ops::Deref for PhysicalDeviceExternalFenceInfoBuilder<'a> {
18301     type Target = PhysicalDeviceExternalFenceInfo;
deref(&self) -> &Self::Target18302     fn deref(&self) -> &Self::Target {
18303         &self.inner
18304     }
18305 }
18306 impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalFenceInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target18307     fn deref_mut(&mut self) -> &mut Self::Target {
18308         &mut self.inner
18309     }
18310 }
18311 impl<'a> PhysicalDeviceExternalFenceInfoBuilder<'a> {
18312     #[inline]
handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self18313     pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self {
18314         self.inner.handle_type = handle_type;
18315         self
18316     }
18317     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18318     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18319     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceExternalFenceInfo18320     pub fn build(self) -> PhysicalDeviceExternalFenceInfo {
18321         self.inner
18322     }
18323 }
18324 #[repr(C)]
18325 #[cfg_attr(feature = "debug", derive(Debug))]
18326 #[derive(Copy, Clone)]
18327 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalFenceProperties.html>"]
18328 pub struct ExternalFenceProperties {
18329     pub s_type: StructureType,
18330     pub p_next: *mut c_void,
18331     pub export_from_imported_handle_types: ExternalFenceHandleTypeFlags,
18332     pub compatible_handle_types: ExternalFenceHandleTypeFlags,
18333     pub external_fence_features: ExternalFenceFeatureFlags,
18334 }
18335 impl ::std::default::Default for ExternalFenceProperties {
18336     #[inline]
default() -> Self18337     fn default() -> Self {
18338         Self {
18339             s_type: Self::STRUCTURE_TYPE,
18340             p_next: ::std::ptr::null_mut(),
18341             export_from_imported_handle_types: ExternalFenceHandleTypeFlags::default(),
18342             compatible_handle_types: ExternalFenceHandleTypeFlags::default(),
18343             external_fence_features: ExternalFenceFeatureFlags::default(),
18344         }
18345     }
18346 }
18347 unsafe impl TaggedStructure for ExternalFenceProperties {
18348     const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_FENCE_PROPERTIES;
18349 }
18350 impl ExternalFenceProperties {
builder<'a>() -> ExternalFencePropertiesBuilder<'a>18351     pub fn builder<'a>() -> ExternalFencePropertiesBuilder<'a> {
18352         ExternalFencePropertiesBuilder {
18353             inner: Self::default(),
18354             marker: ::std::marker::PhantomData,
18355         }
18356     }
18357 }
18358 #[repr(transparent)]
18359 pub struct ExternalFencePropertiesBuilder<'a> {
18360     inner: ExternalFenceProperties,
18361     marker: ::std::marker::PhantomData<&'a ()>,
18362 }
18363 impl<'a> ::std::ops::Deref for ExternalFencePropertiesBuilder<'a> {
18364     type Target = ExternalFenceProperties;
deref(&self) -> &Self::Target18365     fn deref(&self) -> &Self::Target {
18366         &self.inner
18367     }
18368 }
18369 impl<'a> ::std::ops::DerefMut for ExternalFencePropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target18370     fn deref_mut(&mut self) -> &mut Self::Target {
18371         &mut self.inner
18372     }
18373 }
18374 impl<'a> ExternalFencePropertiesBuilder<'a> {
18375     #[inline]
export_from_imported_handle_types( mut self, export_from_imported_handle_types: ExternalFenceHandleTypeFlags, ) -> Self18376     pub fn export_from_imported_handle_types(
18377         mut self,
18378         export_from_imported_handle_types: ExternalFenceHandleTypeFlags,
18379     ) -> Self {
18380         self.inner.export_from_imported_handle_types = export_from_imported_handle_types;
18381         self
18382     }
18383     #[inline]
compatible_handle_types( mut self, compatible_handle_types: ExternalFenceHandleTypeFlags, ) -> Self18384     pub fn compatible_handle_types(
18385         mut self,
18386         compatible_handle_types: ExternalFenceHandleTypeFlags,
18387     ) -> Self {
18388         self.inner.compatible_handle_types = compatible_handle_types;
18389         self
18390     }
18391     #[inline]
external_fence_features( mut self, external_fence_features: ExternalFenceFeatureFlags, ) -> Self18392     pub fn external_fence_features(
18393         mut self,
18394         external_fence_features: ExternalFenceFeatureFlags,
18395     ) -> Self {
18396         self.inner.external_fence_features = external_fence_features;
18397         self
18398     }
18399     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18400     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18401     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExternalFenceProperties18402     pub fn build(self) -> ExternalFenceProperties {
18403         self.inner
18404     }
18405 }
18406 #[repr(C)]
18407 #[cfg_attr(feature = "debug", derive(Debug))]
18408 #[derive(Copy, Clone)]
18409 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportFenceCreateInfo.html>"]
18410 pub struct ExportFenceCreateInfo {
18411     pub s_type: StructureType,
18412     pub p_next: *const c_void,
18413     pub handle_types: ExternalFenceHandleTypeFlags,
18414 }
18415 impl ::std::default::Default for ExportFenceCreateInfo {
18416     #[inline]
default() -> Self18417     fn default() -> Self {
18418         Self {
18419             s_type: Self::STRUCTURE_TYPE,
18420             p_next: ::std::ptr::null(),
18421             handle_types: ExternalFenceHandleTypeFlags::default(),
18422         }
18423     }
18424 }
18425 unsafe impl TaggedStructure for ExportFenceCreateInfo {
18426     const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_FENCE_CREATE_INFO;
18427 }
18428 impl ExportFenceCreateInfo {
builder<'a>() -> ExportFenceCreateInfoBuilder<'a>18429     pub fn builder<'a>() -> ExportFenceCreateInfoBuilder<'a> {
18430         ExportFenceCreateInfoBuilder {
18431             inner: Self::default(),
18432             marker: ::std::marker::PhantomData,
18433         }
18434     }
18435 }
18436 #[repr(transparent)]
18437 pub struct ExportFenceCreateInfoBuilder<'a> {
18438     inner: ExportFenceCreateInfo,
18439     marker: ::std::marker::PhantomData<&'a ()>,
18440 }
18441 unsafe impl ExtendsFenceCreateInfo for ExportFenceCreateInfoBuilder<'_> {}
18442 unsafe impl ExtendsFenceCreateInfo for ExportFenceCreateInfo {}
18443 impl<'a> ::std::ops::Deref for ExportFenceCreateInfoBuilder<'a> {
18444     type Target = ExportFenceCreateInfo;
deref(&self) -> &Self::Target18445     fn deref(&self) -> &Self::Target {
18446         &self.inner
18447     }
18448 }
18449 impl<'a> ::std::ops::DerefMut for ExportFenceCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target18450     fn deref_mut(&mut self) -> &mut Self::Target {
18451         &mut self.inner
18452     }
18453 }
18454 impl<'a> ExportFenceCreateInfoBuilder<'a> {
18455     #[inline]
handle_types(mut self, handle_types: ExternalFenceHandleTypeFlags) -> Self18456     pub fn handle_types(mut self, handle_types: ExternalFenceHandleTypeFlags) -> Self {
18457         self.inner.handle_types = handle_types;
18458         self
18459     }
18460     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18461     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18462     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExportFenceCreateInfo18463     pub fn build(self) -> ExportFenceCreateInfo {
18464         self.inner
18465     }
18466 }
18467 #[repr(C)]
18468 #[cfg_attr(feature = "debug", derive(Debug))]
18469 #[derive(Copy, Clone)]
18470 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportFenceWin32HandleInfoKHR.html>"]
18471 pub struct ImportFenceWin32HandleInfoKHR {
18472     pub s_type: StructureType,
18473     pub p_next: *const c_void,
18474     pub fence: Fence,
18475     pub flags: FenceImportFlags,
18476     pub handle_type: ExternalFenceHandleTypeFlags,
18477     pub handle: HANDLE,
18478     pub name: LPCWSTR,
18479 }
18480 impl ::std::default::Default for ImportFenceWin32HandleInfoKHR {
18481     #[inline]
default() -> Self18482     fn default() -> Self {
18483         Self {
18484             s_type: Self::STRUCTURE_TYPE,
18485             p_next: ::std::ptr::null(),
18486             fence: Fence::default(),
18487             flags: FenceImportFlags::default(),
18488             handle_type: ExternalFenceHandleTypeFlags::default(),
18489             handle: unsafe { ::std::mem::zeroed() },
18490             name: unsafe { ::std::mem::zeroed() },
18491         }
18492     }
18493 }
18494 unsafe impl TaggedStructure for ImportFenceWin32HandleInfoKHR {
18495     const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_FENCE_WIN32_HANDLE_INFO_KHR;
18496 }
18497 impl ImportFenceWin32HandleInfoKHR {
builder<'a>() -> ImportFenceWin32HandleInfoKHRBuilder<'a>18498     pub fn builder<'a>() -> ImportFenceWin32HandleInfoKHRBuilder<'a> {
18499         ImportFenceWin32HandleInfoKHRBuilder {
18500             inner: Self::default(),
18501             marker: ::std::marker::PhantomData,
18502         }
18503     }
18504 }
18505 #[repr(transparent)]
18506 pub struct ImportFenceWin32HandleInfoKHRBuilder<'a> {
18507     inner: ImportFenceWin32HandleInfoKHR,
18508     marker: ::std::marker::PhantomData<&'a ()>,
18509 }
18510 impl<'a> ::std::ops::Deref for ImportFenceWin32HandleInfoKHRBuilder<'a> {
18511     type Target = ImportFenceWin32HandleInfoKHR;
deref(&self) -> &Self::Target18512     fn deref(&self) -> &Self::Target {
18513         &self.inner
18514     }
18515 }
18516 impl<'a> ::std::ops::DerefMut for ImportFenceWin32HandleInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target18517     fn deref_mut(&mut self) -> &mut Self::Target {
18518         &mut self.inner
18519     }
18520 }
18521 impl<'a> ImportFenceWin32HandleInfoKHRBuilder<'a> {
18522     #[inline]
fence(mut self, fence: Fence) -> Self18523     pub fn fence(mut self, fence: Fence) -> Self {
18524         self.inner.fence = fence;
18525         self
18526     }
18527     #[inline]
flags(mut self, flags: FenceImportFlags) -> Self18528     pub fn flags(mut self, flags: FenceImportFlags) -> Self {
18529         self.inner.flags = flags;
18530         self
18531     }
18532     #[inline]
handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self18533     pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self {
18534         self.inner.handle_type = handle_type;
18535         self
18536     }
18537     #[inline]
handle(mut self, handle: HANDLE) -> Self18538     pub fn handle(mut self, handle: HANDLE) -> Self {
18539         self.inner.handle = handle;
18540         self
18541     }
18542     #[inline]
name(mut self, name: LPCWSTR) -> Self18543     pub fn name(mut self, name: LPCWSTR) -> Self {
18544         self.inner.name = name;
18545         self
18546     }
18547     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18548     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18549     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImportFenceWin32HandleInfoKHR18550     pub fn build(self) -> ImportFenceWin32HandleInfoKHR {
18551         self.inner
18552     }
18553 }
18554 #[repr(C)]
18555 #[cfg_attr(feature = "debug", derive(Debug))]
18556 #[derive(Copy, Clone)]
18557 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportFenceWin32HandleInfoKHR.html>"]
18558 pub struct ExportFenceWin32HandleInfoKHR {
18559     pub s_type: StructureType,
18560     pub p_next: *const c_void,
18561     pub p_attributes: *const SECURITY_ATTRIBUTES,
18562     pub dw_access: DWORD,
18563     pub name: LPCWSTR,
18564 }
18565 impl ::std::default::Default for ExportFenceWin32HandleInfoKHR {
18566     #[inline]
default() -> Self18567     fn default() -> Self {
18568         Self {
18569             s_type: Self::STRUCTURE_TYPE,
18570             p_next: ::std::ptr::null(),
18571             p_attributes: ::std::ptr::null(),
18572             dw_access: DWORD::default(),
18573             name: unsafe { ::std::mem::zeroed() },
18574         }
18575     }
18576 }
18577 unsafe impl TaggedStructure for ExportFenceWin32HandleInfoKHR {
18578     const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_FENCE_WIN32_HANDLE_INFO_KHR;
18579 }
18580 impl ExportFenceWin32HandleInfoKHR {
builder<'a>() -> ExportFenceWin32HandleInfoKHRBuilder<'a>18581     pub fn builder<'a>() -> ExportFenceWin32HandleInfoKHRBuilder<'a> {
18582         ExportFenceWin32HandleInfoKHRBuilder {
18583             inner: Self::default(),
18584             marker: ::std::marker::PhantomData,
18585         }
18586     }
18587 }
18588 #[repr(transparent)]
18589 pub struct ExportFenceWin32HandleInfoKHRBuilder<'a> {
18590     inner: ExportFenceWin32HandleInfoKHR,
18591     marker: ::std::marker::PhantomData<&'a ()>,
18592 }
18593 unsafe impl ExtendsFenceCreateInfo for ExportFenceWin32HandleInfoKHRBuilder<'_> {}
18594 unsafe impl ExtendsFenceCreateInfo for ExportFenceWin32HandleInfoKHR {}
18595 impl<'a> ::std::ops::Deref for ExportFenceWin32HandleInfoKHRBuilder<'a> {
18596     type Target = ExportFenceWin32HandleInfoKHR;
deref(&self) -> &Self::Target18597     fn deref(&self) -> &Self::Target {
18598         &self.inner
18599     }
18600 }
18601 impl<'a> ::std::ops::DerefMut for ExportFenceWin32HandleInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target18602     fn deref_mut(&mut self) -> &mut Self::Target {
18603         &mut self.inner
18604     }
18605 }
18606 impl<'a> ExportFenceWin32HandleInfoKHRBuilder<'a> {
18607     #[inline]
attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self18608     pub fn attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self {
18609         self.inner.p_attributes = attributes;
18610         self
18611     }
18612     #[inline]
dw_access(mut self, dw_access: DWORD) -> Self18613     pub fn dw_access(mut self, dw_access: DWORD) -> Self {
18614         self.inner.dw_access = dw_access;
18615         self
18616     }
18617     #[inline]
name(mut self, name: LPCWSTR) -> Self18618     pub fn name(mut self, name: LPCWSTR) -> Self {
18619         self.inner.name = name;
18620         self
18621     }
18622     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18623     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18624     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExportFenceWin32HandleInfoKHR18625     pub fn build(self) -> ExportFenceWin32HandleInfoKHR {
18626         self.inner
18627     }
18628 }
18629 #[repr(C)]
18630 #[cfg_attr(feature = "debug", derive(Debug))]
18631 #[derive(Copy, Clone)]
18632 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFenceGetWin32HandleInfoKHR.html>"]
18633 pub struct FenceGetWin32HandleInfoKHR {
18634     pub s_type: StructureType,
18635     pub p_next: *const c_void,
18636     pub fence: Fence,
18637     pub handle_type: ExternalFenceHandleTypeFlags,
18638 }
18639 impl ::std::default::Default for FenceGetWin32HandleInfoKHR {
18640     #[inline]
default() -> Self18641     fn default() -> Self {
18642         Self {
18643             s_type: Self::STRUCTURE_TYPE,
18644             p_next: ::std::ptr::null(),
18645             fence: Fence::default(),
18646             handle_type: ExternalFenceHandleTypeFlags::default(),
18647         }
18648     }
18649 }
18650 unsafe impl TaggedStructure for FenceGetWin32HandleInfoKHR {
18651     const STRUCTURE_TYPE: StructureType = StructureType::FENCE_GET_WIN32_HANDLE_INFO_KHR;
18652 }
18653 impl FenceGetWin32HandleInfoKHR {
builder<'a>() -> FenceGetWin32HandleInfoKHRBuilder<'a>18654     pub fn builder<'a>() -> FenceGetWin32HandleInfoKHRBuilder<'a> {
18655         FenceGetWin32HandleInfoKHRBuilder {
18656             inner: Self::default(),
18657             marker: ::std::marker::PhantomData,
18658         }
18659     }
18660 }
18661 #[repr(transparent)]
18662 pub struct FenceGetWin32HandleInfoKHRBuilder<'a> {
18663     inner: FenceGetWin32HandleInfoKHR,
18664     marker: ::std::marker::PhantomData<&'a ()>,
18665 }
18666 impl<'a> ::std::ops::Deref for FenceGetWin32HandleInfoKHRBuilder<'a> {
18667     type Target = FenceGetWin32HandleInfoKHR;
deref(&self) -> &Self::Target18668     fn deref(&self) -> &Self::Target {
18669         &self.inner
18670     }
18671 }
18672 impl<'a> ::std::ops::DerefMut for FenceGetWin32HandleInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target18673     fn deref_mut(&mut self) -> &mut Self::Target {
18674         &mut self.inner
18675     }
18676 }
18677 impl<'a> FenceGetWin32HandleInfoKHRBuilder<'a> {
18678     #[inline]
fence(mut self, fence: Fence) -> Self18679     pub fn fence(mut self, fence: Fence) -> Self {
18680         self.inner.fence = fence;
18681         self
18682     }
18683     #[inline]
handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self18684     pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self {
18685         self.inner.handle_type = handle_type;
18686         self
18687     }
18688     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18689     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18690     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> FenceGetWin32HandleInfoKHR18691     pub fn build(self) -> FenceGetWin32HandleInfoKHR {
18692         self.inner
18693     }
18694 }
18695 #[repr(C)]
18696 #[cfg_attr(feature = "debug", derive(Debug))]
18697 #[derive(Copy, Clone)]
18698 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportFenceFdInfoKHR.html>"]
18699 pub struct ImportFenceFdInfoKHR {
18700     pub s_type: StructureType,
18701     pub p_next: *const c_void,
18702     pub fence: Fence,
18703     pub flags: FenceImportFlags,
18704     pub handle_type: ExternalFenceHandleTypeFlags,
18705     pub fd: c_int,
18706 }
18707 impl ::std::default::Default for ImportFenceFdInfoKHR {
18708     #[inline]
default() -> Self18709     fn default() -> Self {
18710         Self {
18711             s_type: Self::STRUCTURE_TYPE,
18712             p_next: ::std::ptr::null(),
18713             fence: Fence::default(),
18714             flags: FenceImportFlags::default(),
18715             handle_type: ExternalFenceHandleTypeFlags::default(),
18716             fd: c_int::default(),
18717         }
18718     }
18719 }
18720 unsafe impl TaggedStructure for ImportFenceFdInfoKHR {
18721     const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_FENCE_FD_INFO_KHR;
18722 }
18723 impl ImportFenceFdInfoKHR {
builder<'a>() -> ImportFenceFdInfoKHRBuilder<'a>18724     pub fn builder<'a>() -> ImportFenceFdInfoKHRBuilder<'a> {
18725         ImportFenceFdInfoKHRBuilder {
18726             inner: Self::default(),
18727             marker: ::std::marker::PhantomData,
18728         }
18729     }
18730 }
18731 #[repr(transparent)]
18732 pub struct ImportFenceFdInfoKHRBuilder<'a> {
18733     inner: ImportFenceFdInfoKHR,
18734     marker: ::std::marker::PhantomData<&'a ()>,
18735 }
18736 impl<'a> ::std::ops::Deref for ImportFenceFdInfoKHRBuilder<'a> {
18737     type Target = ImportFenceFdInfoKHR;
deref(&self) -> &Self::Target18738     fn deref(&self) -> &Self::Target {
18739         &self.inner
18740     }
18741 }
18742 impl<'a> ::std::ops::DerefMut for ImportFenceFdInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target18743     fn deref_mut(&mut self) -> &mut Self::Target {
18744         &mut self.inner
18745     }
18746 }
18747 impl<'a> ImportFenceFdInfoKHRBuilder<'a> {
18748     #[inline]
fence(mut self, fence: Fence) -> Self18749     pub fn fence(mut self, fence: Fence) -> Self {
18750         self.inner.fence = fence;
18751         self
18752     }
18753     #[inline]
flags(mut self, flags: FenceImportFlags) -> Self18754     pub fn flags(mut self, flags: FenceImportFlags) -> Self {
18755         self.inner.flags = flags;
18756         self
18757     }
18758     #[inline]
handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self18759     pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self {
18760         self.inner.handle_type = handle_type;
18761         self
18762     }
18763     #[inline]
fd(mut self, fd: c_int) -> Self18764     pub fn fd(mut self, fd: c_int) -> Self {
18765         self.inner.fd = fd;
18766         self
18767     }
18768     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18769     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18770     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImportFenceFdInfoKHR18771     pub fn build(self) -> ImportFenceFdInfoKHR {
18772         self.inner
18773     }
18774 }
18775 #[repr(C)]
18776 #[cfg_attr(feature = "debug", derive(Debug))]
18777 #[derive(Copy, Clone)]
18778 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFenceGetFdInfoKHR.html>"]
18779 pub struct FenceGetFdInfoKHR {
18780     pub s_type: StructureType,
18781     pub p_next: *const c_void,
18782     pub fence: Fence,
18783     pub handle_type: ExternalFenceHandleTypeFlags,
18784 }
18785 impl ::std::default::Default for FenceGetFdInfoKHR {
18786     #[inline]
default() -> Self18787     fn default() -> Self {
18788         Self {
18789             s_type: Self::STRUCTURE_TYPE,
18790             p_next: ::std::ptr::null(),
18791             fence: Fence::default(),
18792             handle_type: ExternalFenceHandleTypeFlags::default(),
18793         }
18794     }
18795 }
18796 unsafe impl TaggedStructure for FenceGetFdInfoKHR {
18797     const STRUCTURE_TYPE: StructureType = StructureType::FENCE_GET_FD_INFO_KHR;
18798 }
18799 impl FenceGetFdInfoKHR {
builder<'a>() -> FenceGetFdInfoKHRBuilder<'a>18800     pub fn builder<'a>() -> FenceGetFdInfoKHRBuilder<'a> {
18801         FenceGetFdInfoKHRBuilder {
18802             inner: Self::default(),
18803             marker: ::std::marker::PhantomData,
18804         }
18805     }
18806 }
18807 #[repr(transparent)]
18808 pub struct FenceGetFdInfoKHRBuilder<'a> {
18809     inner: FenceGetFdInfoKHR,
18810     marker: ::std::marker::PhantomData<&'a ()>,
18811 }
18812 impl<'a> ::std::ops::Deref for FenceGetFdInfoKHRBuilder<'a> {
18813     type Target = FenceGetFdInfoKHR;
deref(&self) -> &Self::Target18814     fn deref(&self) -> &Self::Target {
18815         &self.inner
18816     }
18817 }
18818 impl<'a> ::std::ops::DerefMut for FenceGetFdInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target18819     fn deref_mut(&mut self) -> &mut Self::Target {
18820         &mut self.inner
18821     }
18822 }
18823 impl<'a> FenceGetFdInfoKHRBuilder<'a> {
18824     #[inline]
fence(mut self, fence: Fence) -> Self18825     pub fn fence(mut self, fence: Fence) -> Self {
18826         self.inner.fence = fence;
18827         self
18828     }
18829     #[inline]
handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self18830     pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self {
18831         self.inner.handle_type = handle_type;
18832         self
18833     }
18834     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18835     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18836     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> FenceGetFdInfoKHR18837     pub fn build(self) -> FenceGetFdInfoKHR {
18838         self.inner
18839     }
18840 }
18841 #[repr(C)]
18842 #[cfg_attr(feature = "debug", derive(Debug))]
18843 #[derive(Copy, Clone)]
18844 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiviewFeatures.html>"]
18845 pub struct PhysicalDeviceMultiviewFeatures {
18846     pub s_type: StructureType,
18847     pub p_next: *mut c_void,
18848     pub multiview: Bool32,
18849     pub multiview_geometry_shader: Bool32,
18850     pub multiview_tessellation_shader: Bool32,
18851 }
18852 impl ::std::default::Default for PhysicalDeviceMultiviewFeatures {
18853     #[inline]
default() -> Self18854     fn default() -> Self {
18855         Self {
18856             s_type: Self::STRUCTURE_TYPE,
18857             p_next: ::std::ptr::null_mut(),
18858             multiview: Bool32::default(),
18859             multiview_geometry_shader: Bool32::default(),
18860             multiview_tessellation_shader: Bool32::default(),
18861         }
18862     }
18863 }
18864 unsafe impl TaggedStructure for PhysicalDeviceMultiviewFeatures {
18865     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
18866 }
18867 impl PhysicalDeviceMultiviewFeatures {
builder<'a>() -> PhysicalDeviceMultiviewFeaturesBuilder<'a>18868     pub fn builder<'a>() -> PhysicalDeviceMultiviewFeaturesBuilder<'a> {
18869         PhysicalDeviceMultiviewFeaturesBuilder {
18870             inner: Self::default(),
18871             marker: ::std::marker::PhantomData,
18872         }
18873     }
18874 }
18875 #[repr(transparent)]
18876 pub struct PhysicalDeviceMultiviewFeaturesBuilder<'a> {
18877     inner: PhysicalDeviceMultiviewFeatures,
18878     marker: ::std::marker::PhantomData<&'a ()>,
18879 }
18880 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiviewFeaturesBuilder<'_> {}
18881 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiviewFeatures {}
18882 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewFeaturesBuilder<'_> {}
18883 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewFeatures {}
18884 impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewFeaturesBuilder<'a> {
18885     type Target = PhysicalDeviceMultiviewFeatures;
deref(&self) -> &Self::Target18886     fn deref(&self) -> &Self::Target {
18887         &self.inner
18888     }
18889 }
18890 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target18891     fn deref_mut(&mut self) -> &mut Self::Target {
18892         &mut self.inner
18893     }
18894 }
18895 impl<'a> PhysicalDeviceMultiviewFeaturesBuilder<'a> {
18896     #[inline]
multiview(mut self, multiview: bool) -> Self18897     pub fn multiview(mut self, multiview: bool) -> Self {
18898         self.inner.multiview = multiview.into();
18899         self
18900     }
18901     #[inline]
multiview_geometry_shader(mut self, multiview_geometry_shader: bool) -> Self18902     pub fn multiview_geometry_shader(mut self, multiview_geometry_shader: bool) -> Self {
18903         self.inner.multiview_geometry_shader = multiview_geometry_shader.into();
18904         self
18905     }
18906     #[inline]
multiview_tessellation_shader(mut self, multiview_tessellation_shader: bool) -> Self18907     pub fn multiview_tessellation_shader(mut self, multiview_tessellation_shader: bool) -> Self {
18908         self.inner.multiview_tessellation_shader = multiview_tessellation_shader.into();
18909         self
18910     }
18911     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18912     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18913     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMultiviewFeatures18914     pub fn build(self) -> PhysicalDeviceMultiviewFeatures {
18915         self.inner
18916     }
18917 }
18918 #[repr(C)]
18919 #[cfg_attr(feature = "debug", derive(Debug))]
18920 #[derive(Copy, Clone)]
18921 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiviewProperties.html>"]
18922 pub struct PhysicalDeviceMultiviewProperties {
18923     pub s_type: StructureType,
18924     pub p_next: *mut c_void,
18925     pub max_multiview_view_count: u32,
18926     pub max_multiview_instance_index: u32,
18927 }
18928 impl ::std::default::Default for PhysicalDeviceMultiviewProperties {
18929     #[inline]
default() -> Self18930     fn default() -> Self {
18931         Self {
18932             s_type: Self::STRUCTURE_TYPE,
18933             p_next: ::std::ptr::null_mut(),
18934             max_multiview_view_count: u32::default(),
18935             max_multiview_instance_index: u32::default(),
18936         }
18937     }
18938 }
18939 unsafe impl TaggedStructure for PhysicalDeviceMultiviewProperties {
18940     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
18941 }
18942 impl PhysicalDeviceMultiviewProperties {
builder<'a>() -> PhysicalDeviceMultiviewPropertiesBuilder<'a>18943     pub fn builder<'a>() -> PhysicalDeviceMultiviewPropertiesBuilder<'a> {
18944         PhysicalDeviceMultiviewPropertiesBuilder {
18945             inner: Self::default(),
18946             marker: ::std::marker::PhantomData,
18947         }
18948     }
18949 }
18950 #[repr(transparent)]
18951 pub struct PhysicalDeviceMultiviewPropertiesBuilder<'a> {
18952     inner: PhysicalDeviceMultiviewProperties,
18953     marker: ::std::marker::PhantomData<&'a ()>,
18954 }
18955 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiviewPropertiesBuilder<'_> {}
18956 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiviewProperties {}
18957 impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewPropertiesBuilder<'a> {
18958     type Target = PhysicalDeviceMultiviewProperties;
deref(&self) -> &Self::Target18959     fn deref(&self) -> &Self::Target {
18960         &self.inner
18961     }
18962 }
18963 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target18964     fn deref_mut(&mut self) -> &mut Self::Target {
18965         &mut self.inner
18966     }
18967 }
18968 impl<'a> PhysicalDeviceMultiviewPropertiesBuilder<'a> {
18969     #[inline]
max_multiview_view_count(mut self, max_multiview_view_count: u32) -> Self18970     pub fn max_multiview_view_count(mut self, max_multiview_view_count: u32) -> Self {
18971         self.inner.max_multiview_view_count = max_multiview_view_count;
18972         self
18973     }
18974     #[inline]
max_multiview_instance_index(mut self, max_multiview_instance_index: u32) -> Self18975     pub fn max_multiview_instance_index(mut self, max_multiview_instance_index: u32) -> Self {
18976         self.inner.max_multiview_instance_index = max_multiview_instance_index;
18977         self
18978     }
18979     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18980     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18981     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMultiviewProperties18982     pub fn build(self) -> PhysicalDeviceMultiviewProperties {
18983         self.inner
18984     }
18985 }
18986 #[repr(C)]
18987 #[cfg_attr(feature = "debug", derive(Debug))]
18988 #[derive(Copy, Clone)]
18989 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassMultiviewCreateInfo.html>"]
18990 pub struct RenderPassMultiviewCreateInfo {
18991     pub s_type: StructureType,
18992     pub p_next: *const c_void,
18993     pub subpass_count: u32,
18994     pub p_view_masks: *const u32,
18995     pub dependency_count: u32,
18996     pub p_view_offsets: *const i32,
18997     pub correlation_mask_count: u32,
18998     pub p_correlation_masks: *const u32,
18999 }
19000 impl ::std::default::Default for RenderPassMultiviewCreateInfo {
19001     #[inline]
default() -> Self19002     fn default() -> Self {
19003         Self {
19004             s_type: Self::STRUCTURE_TYPE,
19005             p_next: ::std::ptr::null(),
19006             subpass_count: u32::default(),
19007             p_view_masks: ::std::ptr::null(),
19008             dependency_count: u32::default(),
19009             p_view_offsets: ::std::ptr::null(),
19010             correlation_mask_count: u32::default(),
19011             p_correlation_masks: ::std::ptr::null(),
19012         }
19013     }
19014 }
19015 unsafe impl TaggedStructure for RenderPassMultiviewCreateInfo {
19016     const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_MULTIVIEW_CREATE_INFO;
19017 }
19018 impl RenderPassMultiviewCreateInfo {
builder<'a>() -> RenderPassMultiviewCreateInfoBuilder<'a>19019     pub fn builder<'a>() -> RenderPassMultiviewCreateInfoBuilder<'a> {
19020         RenderPassMultiviewCreateInfoBuilder {
19021             inner: Self::default(),
19022             marker: ::std::marker::PhantomData,
19023         }
19024     }
19025 }
19026 #[repr(transparent)]
19027 pub struct RenderPassMultiviewCreateInfoBuilder<'a> {
19028     inner: RenderPassMultiviewCreateInfo,
19029     marker: ::std::marker::PhantomData<&'a ()>,
19030 }
19031 unsafe impl ExtendsRenderPassCreateInfo for RenderPassMultiviewCreateInfoBuilder<'_> {}
19032 unsafe impl ExtendsRenderPassCreateInfo for RenderPassMultiviewCreateInfo {}
19033 impl<'a> ::std::ops::Deref for RenderPassMultiviewCreateInfoBuilder<'a> {
19034     type Target = RenderPassMultiviewCreateInfo;
deref(&self) -> &Self::Target19035     fn deref(&self) -> &Self::Target {
19036         &self.inner
19037     }
19038 }
19039 impl<'a> ::std::ops::DerefMut for RenderPassMultiviewCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target19040     fn deref_mut(&mut self) -> &mut Self::Target {
19041         &mut self.inner
19042     }
19043 }
19044 impl<'a> RenderPassMultiviewCreateInfoBuilder<'a> {
19045     #[inline]
view_masks(mut self, view_masks: &'a [u32]) -> Self19046     pub fn view_masks(mut self, view_masks: &'a [u32]) -> Self {
19047         self.inner.subpass_count = view_masks.len() as _;
19048         self.inner.p_view_masks = view_masks.as_ptr();
19049         self
19050     }
19051     #[inline]
view_offsets(mut self, view_offsets: &'a [i32]) -> Self19052     pub fn view_offsets(mut self, view_offsets: &'a [i32]) -> Self {
19053         self.inner.dependency_count = view_offsets.len() as _;
19054         self.inner.p_view_offsets = view_offsets.as_ptr();
19055         self
19056     }
19057     #[inline]
correlation_masks(mut self, correlation_masks: &'a [u32]) -> Self19058     pub fn correlation_masks(mut self, correlation_masks: &'a [u32]) -> Self {
19059         self.inner.correlation_mask_count = correlation_masks.len() as _;
19060         self.inner.p_correlation_masks = correlation_masks.as_ptr();
19061         self
19062     }
19063     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19064     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19065     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RenderPassMultiviewCreateInfo19066     pub fn build(self) -> RenderPassMultiviewCreateInfo {
19067         self.inner
19068     }
19069 }
19070 #[repr(C)]
19071 #[cfg_attr(feature = "debug", derive(Debug))]
19072 #[derive(Copy, Clone)]
19073 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceCapabilities2EXT.html>"]
19074 pub struct SurfaceCapabilities2EXT {
19075     pub s_type: StructureType,
19076     pub p_next: *mut c_void,
19077     pub min_image_count: u32,
19078     pub max_image_count: u32,
19079     pub current_extent: Extent2D,
19080     pub min_image_extent: Extent2D,
19081     pub max_image_extent: Extent2D,
19082     pub max_image_array_layers: u32,
19083     pub supported_transforms: SurfaceTransformFlagsKHR,
19084     pub current_transform: SurfaceTransformFlagsKHR,
19085     pub supported_composite_alpha: CompositeAlphaFlagsKHR,
19086     pub supported_usage_flags: ImageUsageFlags,
19087     pub supported_surface_counters: SurfaceCounterFlagsEXT,
19088 }
19089 impl ::std::default::Default for SurfaceCapabilities2EXT {
19090     #[inline]
default() -> Self19091     fn default() -> Self {
19092         Self {
19093             s_type: Self::STRUCTURE_TYPE,
19094             p_next: ::std::ptr::null_mut(),
19095             min_image_count: u32::default(),
19096             max_image_count: u32::default(),
19097             current_extent: Extent2D::default(),
19098             min_image_extent: Extent2D::default(),
19099             max_image_extent: Extent2D::default(),
19100             max_image_array_layers: u32::default(),
19101             supported_transforms: SurfaceTransformFlagsKHR::default(),
19102             current_transform: SurfaceTransformFlagsKHR::default(),
19103             supported_composite_alpha: CompositeAlphaFlagsKHR::default(),
19104             supported_usage_flags: ImageUsageFlags::default(),
19105             supported_surface_counters: SurfaceCounterFlagsEXT::default(),
19106         }
19107     }
19108 }
19109 unsafe impl TaggedStructure for SurfaceCapabilities2EXT {
19110     const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_CAPABILITIES_2_EXT;
19111 }
19112 impl SurfaceCapabilities2EXT {
builder<'a>() -> SurfaceCapabilities2EXTBuilder<'a>19113     pub fn builder<'a>() -> SurfaceCapabilities2EXTBuilder<'a> {
19114         SurfaceCapabilities2EXTBuilder {
19115             inner: Self::default(),
19116             marker: ::std::marker::PhantomData,
19117         }
19118     }
19119 }
19120 #[repr(transparent)]
19121 pub struct SurfaceCapabilities2EXTBuilder<'a> {
19122     inner: SurfaceCapabilities2EXT,
19123     marker: ::std::marker::PhantomData<&'a ()>,
19124 }
19125 impl<'a> ::std::ops::Deref for SurfaceCapabilities2EXTBuilder<'a> {
19126     type Target = SurfaceCapabilities2EXT;
deref(&self) -> &Self::Target19127     fn deref(&self) -> &Self::Target {
19128         &self.inner
19129     }
19130 }
19131 impl<'a> ::std::ops::DerefMut for SurfaceCapabilities2EXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target19132     fn deref_mut(&mut self) -> &mut Self::Target {
19133         &mut self.inner
19134     }
19135 }
19136 impl<'a> SurfaceCapabilities2EXTBuilder<'a> {
19137     #[inline]
min_image_count(mut self, min_image_count: u32) -> Self19138     pub fn min_image_count(mut self, min_image_count: u32) -> Self {
19139         self.inner.min_image_count = min_image_count;
19140         self
19141     }
19142     #[inline]
max_image_count(mut self, max_image_count: u32) -> Self19143     pub fn max_image_count(mut self, max_image_count: u32) -> Self {
19144         self.inner.max_image_count = max_image_count;
19145         self
19146     }
19147     #[inline]
current_extent(mut self, current_extent: Extent2D) -> Self19148     pub fn current_extent(mut self, current_extent: Extent2D) -> Self {
19149         self.inner.current_extent = current_extent;
19150         self
19151     }
19152     #[inline]
min_image_extent(mut self, min_image_extent: Extent2D) -> Self19153     pub fn min_image_extent(mut self, min_image_extent: Extent2D) -> Self {
19154         self.inner.min_image_extent = min_image_extent;
19155         self
19156     }
19157     #[inline]
max_image_extent(mut self, max_image_extent: Extent2D) -> Self19158     pub fn max_image_extent(mut self, max_image_extent: Extent2D) -> Self {
19159         self.inner.max_image_extent = max_image_extent;
19160         self
19161     }
19162     #[inline]
max_image_array_layers(mut self, max_image_array_layers: u32) -> Self19163     pub fn max_image_array_layers(mut self, max_image_array_layers: u32) -> Self {
19164         self.inner.max_image_array_layers = max_image_array_layers;
19165         self
19166     }
19167     #[inline]
supported_transforms(mut self, supported_transforms: SurfaceTransformFlagsKHR) -> Self19168     pub fn supported_transforms(mut self, supported_transforms: SurfaceTransformFlagsKHR) -> Self {
19169         self.inner.supported_transforms = supported_transforms;
19170         self
19171     }
19172     #[inline]
current_transform(mut self, current_transform: SurfaceTransformFlagsKHR) -> Self19173     pub fn current_transform(mut self, current_transform: SurfaceTransformFlagsKHR) -> Self {
19174         self.inner.current_transform = current_transform;
19175         self
19176     }
19177     #[inline]
supported_composite_alpha( mut self, supported_composite_alpha: CompositeAlphaFlagsKHR, ) -> Self19178     pub fn supported_composite_alpha(
19179         mut self,
19180         supported_composite_alpha: CompositeAlphaFlagsKHR,
19181     ) -> Self {
19182         self.inner.supported_composite_alpha = supported_composite_alpha;
19183         self
19184     }
19185     #[inline]
supported_usage_flags(mut self, supported_usage_flags: ImageUsageFlags) -> Self19186     pub fn supported_usage_flags(mut self, supported_usage_flags: ImageUsageFlags) -> Self {
19187         self.inner.supported_usage_flags = supported_usage_flags;
19188         self
19189     }
19190     #[inline]
supported_surface_counters( mut self, supported_surface_counters: SurfaceCounterFlagsEXT, ) -> Self19191     pub fn supported_surface_counters(
19192         mut self,
19193         supported_surface_counters: SurfaceCounterFlagsEXT,
19194     ) -> Self {
19195         self.inner.supported_surface_counters = supported_surface_counters;
19196         self
19197     }
19198     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19199     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19200     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SurfaceCapabilities2EXT19201     pub fn build(self) -> SurfaceCapabilities2EXT {
19202         self.inner
19203     }
19204 }
19205 #[repr(C)]
19206 #[cfg_attr(feature = "debug", derive(Debug))]
19207 #[derive(Copy, Clone)]
19208 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPowerInfoEXT.html>"]
19209 pub struct DisplayPowerInfoEXT {
19210     pub s_type: StructureType,
19211     pub p_next: *const c_void,
19212     pub power_state: DisplayPowerStateEXT,
19213 }
19214 impl ::std::default::Default for DisplayPowerInfoEXT {
19215     #[inline]
default() -> Self19216     fn default() -> Self {
19217         Self {
19218             s_type: Self::STRUCTURE_TYPE,
19219             p_next: ::std::ptr::null(),
19220             power_state: DisplayPowerStateEXT::default(),
19221         }
19222     }
19223 }
19224 unsafe impl TaggedStructure for DisplayPowerInfoEXT {
19225     const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_POWER_INFO_EXT;
19226 }
19227 impl DisplayPowerInfoEXT {
builder<'a>() -> DisplayPowerInfoEXTBuilder<'a>19228     pub fn builder<'a>() -> DisplayPowerInfoEXTBuilder<'a> {
19229         DisplayPowerInfoEXTBuilder {
19230             inner: Self::default(),
19231             marker: ::std::marker::PhantomData,
19232         }
19233     }
19234 }
19235 #[repr(transparent)]
19236 pub struct DisplayPowerInfoEXTBuilder<'a> {
19237     inner: DisplayPowerInfoEXT,
19238     marker: ::std::marker::PhantomData<&'a ()>,
19239 }
19240 impl<'a> ::std::ops::Deref for DisplayPowerInfoEXTBuilder<'a> {
19241     type Target = DisplayPowerInfoEXT;
deref(&self) -> &Self::Target19242     fn deref(&self) -> &Self::Target {
19243         &self.inner
19244     }
19245 }
19246 impl<'a> ::std::ops::DerefMut for DisplayPowerInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target19247     fn deref_mut(&mut self) -> &mut Self::Target {
19248         &mut self.inner
19249     }
19250 }
19251 impl<'a> DisplayPowerInfoEXTBuilder<'a> {
19252     #[inline]
power_state(mut self, power_state: DisplayPowerStateEXT) -> Self19253     pub fn power_state(mut self, power_state: DisplayPowerStateEXT) -> Self {
19254         self.inner.power_state = power_state;
19255         self
19256     }
19257     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19258     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19259     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayPowerInfoEXT19260     pub fn build(self) -> DisplayPowerInfoEXT {
19261         self.inner
19262     }
19263 }
19264 #[repr(C)]
19265 #[cfg_attr(feature = "debug", derive(Debug))]
19266 #[derive(Copy, Clone)]
19267 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceEventInfoEXT.html>"]
19268 pub struct DeviceEventInfoEXT {
19269     pub s_type: StructureType,
19270     pub p_next: *const c_void,
19271     pub device_event: DeviceEventTypeEXT,
19272 }
19273 impl ::std::default::Default for DeviceEventInfoEXT {
19274     #[inline]
default() -> Self19275     fn default() -> Self {
19276         Self {
19277             s_type: Self::STRUCTURE_TYPE,
19278             p_next: ::std::ptr::null(),
19279             device_event: DeviceEventTypeEXT::default(),
19280         }
19281     }
19282 }
19283 unsafe impl TaggedStructure for DeviceEventInfoEXT {
19284     const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_EVENT_INFO_EXT;
19285 }
19286 impl DeviceEventInfoEXT {
builder<'a>() -> DeviceEventInfoEXTBuilder<'a>19287     pub fn builder<'a>() -> DeviceEventInfoEXTBuilder<'a> {
19288         DeviceEventInfoEXTBuilder {
19289             inner: Self::default(),
19290             marker: ::std::marker::PhantomData,
19291         }
19292     }
19293 }
19294 #[repr(transparent)]
19295 pub struct DeviceEventInfoEXTBuilder<'a> {
19296     inner: DeviceEventInfoEXT,
19297     marker: ::std::marker::PhantomData<&'a ()>,
19298 }
19299 impl<'a> ::std::ops::Deref for DeviceEventInfoEXTBuilder<'a> {
19300     type Target = DeviceEventInfoEXT;
deref(&self) -> &Self::Target19301     fn deref(&self) -> &Self::Target {
19302         &self.inner
19303     }
19304 }
19305 impl<'a> ::std::ops::DerefMut for DeviceEventInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target19306     fn deref_mut(&mut self) -> &mut Self::Target {
19307         &mut self.inner
19308     }
19309 }
19310 impl<'a> DeviceEventInfoEXTBuilder<'a> {
19311     #[inline]
device_event(mut self, device_event: DeviceEventTypeEXT) -> Self19312     pub fn device_event(mut self, device_event: DeviceEventTypeEXT) -> Self {
19313         self.inner.device_event = device_event;
19314         self
19315     }
19316     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19317     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19318     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceEventInfoEXT19319     pub fn build(self) -> DeviceEventInfoEXT {
19320         self.inner
19321     }
19322 }
19323 #[repr(C)]
19324 #[cfg_attr(feature = "debug", derive(Debug))]
19325 #[derive(Copy, Clone)]
19326 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayEventInfoEXT.html>"]
19327 pub struct DisplayEventInfoEXT {
19328     pub s_type: StructureType,
19329     pub p_next: *const c_void,
19330     pub display_event: DisplayEventTypeEXT,
19331 }
19332 impl ::std::default::Default for DisplayEventInfoEXT {
19333     #[inline]
default() -> Self19334     fn default() -> Self {
19335         Self {
19336             s_type: Self::STRUCTURE_TYPE,
19337             p_next: ::std::ptr::null(),
19338             display_event: DisplayEventTypeEXT::default(),
19339         }
19340     }
19341 }
19342 unsafe impl TaggedStructure for DisplayEventInfoEXT {
19343     const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_EVENT_INFO_EXT;
19344 }
19345 impl DisplayEventInfoEXT {
builder<'a>() -> DisplayEventInfoEXTBuilder<'a>19346     pub fn builder<'a>() -> DisplayEventInfoEXTBuilder<'a> {
19347         DisplayEventInfoEXTBuilder {
19348             inner: Self::default(),
19349             marker: ::std::marker::PhantomData,
19350         }
19351     }
19352 }
19353 #[repr(transparent)]
19354 pub struct DisplayEventInfoEXTBuilder<'a> {
19355     inner: DisplayEventInfoEXT,
19356     marker: ::std::marker::PhantomData<&'a ()>,
19357 }
19358 impl<'a> ::std::ops::Deref for DisplayEventInfoEXTBuilder<'a> {
19359     type Target = DisplayEventInfoEXT;
deref(&self) -> &Self::Target19360     fn deref(&self) -> &Self::Target {
19361         &self.inner
19362     }
19363 }
19364 impl<'a> ::std::ops::DerefMut for DisplayEventInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target19365     fn deref_mut(&mut self) -> &mut Self::Target {
19366         &mut self.inner
19367     }
19368 }
19369 impl<'a> DisplayEventInfoEXTBuilder<'a> {
19370     #[inline]
display_event(mut self, display_event: DisplayEventTypeEXT) -> Self19371     pub fn display_event(mut self, display_event: DisplayEventTypeEXT) -> Self {
19372         self.inner.display_event = display_event;
19373         self
19374     }
19375     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19376     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19377     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayEventInfoEXT19378     pub fn build(self) -> DisplayEventInfoEXT {
19379         self.inner
19380     }
19381 }
19382 #[repr(C)]
19383 #[cfg_attr(feature = "debug", derive(Debug))]
19384 #[derive(Copy, Clone)]
19385 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainCounterCreateInfoEXT.html>"]
19386 pub struct SwapchainCounterCreateInfoEXT {
19387     pub s_type: StructureType,
19388     pub p_next: *const c_void,
19389     pub surface_counters: SurfaceCounterFlagsEXT,
19390 }
19391 impl ::std::default::Default for SwapchainCounterCreateInfoEXT {
19392     #[inline]
default() -> Self19393     fn default() -> Self {
19394         Self {
19395             s_type: Self::STRUCTURE_TYPE,
19396             p_next: ::std::ptr::null(),
19397             surface_counters: SurfaceCounterFlagsEXT::default(),
19398         }
19399     }
19400 }
19401 unsafe impl TaggedStructure for SwapchainCounterCreateInfoEXT {
19402     const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_COUNTER_CREATE_INFO_EXT;
19403 }
19404 impl SwapchainCounterCreateInfoEXT {
builder<'a>() -> SwapchainCounterCreateInfoEXTBuilder<'a>19405     pub fn builder<'a>() -> SwapchainCounterCreateInfoEXTBuilder<'a> {
19406         SwapchainCounterCreateInfoEXTBuilder {
19407             inner: Self::default(),
19408             marker: ::std::marker::PhantomData,
19409         }
19410     }
19411 }
19412 #[repr(transparent)]
19413 pub struct SwapchainCounterCreateInfoEXTBuilder<'a> {
19414     inner: SwapchainCounterCreateInfoEXT,
19415     marker: ::std::marker::PhantomData<&'a ()>,
19416 }
19417 unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainCounterCreateInfoEXTBuilder<'_> {}
19418 unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainCounterCreateInfoEXT {}
19419 impl<'a> ::std::ops::Deref for SwapchainCounterCreateInfoEXTBuilder<'a> {
19420     type Target = SwapchainCounterCreateInfoEXT;
deref(&self) -> &Self::Target19421     fn deref(&self) -> &Self::Target {
19422         &self.inner
19423     }
19424 }
19425 impl<'a> ::std::ops::DerefMut for SwapchainCounterCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target19426     fn deref_mut(&mut self) -> &mut Self::Target {
19427         &mut self.inner
19428     }
19429 }
19430 impl<'a> SwapchainCounterCreateInfoEXTBuilder<'a> {
19431     #[inline]
surface_counters(mut self, surface_counters: SurfaceCounterFlagsEXT) -> Self19432     pub fn surface_counters(mut self, surface_counters: SurfaceCounterFlagsEXT) -> Self {
19433         self.inner.surface_counters = surface_counters;
19434         self
19435     }
19436     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19437     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19438     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SwapchainCounterCreateInfoEXT19439     pub fn build(self) -> SwapchainCounterCreateInfoEXT {
19440         self.inner
19441     }
19442 }
19443 #[repr(C)]
19444 #[cfg_attr(feature = "debug", derive(Debug))]
19445 #[derive(Copy, Clone)]
19446 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceGroupProperties.html>"]
19447 pub struct PhysicalDeviceGroupProperties {
19448     pub s_type: StructureType,
19449     pub p_next: *mut c_void,
19450     pub physical_device_count: u32,
19451     pub physical_devices: [PhysicalDevice; MAX_DEVICE_GROUP_SIZE],
19452     pub subset_allocation: Bool32,
19453 }
19454 impl ::std::default::Default for PhysicalDeviceGroupProperties {
19455     #[inline]
default() -> Self19456     fn default() -> Self {
19457         Self {
19458             s_type: Self::STRUCTURE_TYPE,
19459             p_next: ::std::ptr::null_mut(),
19460             physical_device_count: u32::default(),
19461             physical_devices: unsafe { ::std::mem::zeroed() },
19462             subset_allocation: Bool32::default(),
19463         }
19464     }
19465 }
19466 unsafe impl TaggedStructure for PhysicalDeviceGroupProperties {
19467     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_GROUP_PROPERTIES;
19468 }
19469 impl PhysicalDeviceGroupProperties {
builder<'a>() -> PhysicalDeviceGroupPropertiesBuilder<'a>19470     pub fn builder<'a>() -> PhysicalDeviceGroupPropertiesBuilder<'a> {
19471         PhysicalDeviceGroupPropertiesBuilder {
19472             inner: Self::default(),
19473             marker: ::std::marker::PhantomData,
19474         }
19475     }
19476 }
19477 #[repr(transparent)]
19478 pub struct PhysicalDeviceGroupPropertiesBuilder<'a> {
19479     inner: PhysicalDeviceGroupProperties,
19480     marker: ::std::marker::PhantomData<&'a ()>,
19481 }
19482 impl<'a> ::std::ops::Deref for PhysicalDeviceGroupPropertiesBuilder<'a> {
19483     type Target = PhysicalDeviceGroupProperties;
deref(&self) -> &Self::Target19484     fn deref(&self) -> &Self::Target {
19485         &self.inner
19486     }
19487 }
19488 impl<'a> ::std::ops::DerefMut for PhysicalDeviceGroupPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target19489     fn deref_mut(&mut self) -> &mut Self::Target {
19490         &mut self.inner
19491     }
19492 }
19493 impl<'a> PhysicalDeviceGroupPropertiesBuilder<'a> {
19494     #[inline]
physical_device_count(mut self, physical_device_count: u32) -> Self19495     pub fn physical_device_count(mut self, physical_device_count: u32) -> Self {
19496         self.inner.physical_device_count = physical_device_count;
19497         self
19498     }
19499     #[inline]
physical_devices( mut self, physical_devices: [PhysicalDevice; MAX_DEVICE_GROUP_SIZE], ) -> Self19500     pub fn physical_devices(
19501         mut self,
19502         physical_devices: [PhysicalDevice; MAX_DEVICE_GROUP_SIZE],
19503     ) -> Self {
19504         self.inner.physical_devices = physical_devices;
19505         self
19506     }
19507     #[inline]
subset_allocation(mut self, subset_allocation: bool) -> Self19508     pub fn subset_allocation(mut self, subset_allocation: bool) -> Self {
19509         self.inner.subset_allocation = subset_allocation.into();
19510         self
19511     }
19512     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19513     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19514     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceGroupProperties19515     pub fn build(self) -> PhysicalDeviceGroupProperties {
19516         self.inner
19517     }
19518 }
19519 #[repr(C)]
19520 #[cfg_attr(feature = "debug", derive(Debug))]
19521 #[derive(Copy, Clone)]
19522 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryAllocateFlagsInfo.html>"]
19523 pub struct MemoryAllocateFlagsInfo {
19524     pub s_type: StructureType,
19525     pub p_next: *const c_void,
19526     pub flags: MemoryAllocateFlags,
19527     pub device_mask: u32,
19528 }
19529 impl ::std::default::Default for MemoryAllocateFlagsInfo {
19530     #[inline]
default() -> Self19531     fn default() -> Self {
19532         Self {
19533             s_type: Self::STRUCTURE_TYPE,
19534             p_next: ::std::ptr::null(),
19535             flags: MemoryAllocateFlags::default(),
19536             device_mask: u32::default(),
19537         }
19538     }
19539 }
19540 unsafe impl TaggedStructure for MemoryAllocateFlagsInfo {
19541     const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_ALLOCATE_FLAGS_INFO;
19542 }
19543 impl MemoryAllocateFlagsInfo {
builder<'a>() -> MemoryAllocateFlagsInfoBuilder<'a>19544     pub fn builder<'a>() -> MemoryAllocateFlagsInfoBuilder<'a> {
19545         MemoryAllocateFlagsInfoBuilder {
19546             inner: Self::default(),
19547             marker: ::std::marker::PhantomData,
19548         }
19549     }
19550 }
19551 #[repr(transparent)]
19552 pub struct MemoryAllocateFlagsInfoBuilder<'a> {
19553     inner: MemoryAllocateFlagsInfo,
19554     marker: ::std::marker::PhantomData<&'a ()>,
19555 }
19556 unsafe impl ExtendsMemoryAllocateInfo for MemoryAllocateFlagsInfoBuilder<'_> {}
19557 unsafe impl ExtendsMemoryAllocateInfo for MemoryAllocateFlagsInfo {}
19558 impl<'a> ::std::ops::Deref for MemoryAllocateFlagsInfoBuilder<'a> {
19559     type Target = MemoryAllocateFlagsInfo;
deref(&self) -> &Self::Target19560     fn deref(&self) -> &Self::Target {
19561         &self.inner
19562     }
19563 }
19564 impl<'a> ::std::ops::DerefMut for MemoryAllocateFlagsInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target19565     fn deref_mut(&mut self) -> &mut Self::Target {
19566         &mut self.inner
19567     }
19568 }
19569 impl<'a> MemoryAllocateFlagsInfoBuilder<'a> {
19570     #[inline]
flags(mut self, flags: MemoryAllocateFlags) -> Self19571     pub fn flags(mut self, flags: MemoryAllocateFlags) -> Self {
19572         self.inner.flags = flags;
19573         self
19574     }
19575     #[inline]
device_mask(mut self, device_mask: u32) -> Self19576     pub fn device_mask(mut self, device_mask: u32) -> Self {
19577         self.inner.device_mask = device_mask;
19578         self
19579     }
19580     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19581     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19582     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryAllocateFlagsInfo19583     pub fn build(self) -> MemoryAllocateFlagsInfo {
19584         self.inner
19585     }
19586 }
19587 #[repr(C)]
19588 #[cfg_attr(feature = "debug", derive(Debug))]
19589 #[derive(Copy, Clone)]
19590 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindBufferMemoryInfo.html>"]
19591 pub struct BindBufferMemoryInfo {
19592     pub s_type: StructureType,
19593     pub p_next: *const c_void,
19594     pub buffer: Buffer,
19595     pub memory: DeviceMemory,
19596     pub memory_offset: DeviceSize,
19597 }
19598 impl ::std::default::Default for BindBufferMemoryInfo {
19599     #[inline]
default() -> Self19600     fn default() -> Self {
19601         Self {
19602             s_type: Self::STRUCTURE_TYPE,
19603             p_next: ::std::ptr::null(),
19604             buffer: Buffer::default(),
19605             memory: DeviceMemory::default(),
19606             memory_offset: DeviceSize::default(),
19607         }
19608     }
19609 }
19610 unsafe impl TaggedStructure for BindBufferMemoryInfo {
19611     const STRUCTURE_TYPE: StructureType = StructureType::BIND_BUFFER_MEMORY_INFO;
19612 }
19613 impl BindBufferMemoryInfo {
builder<'a>() -> BindBufferMemoryInfoBuilder<'a>19614     pub fn builder<'a>() -> BindBufferMemoryInfoBuilder<'a> {
19615         BindBufferMemoryInfoBuilder {
19616             inner: Self::default(),
19617             marker: ::std::marker::PhantomData,
19618         }
19619     }
19620 }
19621 #[repr(transparent)]
19622 pub struct BindBufferMemoryInfoBuilder<'a> {
19623     inner: BindBufferMemoryInfo,
19624     marker: ::std::marker::PhantomData<&'a ()>,
19625 }
19626 pub unsafe trait ExtendsBindBufferMemoryInfo {}
19627 impl<'a> ::std::ops::Deref for BindBufferMemoryInfoBuilder<'a> {
19628     type Target = BindBufferMemoryInfo;
deref(&self) -> &Self::Target19629     fn deref(&self) -> &Self::Target {
19630         &self.inner
19631     }
19632 }
19633 impl<'a> ::std::ops::DerefMut for BindBufferMemoryInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target19634     fn deref_mut(&mut self) -> &mut Self::Target {
19635         &mut self.inner
19636     }
19637 }
19638 impl<'a> BindBufferMemoryInfoBuilder<'a> {
19639     #[inline]
buffer(mut self, buffer: Buffer) -> Self19640     pub fn buffer(mut self, buffer: Buffer) -> Self {
19641         self.inner.buffer = buffer;
19642         self
19643     }
19644     #[inline]
memory(mut self, memory: DeviceMemory) -> Self19645     pub fn memory(mut self, memory: DeviceMemory) -> Self {
19646         self.inner.memory = memory;
19647         self
19648     }
19649     #[inline]
memory_offset(mut self, memory_offset: DeviceSize) -> Self19650     pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self {
19651         self.inner.memory_offset = memory_offset;
19652         self
19653     }
19654     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
19655     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
19656     #[doc = r" valid extension structs can be pushed into the chain."]
19657     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
19658     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsBindBufferMemoryInfo>(mut self, next: &'a mut T) -> Self19659     pub fn push_next<T: ExtendsBindBufferMemoryInfo>(mut self, next: &'a mut T) -> Self {
19660         unsafe {
19661             let next_ptr = <*const T>::cast(next);
19662             let last_next = ptr_chain_iter(next).last().unwrap();
19663             (*last_next).p_next = self.inner.p_next as _;
19664             self.inner.p_next = next_ptr;
19665         }
19666         self
19667     }
19668     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19669     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19670     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BindBufferMemoryInfo19671     pub fn build(self) -> BindBufferMemoryInfo {
19672         self.inner
19673     }
19674 }
19675 #[repr(C)]
19676 #[cfg_attr(feature = "debug", derive(Debug))]
19677 #[derive(Copy, Clone)]
19678 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindBufferMemoryDeviceGroupInfo.html>"]
19679 pub struct BindBufferMemoryDeviceGroupInfo {
19680     pub s_type: StructureType,
19681     pub p_next: *const c_void,
19682     pub device_index_count: u32,
19683     pub p_device_indices: *const u32,
19684 }
19685 impl ::std::default::Default for BindBufferMemoryDeviceGroupInfo {
19686     #[inline]
default() -> Self19687     fn default() -> Self {
19688         Self {
19689             s_type: Self::STRUCTURE_TYPE,
19690             p_next: ::std::ptr::null(),
19691             device_index_count: u32::default(),
19692             p_device_indices: ::std::ptr::null(),
19693         }
19694     }
19695 }
19696 unsafe impl TaggedStructure for BindBufferMemoryDeviceGroupInfo {
19697     const STRUCTURE_TYPE: StructureType = StructureType::BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO;
19698 }
19699 impl BindBufferMemoryDeviceGroupInfo {
builder<'a>() -> BindBufferMemoryDeviceGroupInfoBuilder<'a>19700     pub fn builder<'a>() -> BindBufferMemoryDeviceGroupInfoBuilder<'a> {
19701         BindBufferMemoryDeviceGroupInfoBuilder {
19702             inner: Self::default(),
19703             marker: ::std::marker::PhantomData,
19704         }
19705     }
19706 }
19707 #[repr(transparent)]
19708 pub struct BindBufferMemoryDeviceGroupInfoBuilder<'a> {
19709     inner: BindBufferMemoryDeviceGroupInfo,
19710     marker: ::std::marker::PhantomData<&'a ()>,
19711 }
19712 unsafe impl ExtendsBindBufferMemoryInfo for BindBufferMemoryDeviceGroupInfoBuilder<'_> {}
19713 unsafe impl ExtendsBindBufferMemoryInfo for BindBufferMemoryDeviceGroupInfo {}
19714 impl<'a> ::std::ops::Deref for BindBufferMemoryDeviceGroupInfoBuilder<'a> {
19715     type Target = BindBufferMemoryDeviceGroupInfo;
deref(&self) -> &Self::Target19716     fn deref(&self) -> &Self::Target {
19717         &self.inner
19718     }
19719 }
19720 impl<'a> ::std::ops::DerefMut for BindBufferMemoryDeviceGroupInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target19721     fn deref_mut(&mut self) -> &mut Self::Target {
19722         &mut self.inner
19723     }
19724 }
19725 impl<'a> BindBufferMemoryDeviceGroupInfoBuilder<'a> {
19726     #[inline]
device_indices(mut self, device_indices: &'a [u32]) -> Self19727     pub fn device_indices(mut self, device_indices: &'a [u32]) -> Self {
19728         self.inner.device_index_count = device_indices.len() as _;
19729         self.inner.p_device_indices = device_indices.as_ptr();
19730         self
19731     }
19732     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19733     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19734     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BindBufferMemoryDeviceGroupInfo19735     pub fn build(self) -> BindBufferMemoryDeviceGroupInfo {
19736         self.inner
19737     }
19738 }
19739 #[repr(C)]
19740 #[cfg_attr(feature = "debug", derive(Debug))]
19741 #[derive(Copy, Clone)]
19742 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindImageMemoryInfo.html>"]
19743 pub struct BindImageMemoryInfo {
19744     pub s_type: StructureType,
19745     pub p_next: *const c_void,
19746     pub image: Image,
19747     pub memory: DeviceMemory,
19748     pub memory_offset: DeviceSize,
19749 }
19750 impl ::std::default::Default for BindImageMemoryInfo {
19751     #[inline]
default() -> Self19752     fn default() -> Self {
19753         Self {
19754             s_type: Self::STRUCTURE_TYPE,
19755             p_next: ::std::ptr::null(),
19756             image: Image::default(),
19757             memory: DeviceMemory::default(),
19758             memory_offset: DeviceSize::default(),
19759         }
19760     }
19761 }
19762 unsafe impl TaggedStructure for BindImageMemoryInfo {
19763     const STRUCTURE_TYPE: StructureType = StructureType::BIND_IMAGE_MEMORY_INFO;
19764 }
19765 impl BindImageMemoryInfo {
builder<'a>() -> BindImageMemoryInfoBuilder<'a>19766     pub fn builder<'a>() -> BindImageMemoryInfoBuilder<'a> {
19767         BindImageMemoryInfoBuilder {
19768             inner: Self::default(),
19769             marker: ::std::marker::PhantomData,
19770         }
19771     }
19772 }
19773 #[repr(transparent)]
19774 pub struct BindImageMemoryInfoBuilder<'a> {
19775     inner: BindImageMemoryInfo,
19776     marker: ::std::marker::PhantomData<&'a ()>,
19777 }
19778 pub unsafe trait ExtendsBindImageMemoryInfo {}
19779 impl<'a> ::std::ops::Deref for BindImageMemoryInfoBuilder<'a> {
19780     type Target = BindImageMemoryInfo;
deref(&self) -> &Self::Target19781     fn deref(&self) -> &Self::Target {
19782         &self.inner
19783     }
19784 }
19785 impl<'a> ::std::ops::DerefMut for BindImageMemoryInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target19786     fn deref_mut(&mut self) -> &mut Self::Target {
19787         &mut self.inner
19788     }
19789 }
19790 impl<'a> BindImageMemoryInfoBuilder<'a> {
19791     #[inline]
image(mut self, image: Image) -> Self19792     pub fn image(mut self, image: Image) -> Self {
19793         self.inner.image = image;
19794         self
19795     }
19796     #[inline]
memory(mut self, memory: DeviceMemory) -> Self19797     pub fn memory(mut self, memory: DeviceMemory) -> Self {
19798         self.inner.memory = memory;
19799         self
19800     }
19801     #[inline]
memory_offset(mut self, memory_offset: DeviceSize) -> Self19802     pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self {
19803         self.inner.memory_offset = memory_offset;
19804         self
19805     }
19806     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
19807     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
19808     #[doc = r" valid extension structs can be pushed into the chain."]
19809     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
19810     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsBindImageMemoryInfo>(mut self, next: &'a mut T) -> Self19811     pub fn push_next<T: ExtendsBindImageMemoryInfo>(mut self, next: &'a mut T) -> Self {
19812         unsafe {
19813             let next_ptr = <*const T>::cast(next);
19814             let last_next = ptr_chain_iter(next).last().unwrap();
19815             (*last_next).p_next = self.inner.p_next as _;
19816             self.inner.p_next = next_ptr;
19817         }
19818         self
19819     }
19820     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19821     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19822     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BindImageMemoryInfo19823     pub fn build(self) -> BindImageMemoryInfo {
19824         self.inner
19825     }
19826 }
19827 #[repr(C)]
19828 #[cfg_attr(feature = "debug", derive(Debug))]
19829 #[derive(Copy, Clone)]
19830 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindImageMemoryDeviceGroupInfo.html>"]
19831 pub struct BindImageMemoryDeviceGroupInfo {
19832     pub s_type: StructureType,
19833     pub p_next: *const c_void,
19834     pub device_index_count: u32,
19835     pub p_device_indices: *const u32,
19836     pub split_instance_bind_region_count: u32,
19837     pub p_split_instance_bind_regions: *const Rect2D,
19838 }
19839 impl ::std::default::Default for BindImageMemoryDeviceGroupInfo {
19840     #[inline]
default() -> Self19841     fn default() -> Self {
19842         Self {
19843             s_type: Self::STRUCTURE_TYPE,
19844             p_next: ::std::ptr::null(),
19845             device_index_count: u32::default(),
19846             p_device_indices: ::std::ptr::null(),
19847             split_instance_bind_region_count: u32::default(),
19848             p_split_instance_bind_regions: ::std::ptr::null(),
19849         }
19850     }
19851 }
19852 unsafe impl TaggedStructure for BindImageMemoryDeviceGroupInfo {
19853     const STRUCTURE_TYPE: StructureType = StructureType::BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO;
19854 }
19855 impl BindImageMemoryDeviceGroupInfo {
builder<'a>() -> BindImageMemoryDeviceGroupInfoBuilder<'a>19856     pub fn builder<'a>() -> BindImageMemoryDeviceGroupInfoBuilder<'a> {
19857         BindImageMemoryDeviceGroupInfoBuilder {
19858             inner: Self::default(),
19859             marker: ::std::marker::PhantomData,
19860         }
19861     }
19862 }
19863 #[repr(transparent)]
19864 pub struct BindImageMemoryDeviceGroupInfoBuilder<'a> {
19865     inner: BindImageMemoryDeviceGroupInfo,
19866     marker: ::std::marker::PhantomData<&'a ()>,
19867 }
19868 unsafe impl ExtendsBindImageMemoryInfo for BindImageMemoryDeviceGroupInfoBuilder<'_> {}
19869 unsafe impl ExtendsBindImageMemoryInfo for BindImageMemoryDeviceGroupInfo {}
19870 impl<'a> ::std::ops::Deref for BindImageMemoryDeviceGroupInfoBuilder<'a> {
19871     type Target = BindImageMemoryDeviceGroupInfo;
deref(&self) -> &Self::Target19872     fn deref(&self) -> &Self::Target {
19873         &self.inner
19874     }
19875 }
19876 impl<'a> ::std::ops::DerefMut for BindImageMemoryDeviceGroupInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target19877     fn deref_mut(&mut self) -> &mut Self::Target {
19878         &mut self.inner
19879     }
19880 }
19881 impl<'a> BindImageMemoryDeviceGroupInfoBuilder<'a> {
19882     #[inline]
device_indices(mut self, device_indices: &'a [u32]) -> Self19883     pub fn device_indices(mut self, device_indices: &'a [u32]) -> Self {
19884         self.inner.device_index_count = device_indices.len() as _;
19885         self.inner.p_device_indices = device_indices.as_ptr();
19886         self
19887     }
19888     #[inline]
split_instance_bind_regions( mut self, split_instance_bind_regions: &'a [Rect2D], ) -> Self19889     pub fn split_instance_bind_regions(
19890         mut self,
19891         split_instance_bind_regions: &'a [Rect2D],
19892     ) -> Self {
19893         self.inner.split_instance_bind_region_count = split_instance_bind_regions.len() as _;
19894         self.inner.p_split_instance_bind_regions = split_instance_bind_regions.as_ptr();
19895         self
19896     }
19897     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19898     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19899     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BindImageMemoryDeviceGroupInfo19900     pub fn build(self) -> BindImageMemoryDeviceGroupInfo {
19901         self.inner
19902     }
19903 }
19904 #[repr(C)]
19905 #[cfg_attr(feature = "debug", derive(Debug))]
19906 #[derive(Copy, Clone)]
19907 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupRenderPassBeginInfo.html>"]
19908 pub struct DeviceGroupRenderPassBeginInfo {
19909     pub s_type: StructureType,
19910     pub p_next: *const c_void,
19911     pub device_mask: u32,
19912     pub device_render_area_count: u32,
19913     pub p_device_render_areas: *const Rect2D,
19914 }
19915 impl ::std::default::Default for DeviceGroupRenderPassBeginInfo {
19916     #[inline]
default() -> Self19917     fn default() -> Self {
19918         Self {
19919             s_type: Self::STRUCTURE_TYPE,
19920             p_next: ::std::ptr::null(),
19921             device_mask: u32::default(),
19922             device_render_area_count: u32::default(),
19923             p_device_render_areas: ::std::ptr::null(),
19924         }
19925     }
19926 }
19927 unsafe impl TaggedStructure for DeviceGroupRenderPassBeginInfo {
19928     const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_RENDER_PASS_BEGIN_INFO;
19929 }
19930 impl DeviceGroupRenderPassBeginInfo {
builder<'a>() -> DeviceGroupRenderPassBeginInfoBuilder<'a>19931     pub fn builder<'a>() -> DeviceGroupRenderPassBeginInfoBuilder<'a> {
19932         DeviceGroupRenderPassBeginInfoBuilder {
19933             inner: Self::default(),
19934             marker: ::std::marker::PhantomData,
19935         }
19936     }
19937 }
19938 #[repr(transparent)]
19939 pub struct DeviceGroupRenderPassBeginInfoBuilder<'a> {
19940     inner: DeviceGroupRenderPassBeginInfo,
19941     marker: ::std::marker::PhantomData<&'a ()>,
19942 }
19943 unsafe impl ExtendsRenderPassBeginInfo for DeviceGroupRenderPassBeginInfoBuilder<'_> {}
19944 unsafe impl ExtendsRenderPassBeginInfo for DeviceGroupRenderPassBeginInfo {}
19945 unsafe impl ExtendsRenderingInfo for DeviceGroupRenderPassBeginInfoBuilder<'_> {}
19946 unsafe impl ExtendsRenderingInfo for DeviceGroupRenderPassBeginInfo {}
19947 impl<'a> ::std::ops::Deref for DeviceGroupRenderPassBeginInfoBuilder<'a> {
19948     type Target = DeviceGroupRenderPassBeginInfo;
deref(&self) -> &Self::Target19949     fn deref(&self) -> &Self::Target {
19950         &self.inner
19951     }
19952 }
19953 impl<'a> ::std::ops::DerefMut for DeviceGroupRenderPassBeginInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target19954     fn deref_mut(&mut self) -> &mut Self::Target {
19955         &mut self.inner
19956     }
19957 }
19958 impl<'a> DeviceGroupRenderPassBeginInfoBuilder<'a> {
19959     #[inline]
device_mask(mut self, device_mask: u32) -> Self19960     pub fn device_mask(mut self, device_mask: u32) -> Self {
19961         self.inner.device_mask = device_mask;
19962         self
19963     }
19964     #[inline]
device_render_areas(mut self, device_render_areas: &'a [Rect2D]) -> Self19965     pub fn device_render_areas(mut self, device_render_areas: &'a [Rect2D]) -> Self {
19966         self.inner.device_render_area_count = device_render_areas.len() as _;
19967         self.inner.p_device_render_areas = device_render_areas.as_ptr();
19968         self
19969     }
19970     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19971     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19972     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceGroupRenderPassBeginInfo19973     pub fn build(self) -> DeviceGroupRenderPassBeginInfo {
19974         self.inner
19975     }
19976 }
19977 #[repr(C)]
19978 #[cfg_attr(feature = "debug", derive(Debug))]
19979 #[derive(Copy, Clone)]
19980 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupCommandBufferBeginInfo.html>"]
19981 pub struct DeviceGroupCommandBufferBeginInfo {
19982     pub s_type: StructureType,
19983     pub p_next: *const c_void,
19984     pub device_mask: u32,
19985 }
19986 impl ::std::default::Default for DeviceGroupCommandBufferBeginInfo {
19987     #[inline]
default() -> Self19988     fn default() -> Self {
19989         Self {
19990             s_type: Self::STRUCTURE_TYPE,
19991             p_next: ::std::ptr::null(),
19992             device_mask: u32::default(),
19993         }
19994     }
19995 }
19996 unsafe impl TaggedStructure for DeviceGroupCommandBufferBeginInfo {
19997     const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO;
19998 }
19999 impl DeviceGroupCommandBufferBeginInfo {
builder<'a>() -> DeviceGroupCommandBufferBeginInfoBuilder<'a>20000     pub fn builder<'a>() -> DeviceGroupCommandBufferBeginInfoBuilder<'a> {
20001         DeviceGroupCommandBufferBeginInfoBuilder {
20002             inner: Self::default(),
20003             marker: ::std::marker::PhantomData,
20004         }
20005     }
20006 }
20007 #[repr(transparent)]
20008 pub struct DeviceGroupCommandBufferBeginInfoBuilder<'a> {
20009     inner: DeviceGroupCommandBufferBeginInfo,
20010     marker: ::std::marker::PhantomData<&'a ()>,
20011 }
20012 unsafe impl ExtendsCommandBufferBeginInfo for DeviceGroupCommandBufferBeginInfoBuilder<'_> {}
20013 unsafe impl ExtendsCommandBufferBeginInfo for DeviceGroupCommandBufferBeginInfo {}
20014 impl<'a> ::std::ops::Deref for DeviceGroupCommandBufferBeginInfoBuilder<'a> {
20015     type Target = DeviceGroupCommandBufferBeginInfo;
deref(&self) -> &Self::Target20016     fn deref(&self) -> &Self::Target {
20017         &self.inner
20018     }
20019 }
20020 impl<'a> ::std::ops::DerefMut for DeviceGroupCommandBufferBeginInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target20021     fn deref_mut(&mut self) -> &mut Self::Target {
20022         &mut self.inner
20023     }
20024 }
20025 impl<'a> DeviceGroupCommandBufferBeginInfoBuilder<'a> {
20026     #[inline]
device_mask(mut self, device_mask: u32) -> Self20027     pub fn device_mask(mut self, device_mask: u32) -> Self {
20028         self.inner.device_mask = device_mask;
20029         self
20030     }
20031     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20032     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20033     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceGroupCommandBufferBeginInfo20034     pub fn build(self) -> DeviceGroupCommandBufferBeginInfo {
20035         self.inner
20036     }
20037 }
20038 #[repr(C)]
20039 #[cfg_attr(feature = "debug", derive(Debug))]
20040 #[derive(Copy, Clone)]
20041 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupSubmitInfo.html>"]
20042 pub struct DeviceGroupSubmitInfo {
20043     pub s_type: StructureType,
20044     pub p_next: *const c_void,
20045     pub wait_semaphore_count: u32,
20046     pub p_wait_semaphore_device_indices: *const u32,
20047     pub command_buffer_count: u32,
20048     pub p_command_buffer_device_masks: *const u32,
20049     pub signal_semaphore_count: u32,
20050     pub p_signal_semaphore_device_indices: *const u32,
20051 }
20052 impl ::std::default::Default for DeviceGroupSubmitInfo {
20053     #[inline]
default() -> Self20054     fn default() -> Self {
20055         Self {
20056             s_type: Self::STRUCTURE_TYPE,
20057             p_next: ::std::ptr::null(),
20058             wait_semaphore_count: u32::default(),
20059             p_wait_semaphore_device_indices: ::std::ptr::null(),
20060             command_buffer_count: u32::default(),
20061             p_command_buffer_device_masks: ::std::ptr::null(),
20062             signal_semaphore_count: u32::default(),
20063             p_signal_semaphore_device_indices: ::std::ptr::null(),
20064         }
20065     }
20066 }
20067 unsafe impl TaggedStructure for DeviceGroupSubmitInfo {
20068     const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_SUBMIT_INFO;
20069 }
20070 impl DeviceGroupSubmitInfo {
builder<'a>() -> DeviceGroupSubmitInfoBuilder<'a>20071     pub fn builder<'a>() -> DeviceGroupSubmitInfoBuilder<'a> {
20072         DeviceGroupSubmitInfoBuilder {
20073             inner: Self::default(),
20074             marker: ::std::marker::PhantomData,
20075         }
20076     }
20077 }
20078 #[repr(transparent)]
20079 pub struct DeviceGroupSubmitInfoBuilder<'a> {
20080     inner: DeviceGroupSubmitInfo,
20081     marker: ::std::marker::PhantomData<&'a ()>,
20082 }
20083 unsafe impl ExtendsSubmitInfo for DeviceGroupSubmitInfoBuilder<'_> {}
20084 unsafe impl ExtendsSubmitInfo for DeviceGroupSubmitInfo {}
20085 impl<'a> ::std::ops::Deref for DeviceGroupSubmitInfoBuilder<'a> {
20086     type Target = DeviceGroupSubmitInfo;
deref(&self) -> &Self::Target20087     fn deref(&self) -> &Self::Target {
20088         &self.inner
20089     }
20090 }
20091 impl<'a> ::std::ops::DerefMut for DeviceGroupSubmitInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target20092     fn deref_mut(&mut self) -> &mut Self::Target {
20093         &mut self.inner
20094     }
20095 }
20096 impl<'a> DeviceGroupSubmitInfoBuilder<'a> {
20097     #[inline]
wait_semaphore_device_indices( mut self, wait_semaphore_device_indices: &'a [u32], ) -> Self20098     pub fn wait_semaphore_device_indices(
20099         mut self,
20100         wait_semaphore_device_indices: &'a [u32],
20101     ) -> Self {
20102         self.inner.wait_semaphore_count = wait_semaphore_device_indices.len() as _;
20103         self.inner.p_wait_semaphore_device_indices = wait_semaphore_device_indices.as_ptr();
20104         self
20105     }
20106     #[inline]
command_buffer_device_masks(mut self, command_buffer_device_masks: &'a [u32]) -> Self20107     pub fn command_buffer_device_masks(mut self, command_buffer_device_masks: &'a [u32]) -> Self {
20108         self.inner.command_buffer_count = command_buffer_device_masks.len() as _;
20109         self.inner.p_command_buffer_device_masks = command_buffer_device_masks.as_ptr();
20110         self
20111     }
20112     #[inline]
signal_semaphore_device_indices( mut self, signal_semaphore_device_indices: &'a [u32], ) -> Self20113     pub fn signal_semaphore_device_indices(
20114         mut self,
20115         signal_semaphore_device_indices: &'a [u32],
20116     ) -> Self {
20117         self.inner.signal_semaphore_count = signal_semaphore_device_indices.len() as _;
20118         self.inner.p_signal_semaphore_device_indices = signal_semaphore_device_indices.as_ptr();
20119         self
20120     }
20121     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20122     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20123     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceGroupSubmitInfo20124     pub fn build(self) -> DeviceGroupSubmitInfo {
20125         self.inner
20126     }
20127 }
20128 #[repr(C)]
20129 #[cfg_attr(feature = "debug", derive(Debug))]
20130 #[derive(Copy, Clone)]
20131 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupBindSparseInfo.html>"]
20132 pub struct DeviceGroupBindSparseInfo {
20133     pub s_type: StructureType,
20134     pub p_next: *const c_void,
20135     pub resource_device_index: u32,
20136     pub memory_device_index: u32,
20137 }
20138 impl ::std::default::Default for DeviceGroupBindSparseInfo {
20139     #[inline]
default() -> Self20140     fn default() -> Self {
20141         Self {
20142             s_type: Self::STRUCTURE_TYPE,
20143             p_next: ::std::ptr::null(),
20144             resource_device_index: u32::default(),
20145             memory_device_index: u32::default(),
20146         }
20147     }
20148 }
20149 unsafe impl TaggedStructure for DeviceGroupBindSparseInfo {
20150     const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_BIND_SPARSE_INFO;
20151 }
20152 impl DeviceGroupBindSparseInfo {
builder<'a>() -> DeviceGroupBindSparseInfoBuilder<'a>20153     pub fn builder<'a>() -> DeviceGroupBindSparseInfoBuilder<'a> {
20154         DeviceGroupBindSparseInfoBuilder {
20155             inner: Self::default(),
20156             marker: ::std::marker::PhantomData,
20157         }
20158     }
20159 }
20160 #[repr(transparent)]
20161 pub struct DeviceGroupBindSparseInfoBuilder<'a> {
20162     inner: DeviceGroupBindSparseInfo,
20163     marker: ::std::marker::PhantomData<&'a ()>,
20164 }
20165 unsafe impl ExtendsBindSparseInfo for DeviceGroupBindSparseInfoBuilder<'_> {}
20166 unsafe impl ExtendsBindSparseInfo for DeviceGroupBindSparseInfo {}
20167 impl<'a> ::std::ops::Deref for DeviceGroupBindSparseInfoBuilder<'a> {
20168     type Target = DeviceGroupBindSparseInfo;
deref(&self) -> &Self::Target20169     fn deref(&self) -> &Self::Target {
20170         &self.inner
20171     }
20172 }
20173 impl<'a> ::std::ops::DerefMut for DeviceGroupBindSparseInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target20174     fn deref_mut(&mut self) -> &mut Self::Target {
20175         &mut self.inner
20176     }
20177 }
20178 impl<'a> DeviceGroupBindSparseInfoBuilder<'a> {
20179     #[inline]
resource_device_index(mut self, resource_device_index: u32) -> Self20180     pub fn resource_device_index(mut self, resource_device_index: u32) -> Self {
20181         self.inner.resource_device_index = resource_device_index;
20182         self
20183     }
20184     #[inline]
memory_device_index(mut self, memory_device_index: u32) -> Self20185     pub fn memory_device_index(mut self, memory_device_index: u32) -> Self {
20186         self.inner.memory_device_index = memory_device_index;
20187         self
20188     }
20189     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20190     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20191     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceGroupBindSparseInfo20192     pub fn build(self) -> DeviceGroupBindSparseInfo {
20193         self.inner
20194     }
20195 }
20196 #[repr(C)]
20197 #[cfg_attr(feature = "debug", derive(Debug))]
20198 #[derive(Copy, Clone)]
20199 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupPresentCapabilitiesKHR.html>"]
20200 pub struct DeviceGroupPresentCapabilitiesKHR {
20201     pub s_type: StructureType,
20202     pub p_next: *mut c_void,
20203     pub present_mask: [u32; MAX_DEVICE_GROUP_SIZE],
20204     pub modes: DeviceGroupPresentModeFlagsKHR,
20205 }
20206 impl ::std::default::Default for DeviceGroupPresentCapabilitiesKHR {
20207     #[inline]
default() -> Self20208     fn default() -> Self {
20209         Self {
20210             s_type: Self::STRUCTURE_TYPE,
20211             p_next: ::std::ptr::null_mut(),
20212             present_mask: unsafe { ::std::mem::zeroed() },
20213             modes: DeviceGroupPresentModeFlagsKHR::default(),
20214         }
20215     }
20216 }
20217 unsafe impl TaggedStructure for DeviceGroupPresentCapabilitiesKHR {
20218     const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_PRESENT_CAPABILITIES_KHR;
20219 }
20220 impl DeviceGroupPresentCapabilitiesKHR {
builder<'a>() -> DeviceGroupPresentCapabilitiesKHRBuilder<'a>20221     pub fn builder<'a>() -> DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
20222         DeviceGroupPresentCapabilitiesKHRBuilder {
20223             inner: Self::default(),
20224             marker: ::std::marker::PhantomData,
20225         }
20226     }
20227 }
20228 #[repr(transparent)]
20229 pub struct DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
20230     inner: DeviceGroupPresentCapabilitiesKHR,
20231     marker: ::std::marker::PhantomData<&'a ()>,
20232 }
20233 impl<'a> ::std::ops::Deref for DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
20234     type Target = DeviceGroupPresentCapabilitiesKHR;
deref(&self) -> &Self::Target20235     fn deref(&self) -> &Self::Target {
20236         &self.inner
20237     }
20238 }
20239 impl<'a> ::std::ops::DerefMut for DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target20240     fn deref_mut(&mut self) -> &mut Self::Target {
20241         &mut self.inner
20242     }
20243 }
20244 impl<'a> DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
20245     #[inline]
present_mask(mut self, present_mask: [u32; MAX_DEVICE_GROUP_SIZE]) -> Self20246     pub fn present_mask(mut self, present_mask: [u32; MAX_DEVICE_GROUP_SIZE]) -> Self {
20247         self.inner.present_mask = present_mask;
20248         self
20249     }
20250     #[inline]
modes(mut self, modes: DeviceGroupPresentModeFlagsKHR) -> Self20251     pub fn modes(mut self, modes: DeviceGroupPresentModeFlagsKHR) -> Self {
20252         self.inner.modes = modes;
20253         self
20254     }
20255     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20256     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20257     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceGroupPresentCapabilitiesKHR20258     pub fn build(self) -> DeviceGroupPresentCapabilitiesKHR {
20259         self.inner
20260     }
20261 }
20262 #[repr(C)]
20263 #[cfg_attr(feature = "debug", derive(Debug))]
20264 #[derive(Copy, Clone)]
20265 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSwapchainCreateInfoKHR.html>"]
20266 pub struct ImageSwapchainCreateInfoKHR {
20267     pub s_type: StructureType,
20268     pub p_next: *const c_void,
20269     pub swapchain: SwapchainKHR,
20270 }
20271 impl ::std::default::Default for ImageSwapchainCreateInfoKHR {
20272     #[inline]
default() -> Self20273     fn default() -> Self {
20274         Self {
20275             s_type: Self::STRUCTURE_TYPE,
20276             p_next: ::std::ptr::null(),
20277             swapchain: SwapchainKHR::default(),
20278         }
20279     }
20280 }
20281 unsafe impl TaggedStructure for ImageSwapchainCreateInfoKHR {
20282     const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_SWAPCHAIN_CREATE_INFO_KHR;
20283 }
20284 impl ImageSwapchainCreateInfoKHR {
builder<'a>() -> ImageSwapchainCreateInfoKHRBuilder<'a>20285     pub fn builder<'a>() -> ImageSwapchainCreateInfoKHRBuilder<'a> {
20286         ImageSwapchainCreateInfoKHRBuilder {
20287             inner: Self::default(),
20288             marker: ::std::marker::PhantomData,
20289         }
20290     }
20291 }
20292 #[repr(transparent)]
20293 pub struct ImageSwapchainCreateInfoKHRBuilder<'a> {
20294     inner: ImageSwapchainCreateInfoKHR,
20295     marker: ::std::marker::PhantomData<&'a ()>,
20296 }
20297 unsafe impl ExtendsImageCreateInfo for ImageSwapchainCreateInfoKHRBuilder<'_> {}
20298 unsafe impl ExtendsImageCreateInfo for ImageSwapchainCreateInfoKHR {}
20299 impl<'a> ::std::ops::Deref for ImageSwapchainCreateInfoKHRBuilder<'a> {
20300     type Target = ImageSwapchainCreateInfoKHR;
deref(&self) -> &Self::Target20301     fn deref(&self) -> &Self::Target {
20302         &self.inner
20303     }
20304 }
20305 impl<'a> ::std::ops::DerefMut for ImageSwapchainCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target20306     fn deref_mut(&mut self) -> &mut Self::Target {
20307         &mut self.inner
20308     }
20309 }
20310 impl<'a> ImageSwapchainCreateInfoKHRBuilder<'a> {
20311     #[inline]
swapchain(mut self, swapchain: SwapchainKHR) -> Self20312     pub fn swapchain(mut self, swapchain: SwapchainKHR) -> Self {
20313         self.inner.swapchain = swapchain;
20314         self
20315     }
20316     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20317     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20318     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageSwapchainCreateInfoKHR20319     pub fn build(self) -> ImageSwapchainCreateInfoKHR {
20320         self.inner
20321     }
20322 }
20323 #[repr(C)]
20324 #[cfg_attr(feature = "debug", derive(Debug))]
20325 #[derive(Copy, Clone)]
20326 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindImageMemorySwapchainInfoKHR.html>"]
20327 pub struct BindImageMemorySwapchainInfoKHR {
20328     pub s_type: StructureType,
20329     pub p_next: *const c_void,
20330     pub swapchain: SwapchainKHR,
20331     pub image_index: u32,
20332 }
20333 impl ::std::default::Default for BindImageMemorySwapchainInfoKHR {
20334     #[inline]
default() -> Self20335     fn default() -> Self {
20336         Self {
20337             s_type: Self::STRUCTURE_TYPE,
20338             p_next: ::std::ptr::null(),
20339             swapchain: SwapchainKHR::default(),
20340             image_index: u32::default(),
20341         }
20342     }
20343 }
20344 unsafe impl TaggedStructure for BindImageMemorySwapchainInfoKHR {
20345     const STRUCTURE_TYPE: StructureType = StructureType::BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR;
20346 }
20347 impl BindImageMemorySwapchainInfoKHR {
builder<'a>() -> BindImageMemorySwapchainInfoKHRBuilder<'a>20348     pub fn builder<'a>() -> BindImageMemorySwapchainInfoKHRBuilder<'a> {
20349         BindImageMemorySwapchainInfoKHRBuilder {
20350             inner: Self::default(),
20351             marker: ::std::marker::PhantomData,
20352         }
20353     }
20354 }
20355 #[repr(transparent)]
20356 pub struct BindImageMemorySwapchainInfoKHRBuilder<'a> {
20357     inner: BindImageMemorySwapchainInfoKHR,
20358     marker: ::std::marker::PhantomData<&'a ()>,
20359 }
20360 unsafe impl ExtendsBindImageMemoryInfo for BindImageMemorySwapchainInfoKHRBuilder<'_> {}
20361 unsafe impl ExtendsBindImageMemoryInfo for BindImageMemorySwapchainInfoKHR {}
20362 impl<'a> ::std::ops::Deref for BindImageMemorySwapchainInfoKHRBuilder<'a> {
20363     type Target = BindImageMemorySwapchainInfoKHR;
deref(&self) -> &Self::Target20364     fn deref(&self) -> &Self::Target {
20365         &self.inner
20366     }
20367 }
20368 impl<'a> ::std::ops::DerefMut for BindImageMemorySwapchainInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target20369     fn deref_mut(&mut self) -> &mut Self::Target {
20370         &mut self.inner
20371     }
20372 }
20373 impl<'a> BindImageMemorySwapchainInfoKHRBuilder<'a> {
20374     #[inline]
swapchain(mut self, swapchain: SwapchainKHR) -> Self20375     pub fn swapchain(mut self, swapchain: SwapchainKHR) -> Self {
20376         self.inner.swapchain = swapchain;
20377         self
20378     }
20379     #[inline]
image_index(mut self, image_index: u32) -> Self20380     pub fn image_index(mut self, image_index: u32) -> Self {
20381         self.inner.image_index = image_index;
20382         self
20383     }
20384     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20385     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20386     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BindImageMemorySwapchainInfoKHR20387     pub fn build(self) -> BindImageMemorySwapchainInfoKHR {
20388         self.inner
20389     }
20390 }
20391 #[repr(C)]
20392 #[cfg_attr(feature = "debug", derive(Debug))]
20393 #[derive(Copy, Clone)]
20394 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAcquireNextImageInfoKHR.html>"]
20395 pub struct AcquireNextImageInfoKHR {
20396     pub s_type: StructureType,
20397     pub p_next: *const c_void,
20398     pub swapchain: SwapchainKHR,
20399     pub timeout: u64,
20400     pub semaphore: Semaphore,
20401     pub fence: Fence,
20402     pub device_mask: u32,
20403 }
20404 impl ::std::default::Default for AcquireNextImageInfoKHR {
20405     #[inline]
default() -> Self20406     fn default() -> Self {
20407         Self {
20408             s_type: Self::STRUCTURE_TYPE,
20409             p_next: ::std::ptr::null(),
20410             swapchain: SwapchainKHR::default(),
20411             timeout: u64::default(),
20412             semaphore: Semaphore::default(),
20413             fence: Fence::default(),
20414             device_mask: u32::default(),
20415         }
20416     }
20417 }
20418 unsafe impl TaggedStructure for AcquireNextImageInfoKHR {
20419     const STRUCTURE_TYPE: StructureType = StructureType::ACQUIRE_NEXT_IMAGE_INFO_KHR;
20420 }
20421 impl AcquireNextImageInfoKHR {
builder<'a>() -> AcquireNextImageInfoKHRBuilder<'a>20422     pub fn builder<'a>() -> AcquireNextImageInfoKHRBuilder<'a> {
20423         AcquireNextImageInfoKHRBuilder {
20424             inner: Self::default(),
20425             marker: ::std::marker::PhantomData,
20426         }
20427     }
20428 }
20429 #[repr(transparent)]
20430 pub struct AcquireNextImageInfoKHRBuilder<'a> {
20431     inner: AcquireNextImageInfoKHR,
20432     marker: ::std::marker::PhantomData<&'a ()>,
20433 }
20434 impl<'a> ::std::ops::Deref for AcquireNextImageInfoKHRBuilder<'a> {
20435     type Target = AcquireNextImageInfoKHR;
deref(&self) -> &Self::Target20436     fn deref(&self) -> &Self::Target {
20437         &self.inner
20438     }
20439 }
20440 impl<'a> ::std::ops::DerefMut for AcquireNextImageInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target20441     fn deref_mut(&mut self) -> &mut Self::Target {
20442         &mut self.inner
20443     }
20444 }
20445 impl<'a> AcquireNextImageInfoKHRBuilder<'a> {
20446     #[inline]
swapchain(mut self, swapchain: SwapchainKHR) -> Self20447     pub fn swapchain(mut self, swapchain: SwapchainKHR) -> Self {
20448         self.inner.swapchain = swapchain;
20449         self
20450     }
20451     #[inline]
timeout(mut self, timeout: u64) -> Self20452     pub fn timeout(mut self, timeout: u64) -> Self {
20453         self.inner.timeout = timeout;
20454         self
20455     }
20456     #[inline]
semaphore(mut self, semaphore: Semaphore) -> Self20457     pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
20458         self.inner.semaphore = semaphore;
20459         self
20460     }
20461     #[inline]
fence(mut self, fence: Fence) -> Self20462     pub fn fence(mut self, fence: Fence) -> Self {
20463         self.inner.fence = fence;
20464         self
20465     }
20466     #[inline]
device_mask(mut self, device_mask: u32) -> Self20467     pub fn device_mask(mut self, device_mask: u32) -> Self {
20468         self.inner.device_mask = device_mask;
20469         self
20470     }
20471     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20472     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20473     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AcquireNextImageInfoKHR20474     pub fn build(self) -> AcquireNextImageInfoKHR {
20475         self.inner
20476     }
20477 }
20478 #[repr(C)]
20479 #[cfg_attr(feature = "debug", derive(Debug))]
20480 #[derive(Copy, Clone)]
20481 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupPresentInfoKHR.html>"]
20482 pub struct DeviceGroupPresentInfoKHR {
20483     pub s_type: StructureType,
20484     pub p_next: *const c_void,
20485     pub swapchain_count: u32,
20486     pub p_device_masks: *const u32,
20487     pub mode: DeviceGroupPresentModeFlagsKHR,
20488 }
20489 impl ::std::default::Default for DeviceGroupPresentInfoKHR {
20490     #[inline]
default() -> Self20491     fn default() -> Self {
20492         Self {
20493             s_type: Self::STRUCTURE_TYPE,
20494             p_next: ::std::ptr::null(),
20495             swapchain_count: u32::default(),
20496             p_device_masks: ::std::ptr::null(),
20497             mode: DeviceGroupPresentModeFlagsKHR::default(),
20498         }
20499     }
20500 }
20501 unsafe impl TaggedStructure for DeviceGroupPresentInfoKHR {
20502     const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_PRESENT_INFO_KHR;
20503 }
20504 impl DeviceGroupPresentInfoKHR {
builder<'a>() -> DeviceGroupPresentInfoKHRBuilder<'a>20505     pub fn builder<'a>() -> DeviceGroupPresentInfoKHRBuilder<'a> {
20506         DeviceGroupPresentInfoKHRBuilder {
20507             inner: Self::default(),
20508             marker: ::std::marker::PhantomData,
20509         }
20510     }
20511 }
20512 #[repr(transparent)]
20513 pub struct DeviceGroupPresentInfoKHRBuilder<'a> {
20514     inner: DeviceGroupPresentInfoKHR,
20515     marker: ::std::marker::PhantomData<&'a ()>,
20516 }
20517 unsafe impl ExtendsPresentInfoKHR for DeviceGroupPresentInfoKHRBuilder<'_> {}
20518 unsafe impl ExtendsPresentInfoKHR for DeviceGroupPresentInfoKHR {}
20519 impl<'a> ::std::ops::Deref for DeviceGroupPresentInfoKHRBuilder<'a> {
20520     type Target = DeviceGroupPresentInfoKHR;
deref(&self) -> &Self::Target20521     fn deref(&self) -> &Self::Target {
20522         &self.inner
20523     }
20524 }
20525 impl<'a> ::std::ops::DerefMut for DeviceGroupPresentInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target20526     fn deref_mut(&mut self) -> &mut Self::Target {
20527         &mut self.inner
20528     }
20529 }
20530 impl<'a> DeviceGroupPresentInfoKHRBuilder<'a> {
20531     #[inline]
device_masks(mut self, device_masks: &'a [u32]) -> Self20532     pub fn device_masks(mut self, device_masks: &'a [u32]) -> Self {
20533         self.inner.swapchain_count = device_masks.len() as _;
20534         self.inner.p_device_masks = device_masks.as_ptr();
20535         self
20536     }
20537     #[inline]
mode(mut self, mode: DeviceGroupPresentModeFlagsKHR) -> Self20538     pub fn mode(mut self, mode: DeviceGroupPresentModeFlagsKHR) -> Self {
20539         self.inner.mode = mode;
20540         self
20541     }
20542     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20543     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20544     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceGroupPresentInfoKHR20545     pub fn build(self) -> DeviceGroupPresentInfoKHR {
20546         self.inner
20547     }
20548 }
20549 #[repr(C)]
20550 #[cfg_attr(feature = "debug", derive(Debug))]
20551 #[derive(Copy, Clone)]
20552 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupDeviceCreateInfo.html>"]
20553 pub struct DeviceGroupDeviceCreateInfo {
20554     pub s_type: StructureType,
20555     pub p_next: *const c_void,
20556     pub physical_device_count: u32,
20557     pub p_physical_devices: *const PhysicalDevice,
20558 }
20559 impl ::std::default::Default for DeviceGroupDeviceCreateInfo {
20560     #[inline]
default() -> Self20561     fn default() -> Self {
20562         Self {
20563             s_type: Self::STRUCTURE_TYPE,
20564             p_next: ::std::ptr::null(),
20565             physical_device_count: u32::default(),
20566             p_physical_devices: ::std::ptr::null(),
20567         }
20568     }
20569 }
20570 unsafe impl TaggedStructure for DeviceGroupDeviceCreateInfo {
20571     const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_DEVICE_CREATE_INFO;
20572 }
20573 impl DeviceGroupDeviceCreateInfo {
builder<'a>() -> DeviceGroupDeviceCreateInfoBuilder<'a>20574     pub fn builder<'a>() -> DeviceGroupDeviceCreateInfoBuilder<'a> {
20575         DeviceGroupDeviceCreateInfoBuilder {
20576             inner: Self::default(),
20577             marker: ::std::marker::PhantomData,
20578         }
20579     }
20580 }
20581 #[repr(transparent)]
20582 pub struct DeviceGroupDeviceCreateInfoBuilder<'a> {
20583     inner: DeviceGroupDeviceCreateInfo,
20584     marker: ::std::marker::PhantomData<&'a ()>,
20585 }
20586 unsafe impl ExtendsDeviceCreateInfo for DeviceGroupDeviceCreateInfoBuilder<'_> {}
20587 unsafe impl ExtendsDeviceCreateInfo for DeviceGroupDeviceCreateInfo {}
20588 impl<'a> ::std::ops::Deref for DeviceGroupDeviceCreateInfoBuilder<'a> {
20589     type Target = DeviceGroupDeviceCreateInfo;
deref(&self) -> &Self::Target20590     fn deref(&self) -> &Self::Target {
20591         &self.inner
20592     }
20593 }
20594 impl<'a> ::std::ops::DerefMut for DeviceGroupDeviceCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target20595     fn deref_mut(&mut self) -> &mut Self::Target {
20596         &mut self.inner
20597     }
20598 }
20599 impl<'a> DeviceGroupDeviceCreateInfoBuilder<'a> {
20600     #[inline]
physical_devices(mut self, physical_devices: &'a [PhysicalDevice]) -> Self20601     pub fn physical_devices(mut self, physical_devices: &'a [PhysicalDevice]) -> Self {
20602         self.inner.physical_device_count = physical_devices.len() as _;
20603         self.inner.p_physical_devices = physical_devices.as_ptr();
20604         self
20605     }
20606     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20607     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20608     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceGroupDeviceCreateInfo20609     pub fn build(self) -> DeviceGroupDeviceCreateInfo {
20610         self.inner
20611     }
20612 }
20613 #[repr(C)]
20614 #[cfg_attr(feature = "debug", derive(Debug))]
20615 #[derive(Copy, Clone)]
20616 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupSwapchainCreateInfoKHR.html>"]
20617 pub struct DeviceGroupSwapchainCreateInfoKHR {
20618     pub s_type: StructureType,
20619     pub p_next: *const c_void,
20620     pub modes: DeviceGroupPresentModeFlagsKHR,
20621 }
20622 impl ::std::default::Default for DeviceGroupSwapchainCreateInfoKHR {
20623     #[inline]
default() -> Self20624     fn default() -> Self {
20625         Self {
20626             s_type: Self::STRUCTURE_TYPE,
20627             p_next: ::std::ptr::null(),
20628             modes: DeviceGroupPresentModeFlagsKHR::default(),
20629         }
20630     }
20631 }
20632 unsafe impl TaggedStructure for DeviceGroupSwapchainCreateInfoKHR {
20633     const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR;
20634 }
20635 impl DeviceGroupSwapchainCreateInfoKHR {
builder<'a>() -> DeviceGroupSwapchainCreateInfoKHRBuilder<'a>20636     pub fn builder<'a>() -> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
20637         DeviceGroupSwapchainCreateInfoKHRBuilder {
20638             inner: Self::default(),
20639             marker: ::std::marker::PhantomData,
20640         }
20641     }
20642 }
20643 #[repr(transparent)]
20644 pub struct DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
20645     inner: DeviceGroupSwapchainCreateInfoKHR,
20646     marker: ::std::marker::PhantomData<&'a ()>,
20647 }
20648 unsafe impl ExtendsSwapchainCreateInfoKHR for DeviceGroupSwapchainCreateInfoKHRBuilder<'_> {}
20649 unsafe impl ExtendsSwapchainCreateInfoKHR for DeviceGroupSwapchainCreateInfoKHR {}
20650 impl<'a> ::std::ops::Deref for DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
20651     type Target = DeviceGroupSwapchainCreateInfoKHR;
deref(&self) -> &Self::Target20652     fn deref(&self) -> &Self::Target {
20653         &self.inner
20654     }
20655 }
20656 impl<'a> ::std::ops::DerefMut for DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target20657     fn deref_mut(&mut self) -> &mut Self::Target {
20658         &mut self.inner
20659     }
20660 }
20661 impl<'a> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
20662     #[inline]
modes(mut self, modes: DeviceGroupPresentModeFlagsKHR) -> Self20663     pub fn modes(mut self, modes: DeviceGroupPresentModeFlagsKHR) -> Self {
20664         self.inner.modes = modes;
20665         self
20666     }
20667     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20668     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20669     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceGroupSwapchainCreateInfoKHR20670     pub fn build(self) -> DeviceGroupSwapchainCreateInfoKHR {
20671         self.inner
20672     }
20673 }
20674 #[repr(C)]
20675 #[cfg_attr(feature = "debug", derive(Debug))]
20676 #[derive(Copy, Clone, Default)]
20677 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorUpdateTemplateEntry.html>"]
20678 pub struct DescriptorUpdateTemplateEntry {
20679     pub dst_binding: u32,
20680     pub dst_array_element: u32,
20681     pub descriptor_count: u32,
20682     pub descriptor_type: DescriptorType,
20683     pub offset: usize,
20684     pub stride: usize,
20685 }
20686 impl DescriptorUpdateTemplateEntry {
builder<'a>() -> DescriptorUpdateTemplateEntryBuilder<'a>20687     pub fn builder<'a>() -> DescriptorUpdateTemplateEntryBuilder<'a> {
20688         DescriptorUpdateTemplateEntryBuilder {
20689             inner: Self::default(),
20690             marker: ::std::marker::PhantomData,
20691         }
20692     }
20693 }
20694 #[repr(transparent)]
20695 pub struct DescriptorUpdateTemplateEntryBuilder<'a> {
20696     inner: DescriptorUpdateTemplateEntry,
20697     marker: ::std::marker::PhantomData<&'a ()>,
20698 }
20699 impl<'a> ::std::ops::Deref for DescriptorUpdateTemplateEntryBuilder<'a> {
20700     type Target = DescriptorUpdateTemplateEntry;
deref(&self) -> &Self::Target20701     fn deref(&self) -> &Self::Target {
20702         &self.inner
20703     }
20704 }
20705 impl<'a> ::std::ops::DerefMut for DescriptorUpdateTemplateEntryBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target20706     fn deref_mut(&mut self) -> &mut Self::Target {
20707         &mut self.inner
20708     }
20709 }
20710 impl<'a> DescriptorUpdateTemplateEntryBuilder<'a> {
20711     #[inline]
dst_binding(mut self, dst_binding: u32) -> Self20712     pub fn dst_binding(mut self, dst_binding: u32) -> Self {
20713         self.inner.dst_binding = dst_binding;
20714         self
20715     }
20716     #[inline]
dst_array_element(mut self, dst_array_element: u32) -> Self20717     pub fn dst_array_element(mut self, dst_array_element: u32) -> Self {
20718         self.inner.dst_array_element = dst_array_element;
20719         self
20720     }
20721     #[inline]
descriptor_count(mut self, descriptor_count: u32) -> Self20722     pub fn descriptor_count(mut self, descriptor_count: u32) -> Self {
20723         self.inner.descriptor_count = descriptor_count;
20724         self
20725     }
20726     #[inline]
descriptor_type(mut self, descriptor_type: DescriptorType) -> Self20727     pub fn descriptor_type(mut self, descriptor_type: DescriptorType) -> Self {
20728         self.inner.descriptor_type = descriptor_type;
20729         self
20730     }
20731     #[inline]
offset(mut self, offset: usize) -> Self20732     pub fn offset(mut self, offset: usize) -> Self {
20733         self.inner.offset = offset;
20734         self
20735     }
20736     #[inline]
stride(mut self, stride: usize) -> Self20737     pub fn stride(mut self, stride: usize) -> Self {
20738         self.inner.stride = stride;
20739         self
20740     }
20741     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20742     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20743     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorUpdateTemplateEntry20744     pub fn build(self) -> DescriptorUpdateTemplateEntry {
20745         self.inner
20746     }
20747 }
20748 #[repr(C)]
20749 #[cfg_attr(feature = "debug", derive(Debug))]
20750 #[derive(Copy, Clone)]
20751 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorUpdateTemplateCreateInfo.html>"]
20752 pub struct DescriptorUpdateTemplateCreateInfo {
20753     pub s_type: StructureType,
20754     pub p_next: *const c_void,
20755     pub flags: DescriptorUpdateTemplateCreateFlags,
20756     pub descriptor_update_entry_count: u32,
20757     pub p_descriptor_update_entries: *const DescriptorUpdateTemplateEntry,
20758     pub template_type: DescriptorUpdateTemplateType,
20759     pub descriptor_set_layout: DescriptorSetLayout,
20760     pub pipeline_bind_point: PipelineBindPoint,
20761     pub pipeline_layout: PipelineLayout,
20762     pub set: u32,
20763 }
20764 impl ::std::default::Default for DescriptorUpdateTemplateCreateInfo {
20765     #[inline]
default() -> Self20766     fn default() -> Self {
20767         Self {
20768             s_type: Self::STRUCTURE_TYPE,
20769             p_next: ::std::ptr::null(),
20770             flags: DescriptorUpdateTemplateCreateFlags::default(),
20771             descriptor_update_entry_count: u32::default(),
20772             p_descriptor_update_entries: ::std::ptr::null(),
20773             template_type: DescriptorUpdateTemplateType::default(),
20774             descriptor_set_layout: DescriptorSetLayout::default(),
20775             pipeline_bind_point: PipelineBindPoint::default(),
20776             pipeline_layout: PipelineLayout::default(),
20777             set: u32::default(),
20778         }
20779     }
20780 }
20781 unsafe impl TaggedStructure for DescriptorUpdateTemplateCreateInfo {
20782     const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO;
20783 }
20784 impl DescriptorUpdateTemplateCreateInfo {
builder<'a>() -> DescriptorUpdateTemplateCreateInfoBuilder<'a>20785     pub fn builder<'a>() -> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
20786         DescriptorUpdateTemplateCreateInfoBuilder {
20787             inner: Self::default(),
20788             marker: ::std::marker::PhantomData,
20789         }
20790     }
20791 }
20792 #[repr(transparent)]
20793 pub struct DescriptorUpdateTemplateCreateInfoBuilder<'a> {
20794     inner: DescriptorUpdateTemplateCreateInfo,
20795     marker: ::std::marker::PhantomData<&'a ()>,
20796 }
20797 impl<'a> ::std::ops::Deref for DescriptorUpdateTemplateCreateInfoBuilder<'a> {
20798     type Target = DescriptorUpdateTemplateCreateInfo;
deref(&self) -> &Self::Target20799     fn deref(&self) -> &Self::Target {
20800         &self.inner
20801     }
20802 }
20803 impl<'a> ::std::ops::DerefMut for DescriptorUpdateTemplateCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target20804     fn deref_mut(&mut self) -> &mut Self::Target {
20805         &mut self.inner
20806     }
20807 }
20808 impl<'a> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
20809     #[inline]
flags(mut self, flags: DescriptorUpdateTemplateCreateFlags) -> Self20810     pub fn flags(mut self, flags: DescriptorUpdateTemplateCreateFlags) -> Self {
20811         self.inner.flags = flags;
20812         self
20813     }
20814     #[inline]
descriptor_update_entries( mut self, descriptor_update_entries: &'a [DescriptorUpdateTemplateEntry], ) -> Self20815     pub fn descriptor_update_entries(
20816         mut self,
20817         descriptor_update_entries: &'a [DescriptorUpdateTemplateEntry],
20818     ) -> Self {
20819         self.inner.descriptor_update_entry_count = descriptor_update_entries.len() as _;
20820         self.inner.p_descriptor_update_entries = descriptor_update_entries.as_ptr();
20821         self
20822     }
20823     #[inline]
template_type(mut self, template_type: DescriptorUpdateTemplateType) -> Self20824     pub fn template_type(mut self, template_type: DescriptorUpdateTemplateType) -> Self {
20825         self.inner.template_type = template_type;
20826         self
20827     }
20828     #[inline]
descriptor_set_layout(mut self, descriptor_set_layout: DescriptorSetLayout) -> Self20829     pub fn descriptor_set_layout(mut self, descriptor_set_layout: DescriptorSetLayout) -> Self {
20830         self.inner.descriptor_set_layout = descriptor_set_layout;
20831         self
20832     }
20833     #[inline]
pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self20834     pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self {
20835         self.inner.pipeline_bind_point = pipeline_bind_point;
20836         self
20837     }
20838     #[inline]
pipeline_layout(mut self, pipeline_layout: PipelineLayout) -> Self20839     pub fn pipeline_layout(mut self, pipeline_layout: PipelineLayout) -> Self {
20840         self.inner.pipeline_layout = pipeline_layout;
20841         self
20842     }
20843     #[inline]
set(mut self, set: u32) -> Self20844     pub fn set(mut self, set: u32) -> Self {
20845         self.inner.set = set;
20846         self
20847     }
20848     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20849     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20850     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorUpdateTemplateCreateInfo20851     pub fn build(self) -> DescriptorUpdateTemplateCreateInfo {
20852         self.inner
20853     }
20854 }
20855 #[repr(C)]
20856 #[cfg_attr(feature = "debug", derive(Debug))]
20857 #[derive(Copy, Clone, Default)]
20858 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkXYColorEXT.html>"]
20859 pub struct XYColorEXT {
20860     pub x: f32,
20861     pub y: f32,
20862 }
20863 impl XYColorEXT {
builder<'a>() -> XYColorEXTBuilder<'a>20864     pub fn builder<'a>() -> XYColorEXTBuilder<'a> {
20865         XYColorEXTBuilder {
20866             inner: Self::default(),
20867             marker: ::std::marker::PhantomData,
20868         }
20869     }
20870 }
20871 #[repr(transparent)]
20872 pub struct XYColorEXTBuilder<'a> {
20873     inner: XYColorEXT,
20874     marker: ::std::marker::PhantomData<&'a ()>,
20875 }
20876 impl<'a> ::std::ops::Deref for XYColorEXTBuilder<'a> {
20877     type Target = XYColorEXT;
deref(&self) -> &Self::Target20878     fn deref(&self) -> &Self::Target {
20879         &self.inner
20880     }
20881 }
20882 impl<'a> ::std::ops::DerefMut for XYColorEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target20883     fn deref_mut(&mut self) -> &mut Self::Target {
20884         &mut self.inner
20885     }
20886 }
20887 impl<'a> XYColorEXTBuilder<'a> {
20888     #[inline]
x(mut self, x: f32) -> Self20889     pub fn x(mut self, x: f32) -> Self {
20890         self.inner.x = x;
20891         self
20892     }
20893     #[inline]
y(mut self, y: f32) -> Self20894     pub fn y(mut self, y: f32) -> Self {
20895         self.inner.y = y;
20896         self
20897     }
20898     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20899     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20900     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> XYColorEXT20901     pub fn build(self) -> XYColorEXT {
20902         self.inner
20903     }
20904 }
20905 #[repr(C)]
20906 #[cfg_attr(feature = "debug", derive(Debug))]
20907 #[derive(Copy, Clone)]
20908 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePresentIdFeaturesKHR.html>"]
20909 pub struct PhysicalDevicePresentIdFeaturesKHR {
20910     pub s_type: StructureType,
20911     pub p_next: *mut c_void,
20912     pub present_id: Bool32,
20913 }
20914 impl ::std::default::Default for PhysicalDevicePresentIdFeaturesKHR {
20915     #[inline]
default() -> Self20916     fn default() -> Self {
20917         Self {
20918             s_type: Self::STRUCTURE_TYPE,
20919             p_next: ::std::ptr::null_mut(),
20920             present_id: Bool32::default(),
20921         }
20922     }
20923 }
20924 unsafe impl TaggedStructure for PhysicalDevicePresentIdFeaturesKHR {
20925     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
20926 }
20927 impl PhysicalDevicePresentIdFeaturesKHR {
builder<'a>() -> PhysicalDevicePresentIdFeaturesKHRBuilder<'a>20928     pub fn builder<'a>() -> PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
20929         PhysicalDevicePresentIdFeaturesKHRBuilder {
20930             inner: Self::default(),
20931             marker: ::std::marker::PhantomData,
20932         }
20933     }
20934 }
20935 #[repr(transparent)]
20936 pub struct PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
20937     inner: PhysicalDevicePresentIdFeaturesKHR,
20938     marker: ::std::marker::PhantomData<&'a ()>,
20939 }
20940 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentIdFeaturesKHRBuilder<'_> {}
20941 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentIdFeaturesKHR {}
20942 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentIdFeaturesKHRBuilder<'_> {}
20943 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentIdFeaturesKHR {}
20944 impl<'a> ::std::ops::Deref for PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
20945     type Target = PhysicalDevicePresentIdFeaturesKHR;
deref(&self) -> &Self::Target20946     fn deref(&self) -> &Self::Target {
20947         &self.inner
20948     }
20949 }
20950 impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target20951     fn deref_mut(&mut self) -> &mut Self::Target {
20952         &mut self.inner
20953     }
20954 }
20955 impl<'a> PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
20956     #[inline]
present_id(mut self, present_id: bool) -> Self20957     pub fn present_id(mut self, present_id: bool) -> Self {
20958         self.inner.present_id = present_id.into();
20959         self
20960     }
20961     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20962     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20963     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePresentIdFeaturesKHR20964     pub fn build(self) -> PhysicalDevicePresentIdFeaturesKHR {
20965         self.inner
20966     }
20967 }
20968 #[repr(C)]
20969 #[cfg_attr(feature = "debug", derive(Debug))]
20970 #[derive(Copy, Clone)]
20971 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentIdKHR.html>"]
20972 pub struct PresentIdKHR {
20973     pub s_type: StructureType,
20974     pub p_next: *const c_void,
20975     pub swapchain_count: u32,
20976     pub p_present_ids: *const u64,
20977 }
20978 impl ::std::default::Default for PresentIdKHR {
20979     #[inline]
default() -> Self20980     fn default() -> Self {
20981         Self {
20982             s_type: Self::STRUCTURE_TYPE,
20983             p_next: ::std::ptr::null(),
20984             swapchain_count: u32::default(),
20985             p_present_ids: ::std::ptr::null(),
20986         }
20987     }
20988 }
20989 unsafe impl TaggedStructure for PresentIdKHR {
20990     const STRUCTURE_TYPE: StructureType = StructureType::PRESENT_ID_KHR;
20991 }
20992 impl PresentIdKHR {
builder<'a>() -> PresentIdKHRBuilder<'a>20993     pub fn builder<'a>() -> PresentIdKHRBuilder<'a> {
20994         PresentIdKHRBuilder {
20995             inner: Self::default(),
20996             marker: ::std::marker::PhantomData,
20997         }
20998     }
20999 }
21000 #[repr(transparent)]
21001 pub struct PresentIdKHRBuilder<'a> {
21002     inner: PresentIdKHR,
21003     marker: ::std::marker::PhantomData<&'a ()>,
21004 }
21005 unsafe impl ExtendsPresentInfoKHR for PresentIdKHRBuilder<'_> {}
21006 unsafe impl ExtendsPresentInfoKHR for PresentIdKHR {}
21007 impl<'a> ::std::ops::Deref for PresentIdKHRBuilder<'a> {
21008     type Target = PresentIdKHR;
deref(&self) -> &Self::Target21009     fn deref(&self) -> &Self::Target {
21010         &self.inner
21011     }
21012 }
21013 impl<'a> ::std::ops::DerefMut for PresentIdKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21014     fn deref_mut(&mut self) -> &mut Self::Target {
21015         &mut self.inner
21016     }
21017 }
21018 impl<'a> PresentIdKHRBuilder<'a> {
21019     #[inline]
present_ids(mut self, present_ids: &'a [u64]) -> Self21020     pub fn present_ids(mut self, present_ids: &'a [u64]) -> Self {
21021         self.inner.swapchain_count = present_ids.len() as _;
21022         self.inner.p_present_ids = present_ids.as_ptr();
21023         self
21024     }
21025     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21026     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21027     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PresentIdKHR21028     pub fn build(self) -> PresentIdKHR {
21029         self.inner
21030     }
21031 }
21032 #[repr(C)]
21033 #[cfg_attr(feature = "debug", derive(Debug))]
21034 #[derive(Copy, Clone)]
21035 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePresentWaitFeaturesKHR.html>"]
21036 pub struct PhysicalDevicePresentWaitFeaturesKHR {
21037     pub s_type: StructureType,
21038     pub p_next: *mut c_void,
21039     pub present_wait: Bool32,
21040 }
21041 impl ::std::default::Default for PhysicalDevicePresentWaitFeaturesKHR {
21042     #[inline]
default() -> Self21043     fn default() -> Self {
21044         Self {
21045             s_type: Self::STRUCTURE_TYPE,
21046             p_next: ::std::ptr::null_mut(),
21047             present_wait: Bool32::default(),
21048         }
21049     }
21050 }
21051 unsafe impl TaggedStructure for PhysicalDevicePresentWaitFeaturesKHR {
21052     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
21053 }
21054 impl PhysicalDevicePresentWaitFeaturesKHR {
builder<'a>() -> PhysicalDevicePresentWaitFeaturesKHRBuilder<'a>21055     pub fn builder<'a>() -> PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
21056         PhysicalDevicePresentWaitFeaturesKHRBuilder {
21057             inner: Self::default(),
21058             marker: ::std::marker::PhantomData,
21059         }
21060     }
21061 }
21062 #[repr(transparent)]
21063 pub struct PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
21064     inner: PhysicalDevicePresentWaitFeaturesKHR,
21065     marker: ::std::marker::PhantomData<&'a ()>,
21066 }
21067 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentWaitFeaturesKHRBuilder<'_> {}
21068 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentWaitFeaturesKHR {}
21069 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentWaitFeaturesKHRBuilder<'_> {}
21070 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentWaitFeaturesKHR {}
21071 impl<'a> ::std::ops::Deref for PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
21072     type Target = PhysicalDevicePresentWaitFeaturesKHR;
deref(&self) -> &Self::Target21073     fn deref(&self) -> &Self::Target {
21074         &self.inner
21075     }
21076 }
21077 impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21078     fn deref_mut(&mut self) -> &mut Self::Target {
21079         &mut self.inner
21080     }
21081 }
21082 impl<'a> PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
21083     #[inline]
present_wait(mut self, present_wait: bool) -> Self21084     pub fn present_wait(mut self, present_wait: bool) -> Self {
21085         self.inner.present_wait = present_wait.into();
21086         self
21087     }
21088     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21089     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21090     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePresentWaitFeaturesKHR21091     pub fn build(self) -> PhysicalDevicePresentWaitFeaturesKHR {
21092         self.inner
21093     }
21094 }
21095 #[repr(C)]
21096 #[cfg_attr(feature = "debug", derive(Debug))]
21097 #[derive(Copy, Clone)]
21098 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkHdrMetadataEXT.html>"]
21099 pub struct HdrMetadataEXT {
21100     pub s_type: StructureType,
21101     pub p_next: *const c_void,
21102     pub display_primary_red: XYColorEXT,
21103     pub display_primary_green: XYColorEXT,
21104     pub display_primary_blue: XYColorEXT,
21105     pub white_point: XYColorEXT,
21106     pub max_luminance: f32,
21107     pub min_luminance: f32,
21108     pub max_content_light_level: f32,
21109     pub max_frame_average_light_level: f32,
21110 }
21111 impl ::std::default::Default for HdrMetadataEXT {
21112     #[inline]
default() -> Self21113     fn default() -> Self {
21114         Self {
21115             s_type: Self::STRUCTURE_TYPE,
21116             p_next: ::std::ptr::null(),
21117             display_primary_red: XYColorEXT::default(),
21118             display_primary_green: XYColorEXT::default(),
21119             display_primary_blue: XYColorEXT::default(),
21120             white_point: XYColorEXT::default(),
21121             max_luminance: f32::default(),
21122             min_luminance: f32::default(),
21123             max_content_light_level: f32::default(),
21124             max_frame_average_light_level: f32::default(),
21125         }
21126     }
21127 }
21128 unsafe impl TaggedStructure for HdrMetadataEXT {
21129     const STRUCTURE_TYPE: StructureType = StructureType::HDR_METADATA_EXT;
21130 }
21131 impl HdrMetadataEXT {
builder<'a>() -> HdrMetadataEXTBuilder<'a>21132     pub fn builder<'a>() -> HdrMetadataEXTBuilder<'a> {
21133         HdrMetadataEXTBuilder {
21134             inner: Self::default(),
21135             marker: ::std::marker::PhantomData,
21136         }
21137     }
21138 }
21139 #[repr(transparent)]
21140 pub struct HdrMetadataEXTBuilder<'a> {
21141     inner: HdrMetadataEXT,
21142     marker: ::std::marker::PhantomData<&'a ()>,
21143 }
21144 impl<'a> ::std::ops::Deref for HdrMetadataEXTBuilder<'a> {
21145     type Target = HdrMetadataEXT;
deref(&self) -> &Self::Target21146     fn deref(&self) -> &Self::Target {
21147         &self.inner
21148     }
21149 }
21150 impl<'a> ::std::ops::DerefMut for HdrMetadataEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21151     fn deref_mut(&mut self) -> &mut Self::Target {
21152         &mut self.inner
21153     }
21154 }
21155 impl<'a> HdrMetadataEXTBuilder<'a> {
21156     #[inline]
display_primary_red(mut self, display_primary_red: XYColorEXT) -> Self21157     pub fn display_primary_red(mut self, display_primary_red: XYColorEXT) -> Self {
21158         self.inner.display_primary_red = display_primary_red;
21159         self
21160     }
21161     #[inline]
display_primary_green(mut self, display_primary_green: XYColorEXT) -> Self21162     pub fn display_primary_green(mut self, display_primary_green: XYColorEXT) -> Self {
21163         self.inner.display_primary_green = display_primary_green;
21164         self
21165     }
21166     #[inline]
display_primary_blue(mut self, display_primary_blue: XYColorEXT) -> Self21167     pub fn display_primary_blue(mut self, display_primary_blue: XYColorEXT) -> Self {
21168         self.inner.display_primary_blue = display_primary_blue;
21169         self
21170     }
21171     #[inline]
white_point(mut self, white_point: XYColorEXT) -> Self21172     pub fn white_point(mut self, white_point: XYColorEXT) -> Self {
21173         self.inner.white_point = white_point;
21174         self
21175     }
21176     #[inline]
max_luminance(mut self, max_luminance: f32) -> Self21177     pub fn max_luminance(mut self, max_luminance: f32) -> Self {
21178         self.inner.max_luminance = max_luminance;
21179         self
21180     }
21181     #[inline]
min_luminance(mut self, min_luminance: f32) -> Self21182     pub fn min_luminance(mut self, min_luminance: f32) -> Self {
21183         self.inner.min_luminance = min_luminance;
21184         self
21185     }
21186     #[inline]
max_content_light_level(mut self, max_content_light_level: f32) -> Self21187     pub fn max_content_light_level(mut self, max_content_light_level: f32) -> Self {
21188         self.inner.max_content_light_level = max_content_light_level;
21189         self
21190     }
21191     #[inline]
max_frame_average_light_level(mut self, max_frame_average_light_level: f32) -> Self21192     pub fn max_frame_average_light_level(mut self, max_frame_average_light_level: f32) -> Self {
21193         self.inner.max_frame_average_light_level = max_frame_average_light_level;
21194         self
21195     }
21196     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21197     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21198     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> HdrMetadataEXT21199     pub fn build(self) -> HdrMetadataEXT {
21200         self.inner
21201     }
21202 }
21203 #[repr(C)]
21204 #[cfg_attr(feature = "debug", derive(Debug))]
21205 #[derive(Copy, Clone)]
21206 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayNativeHdrSurfaceCapabilitiesAMD.html>"]
21207 pub struct DisplayNativeHdrSurfaceCapabilitiesAMD {
21208     pub s_type: StructureType,
21209     pub p_next: *mut c_void,
21210     pub local_dimming_support: Bool32,
21211 }
21212 impl ::std::default::Default for DisplayNativeHdrSurfaceCapabilitiesAMD {
21213     #[inline]
default() -> Self21214     fn default() -> Self {
21215         Self {
21216             s_type: Self::STRUCTURE_TYPE,
21217             p_next: ::std::ptr::null_mut(),
21218             local_dimming_support: Bool32::default(),
21219         }
21220     }
21221 }
21222 unsafe impl TaggedStructure for DisplayNativeHdrSurfaceCapabilitiesAMD {
21223     const STRUCTURE_TYPE: StructureType =
21224         StructureType::DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD;
21225 }
21226 impl DisplayNativeHdrSurfaceCapabilitiesAMD {
builder<'a>() -> DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a>21227     pub fn builder<'a>() -> DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
21228         DisplayNativeHdrSurfaceCapabilitiesAMDBuilder {
21229             inner: Self::default(),
21230             marker: ::std::marker::PhantomData,
21231         }
21232     }
21233 }
21234 #[repr(transparent)]
21235 pub struct DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
21236     inner: DisplayNativeHdrSurfaceCapabilitiesAMD,
21237     marker: ::std::marker::PhantomData<&'a ()>,
21238 }
21239 unsafe impl ExtendsSurfaceCapabilities2KHR for DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'_> {}
21240 unsafe impl ExtendsSurfaceCapabilities2KHR for DisplayNativeHdrSurfaceCapabilitiesAMD {}
21241 impl<'a> ::std::ops::Deref for DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
21242     type Target = DisplayNativeHdrSurfaceCapabilitiesAMD;
deref(&self) -> &Self::Target21243     fn deref(&self) -> &Self::Target {
21244         &self.inner
21245     }
21246 }
21247 impl<'a> ::std::ops::DerefMut for DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21248     fn deref_mut(&mut self) -> &mut Self::Target {
21249         &mut self.inner
21250     }
21251 }
21252 impl<'a> DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
21253     #[inline]
local_dimming_support(mut self, local_dimming_support: bool) -> Self21254     pub fn local_dimming_support(mut self, local_dimming_support: bool) -> Self {
21255         self.inner.local_dimming_support = local_dimming_support.into();
21256         self
21257     }
21258     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21259     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21260     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayNativeHdrSurfaceCapabilitiesAMD21261     pub fn build(self) -> DisplayNativeHdrSurfaceCapabilitiesAMD {
21262         self.inner
21263     }
21264 }
21265 #[repr(C)]
21266 #[cfg_attr(feature = "debug", derive(Debug))]
21267 #[derive(Copy, Clone)]
21268 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainDisplayNativeHdrCreateInfoAMD.html>"]
21269 pub struct SwapchainDisplayNativeHdrCreateInfoAMD {
21270     pub s_type: StructureType,
21271     pub p_next: *const c_void,
21272     pub local_dimming_enable: Bool32,
21273 }
21274 impl ::std::default::Default for SwapchainDisplayNativeHdrCreateInfoAMD {
21275     #[inline]
default() -> Self21276     fn default() -> Self {
21277         Self {
21278             s_type: Self::STRUCTURE_TYPE,
21279             p_next: ::std::ptr::null(),
21280             local_dimming_enable: Bool32::default(),
21281         }
21282     }
21283 }
21284 unsafe impl TaggedStructure for SwapchainDisplayNativeHdrCreateInfoAMD {
21285     const STRUCTURE_TYPE: StructureType =
21286         StructureType::SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD;
21287 }
21288 impl SwapchainDisplayNativeHdrCreateInfoAMD {
builder<'a>() -> SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a>21289     pub fn builder<'a>() -> SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
21290         SwapchainDisplayNativeHdrCreateInfoAMDBuilder {
21291             inner: Self::default(),
21292             marker: ::std::marker::PhantomData,
21293         }
21294     }
21295 }
21296 #[repr(transparent)]
21297 pub struct SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
21298     inner: SwapchainDisplayNativeHdrCreateInfoAMD,
21299     marker: ::std::marker::PhantomData<&'a ()>,
21300 }
21301 unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'_> {}
21302 unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainDisplayNativeHdrCreateInfoAMD {}
21303 impl<'a> ::std::ops::Deref for SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
21304     type Target = SwapchainDisplayNativeHdrCreateInfoAMD;
deref(&self) -> &Self::Target21305     fn deref(&self) -> &Self::Target {
21306         &self.inner
21307     }
21308 }
21309 impl<'a> ::std::ops::DerefMut for SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21310     fn deref_mut(&mut self) -> &mut Self::Target {
21311         &mut self.inner
21312     }
21313 }
21314 impl<'a> SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
21315     #[inline]
local_dimming_enable(mut self, local_dimming_enable: bool) -> Self21316     pub fn local_dimming_enable(mut self, local_dimming_enable: bool) -> Self {
21317         self.inner.local_dimming_enable = local_dimming_enable.into();
21318         self
21319     }
21320     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21321     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21322     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SwapchainDisplayNativeHdrCreateInfoAMD21323     pub fn build(self) -> SwapchainDisplayNativeHdrCreateInfoAMD {
21324         self.inner
21325     }
21326 }
21327 #[repr(C)]
21328 #[cfg_attr(feature = "debug", derive(Debug))]
21329 #[derive(Copy, Clone, Default)]
21330 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRefreshCycleDurationGOOGLE.html>"]
21331 pub struct RefreshCycleDurationGOOGLE {
21332     pub refresh_duration: u64,
21333 }
21334 impl RefreshCycleDurationGOOGLE {
builder<'a>() -> RefreshCycleDurationGOOGLEBuilder<'a>21335     pub fn builder<'a>() -> RefreshCycleDurationGOOGLEBuilder<'a> {
21336         RefreshCycleDurationGOOGLEBuilder {
21337             inner: Self::default(),
21338             marker: ::std::marker::PhantomData,
21339         }
21340     }
21341 }
21342 #[repr(transparent)]
21343 pub struct RefreshCycleDurationGOOGLEBuilder<'a> {
21344     inner: RefreshCycleDurationGOOGLE,
21345     marker: ::std::marker::PhantomData<&'a ()>,
21346 }
21347 impl<'a> ::std::ops::Deref for RefreshCycleDurationGOOGLEBuilder<'a> {
21348     type Target = RefreshCycleDurationGOOGLE;
deref(&self) -> &Self::Target21349     fn deref(&self) -> &Self::Target {
21350         &self.inner
21351     }
21352 }
21353 impl<'a> ::std::ops::DerefMut for RefreshCycleDurationGOOGLEBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21354     fn deref_mut(&mut self) -> &mut Self::Target {
21355         &mut self.inner
21356     }
21357 }
21358 impl<'a> RefreshCycleDurationGOOGLEBuilder<'a> {
21359     #[inline]
refresh_duration(mut self, refresh_duration: u64) -> Self21360     pub fn refresh_duration(mut self, refresh_duration: u64) -> Self {
21361         self.inner.refresh_duration = refresh_duration;
21362         self
21363     }
21364     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21365     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21366     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RefreshCycleDurationGOOGLE21367     pub fn build(self) -> RefreshCycleDurationGOOGLE {
21368         self.inner
21369     }
21370 }
21371 #[repr(C)]
21372 #[cfg_attr(feature = "debug", derive(Debug))]
21373 #[derive(Copy, Clone, Default)]
21374 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPastPresentationTimingGOOGLE.html>"]
21375 pub struct PastPresentationTimingGOOGLE {
21376     pub present_id: u32,
21377     pub desired_present_time: u64,
21378     pub actual_present_time: u64,
21379     pub earliest_present_time: u64,
21380     pub present_margin: u64,
21381 }
21382 impl PastPresentationTimingGOOGLE {
builder<'a>() -> PastPresentationTimingGOOGLEBuilder<'a>21383     pub fn builder<'a>() -> PastPresentationTimingGOOGLEBuilder<'a> {
21384         PastPresentationTimingGOOGLEBuilder {
21385             inner: Self::default(),
21386             marker: ::std::marker::PhantomData,
21387         }
21388     }
21389 }
21390 #[repr(transparent)]
21391 pub struct PastPresentationTimingGOOGLEBuilder<'a> {
21392     inner: PastPresentationTimingGOOGLE,
21393     marker: ::std::marker::PhantomData<&'a ()>,
21394 }
21395 impl<'a> ::std::ops::Deref for PastPresentationTimingGOOGLEBuilder<'a> {
21396     type Target = PastPresentationTimingGOOGLE;
deref(&self) -> &Self::Target21397     fn deref(&self) -> &Self::Target {
21398         &self.inner
21399     }
21400 }
21401 impl<'a> ::std::ops::DerefMut for PastPresentationTimingGOOGLEBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21402     fn deref_mut(&mut self) -> &mut Self::Target {
21403         &mut self.inner
21404     }
21405 }
21406 impl<'a> PastPresentationTimingGOOGLEBuilder<'a> {
21407     #[inline]
present_id(mut self, present_id: u32) -> Self21408     pub fn present_id(mut self, present_id: u32) -> Self {
21409         self.inner.present_id = present_id;
21410         self
21411     }
21412     #[inline]
desired_present_time(mut self, desired_present_time: u64) -> Self21413     pub fn desired_present_time(mut self, desired_present_time: u64) -> Self {
21414         self.inner.desired_present_time = desired_present_time;
21415         self
21416     }
21417     #[inline]
actual_present_time(mut self, actual_present_time: u64) -> Self21418     pub fn actual_present_time(mut self, actual_present_time: u64) -> Self {
21419         self.inner.actual_present_time = actual_present_time;
21420         self
21421     }
21422     #[inline]
earliest_present_time(mut self, earliest_present_time: u64) -> Self21423     pub fn earliest_present_time(mut self, earliest_present_time: u64) -> Self {
21424         self.inner.earliest_present_time = earliest_present_time;
21425         self
21426     }
21427     #[inline]
present_margin(mut self, present_margin: u64) -> Self21428     pub fn present_margin(mut self, present_margin: u64) -> Self {
21429         self.inner.present_margin = present_margin;
21430         self
21431     }
21432     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21433     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21434     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PastPresentationTimingGOOGLE21435     pub fn build(self) -> PastPresentationTimingGOOGLE {
21436         self.inner
21437     }
21438 }
21439 #[repr(C)]
21440 #[cfg_attr(feature = "debug", derive(Debug))]
21441 #[derive(Copy, Clone)]
21442 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentTimesInfoGOOGLE.html>"]
21443 pub struct PresentTimesInfoGOOGLE {
21444     pub s_type: StructureType,
21445     pub p_next: *const c_void,
21446     pub swapchain_count: u32,
21447     pub p_times: *const PresentTimeGOOGLE,
21448 }
21449 impl ::std::default::Default for PresentTimesInfoGOOGLE {
21450     #[inline]
default() -> Self21451     fn default() -> Self {
21452         Self {
21453             s_type: Self::STRUCTURE_TYPE,
21454             p_next: ::std::ptr::null(),
21455             swapchain_count: u32::default(),
21456             p_times: ::std::ptr::null(),
21457         }
21458     }
21459 }
21460 unsafe impl TaggedStructure for PresentTimesInfoGOOGLE {
21461     const STRUCTURE_TYPE: StructureType = StructureType::PRESENT_TIMES_INFO_GOOGLE;
21462 }
21463 impl PresentTimesInfoGOOGLE {
builder<'a>() -> PresentTimesInfoGOOGLEBuilder<'a>21464     pub fn builder<'a>() -> PresentTimesInfoGOOGLEBuilder<'a> {
21465         PresentTimesInfoGOOGLEBuilder {
21466             inner: Self::default(),
21467             marker: ::std::marker::PhantomData,
21468         }
21469     }
21470 }
21471 #[repr(transparent)]
21472 pub struct PresentTimesInfoGOOGLEBuilder<'a> {
21473     inner: PresentTimesInfoGOOGLE,
21474     marker: ::std::marker::PhantomData<&'a ()>,
21475 }
21476 unsafe impl ExtendsPresentInfoKHR for PresentTimesInfoGOOGLEBuilder<'_> {}
21477 unsafe impl ExtendsPresentInfoKHR for PresentTimesInfoGOOGLE {}
21478 impl<'a> ::std::ops::Deref for PresentTimesInfoGOOGLEBuilder<'a> {
21479     type Target = PresentTimesInfoGOOGLE;
deref(&self) -> &Self::Target21480     fn deref(&self) -> &Self::Target {
21481         &self.inner
21482     }
21483 }
21484 impl<'a> ::std::ops::DerefMut for PresentTimesInfoGOOGLEBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21485     fn deref_mut(&mut self) -> &mut Self::Target {
21486         &mut self.inner
21487     }
21488 }
21489 impl<'a> PresentTimesInfoGOOGLEBuilder<'a> {
21490     #[inline]
times(mut self, times: &'a [PresentTimeGOOGLE]) -> Self21491     pub fn times(mut self, times: &'a [PresentTimeGOOGLE]) -> Self {
21492         self.inner.swapchain_count = times.len() as _;
21493         self.inner.p_times = times.as_ptr();
21494         self
21495     }
21496     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21497     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21498     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PresentTimesInfoGOOGLE21499     pub fn build(self) -> PresentTimesInfoGOOGLE {
21500         self.inner
21501     }
21502 }
21503 #[repr(C)]
21504 #[cfg_attr(feature = "debug", derive(Debug))]
21505 #[derive(Copy, Clone, Default)]
21506 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentTimeGOOGLE.html>"]
21507 pub struct PresentTimeGOOGLE {
21508     pub present_id: u32,
21509     pub desired_present_time: u64,
21510 }
21511 impl PresentTimeGOOGLE {
builder<'a>() -> PresentTimeGOOGLEBuilder<'a>21512     pub fn builder<'a>() -> PresentTimeGOOGLEBuilder<'a> {
21513         PresentTimeGOOGLEBuilder {
21514             inner: Self::default(),
21515             marker: ::std::marker::PhantomData,
21516         }
21517     }
21518 }
21519 #[repr(transparent)]
21520 pub struct PresentTimeGOOGLEBuilder<'a> {
21521     inner: PresentTimeGOOGLE,
21522     marker: ::std::marker::PhantomData<&'a ()>,
21523 }
21524 impl<'a> ::std::ops::Deref for PresentTimeGOOGLEBuilder<'a> {
21525     type Target = PresentTimeGOOGLE;
deref(&self) -> &Self::Target21526     fn deref(&self) -> &Self::Target {
21527         &self.inner
21528     }
21529 }
21530 impl<'a> ::std::ops::DerefMut for PresentTimeGOOGLEBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21531     fn deref_mut(&mut self) -> &mut Self::Target {
21532         &mut self.inner
21533     }
21534 }
21535 impl<'a> PresentTimeGOOGLEBuilder<'a> {
21536     #[inline]
present_id(mut self, present_id: u32) -> Self21537     pub fn present_id(mut self, present_id: u32) -> Self {
21538         self.inner.present_id = present_id;
21539         self
21540     }
21541     #[inline]
desired_present_time(mut self, desired_present_time: u64) -> Self21542     pub fn desired_present_time(mut self, desired_present_time: u64) -> Self {
21543         self.inner.desired_present_time = desired_present_time;
21544         self
21545     }
21546     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21547     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21548     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PresentTimeGOOGLE21549     pub fn build(self) -> PresentTimeGOOGLE {
21550         self.inner
21551     }
21552 }
21553 #[repr(C)]
21554 #[cfg_attr(feature = "debug", derive(Debug))]
21555 #[derive(Copy, Clone)]
21556 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIOSSurfaceCreateInfoMVK.html>"]
21557 pub struct IOSSurfaceCreateInfoMVK {
21558     pub s_type: StructureType,
21559     pub p_next: *const c_void,
21560     pub flags: IOSSurfaceCreateFlagsMVK,
21561     pub p_view: *const c_void,
21562 }
21563 impl ::std::default::Default for IOSSurfaceCreateInfoMVK {
21564     #[inline]
default() -> Self21565     fn default() -> Self {
21566         Self {
21567             s_type: Self::STRUCTURE_TYPE,
21568             p_next: ::std::ptr::null(),
21569             flags: IOSSurfaceCreateFlagsMVK::default(),
21570             p_view: ::std::ptr::null(),
21571         }
21572     }
21573 }
21574 unsafe impl TaggedStructure for IOSSurfaceCreateInfoMVK {
21575     const STRUCTURE_TYPE: StructureType = StructureType::IOS_SURFACE_CREATE_INFO_MVK;
21576 }
21577 impl IOSSurfaceCreateInfoMVK {
builder<'a>() -> IOSSurfaceCreateInfoMVKBuilder<'a>21578     pub fn builder<'a>() -> IOSSurfaceCreateInfoMVKBuilder<'a> {
21579         IOSSurfaceCreateInfoMVKBuilder {
21580             inner: Self::default(),
21581             marker: ::std::marker::PhantomData,
21582         }
21583     }
21584 }
21585 #[repr(transparent)]
21586 pub struct IOSSurfaceCreateInfoMVKBuilder<'a> {
21587     inner: IOSSurfaceCreateInfoMVK,
21588     marker: ::std::marker::PhantomData<&'a ()>,
21589 }
21590 impl<'a> ::std::ops::Deref for IOSSurfaceCreateInfoMVKBuilder<'a> {
21591     type Target = IOSSurfaceCreateInfoMVK;
deref(&self) -> &Self::Target21592     fn deref(&self) -> &Self::Target {
21593         &self.inner
21594     }
21595 }
21596 impl<'a> ::std::ops::DerefMut for IOSSurfaceCreateInfoMVKBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21597     fn deref_mut(&mut self) -> &mut Self::Target {
21598         &mut self.inner
21599     }
21600 }
21601 impl<'a> IOSSurfaceCreateInfoMVKBuilder<'a> {
21602     #[inline]
flags(mut self, flags: IOSSurfaceCreateFlagsMVK) -> Self21603     pub fn flags(mut self, flags: IOSSurfaceCreateFlagsMVK) -> Self {
21604         self.inner.flags = flags;
21605         self
21606     }
21607     #[inline]
view(mut self, view: *const c_void) -> Self21608     pub fn view(mut self, view: *const c_void) -> Self {
21609         self.inner.p_view = view;
21610         self
21611     }
21612     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21613     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21614     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> IOSSurfaceCreateInfoMVK21615     pub fn build(self) -> IOSSurfaceCreateInfoMVK {
21616         self.inner
21617     }
21618 }
21619 #[repr(C)]
21620 #[cfg_attr(feature = "debug", derive(Debug))]
21621 #[derive(Copy, Clone)]
21622 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMacOSSurfaceCreateInfoMVK.html>"]
21623 pub struct MacOSSurfaceCreateInfoMVK {
21624     pub s_type: StructureType,
21625     pub p_next: *const c_void,
21626     pub flags: MacOSSurfaceCreateFlagsMVK,
21627     pub p_view: *const c_void,
21628 }
21629 impl ::std::default::Default for MacOSSurfaceCreateInfoMVK {
21630     #[inline]
default() -> Self21631     fn default() -> Self {
21632         Self {
21633             s_type: Self::STRUCTURE_TYPE,
21634             p_next: ::std::ptr::null(),
21635             flags: MacOSSurfaceCreateFlagsMVK::default(),
21636             p_view: ::std::ptr::null(),
21637         }
21638     }
21639 }
21640 unsafe impl TaggedStructure for MacOSSurfaceCreateInfoMVK {
21641     const STRUCTURE_TYPE: StructureType = StructureType::MACOS_SURFACE_CREATE_INFO_MVK;
21642 }
21643 impl MacOSSurfaceCreateInfoMVK {
builder<'a>() -> MacOSSurfaceCreateInfoMVKBuilder<'a>21644     pub fn builder<'a>() -> MacOSSurfaceCreateInfoMVKBuilder<'a> {
21645         MacOSSurfaceCreateInfoMVKBuilder {
21646             inner: Self::default(),
21647             marker: ::std::marker::PhantomData,
21648         }
21649     }
21650 }
21651 #[repr(transparent)]
21652 pub struct MacOSSurfaceCreateInfoMVKBuilder<'a> {
21653     inner: MacOSSurfaceCreateInfoMVK,
21654     marker: ::std::marker::PhantomData<&'a ()>,
21655 }
21656 impl<'a> ::std::ops::Deref for MacOSSurfaceCreateInfoMVKBuilder<'a> {
21657     type Target = MacOSSurfaceCreateInfoMVK;
deref(&self) -> &Self::Target21658     fn deref(&self) -> &Self::Target {
21659         &self.inner
21660     }
21661 }
21662 impl<'a> ::std::ops::DerefMut for MacOSSurfaceCreateInfoMVKBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21663     fn deref_mut(&mut self) -> &mut Self::Target {
21664         &mut self.inner
21665     }
21666 }
21667 impl<'a> MacOSSurfaceCreateInfoMVKBuilder<'a> {
21668     #[inline]
flags(mut self, flags: MacOSSurfaceCreateFlagsMVK) -> Self21669     pub fn flags(mut self, flags: MacOSSurfaceCreateFlagsMVK) -> Self {
21670         self.inner.flags = flags;
21671         self
21672     }
21673     #[inline]
view(mut self, view: *const c_void) -> Self21674     pub fn view(mut self, view: *const c_void) -> Self {
21675         self.inner.p_view = view;
21676         self
21677     }
21678     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21679     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21680     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MacOSSurfaceCreateInfoMVK21681     pub fn build(self) -> MacOSSurfaceCreateInfoMVK {
21682         self.inner
21683     }
21684 }
21685 #[repr(C)]
21686 #[cfg_attr(feature = "debug", derive(Debug))]
21687 #[derive(Copy, Clone)]
21688 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMetalSurfaceCreateInfoEXT.html>"]
21689 pub struct MetalSurfaceCreateInfoEXT {
21690     pub s_type: StructureType,
21691     pub p_next: *const c_void,
21692     pub flags: MetalSurfaceCreateFlagsEXT,
21693     pub p_layer: *const CAMetalLayer,
21694 }
21695 impl ::std::default::Default for MetalSurfaceCreateInfoEXT {
21696     #[inline]
default() -> Self21697     fn default() -> Self {
21698         Self {
21699             s_type: Self::STRUCTURE_TYPE,
21700             p_next: ::std::ptr::null(),
21701             flags: MetalSurfaceCreateFlagsEXT::default(),
21702             p_layer: ::std::ptr::null(),
21703         }
21704     }
21705 }
21706 unsafe impl TaggedStructure for MetalSurfaceCreateInfoEXT {
21707     const STRUCTURE_TYPE: StructureType = StructureType::METAL_SURFACE_CREATE_INFO_EXT;
21708 }
21709 impl MetalSurfaceCreateInfoEXT {
builder<'a>() -> MetalSurfaceCreateInfoEXTBuilder<'a>21710     pub fn builder<'a>() -> MetalSurfaceCreateInfoEXTBuilder<'a> {
21711         MetalSurfaceCreateInfoEXTBuilder {
21712             inner: Self::default(),
21713             marker: ::std::marker::PhantomData,
21714         }
21715     }
21716 }
21717 #[repr(transparent)]
21718 pub struct MetalSurfaceCreateInfoEXTBuilder<'a> {
21719     inner: MetalSurfaceCreateInfoEXT,
21720     marker: ::std::marker::PhantomData<&'a ()>,
21721 }
21722 impl<'a> ::std::ops::Deref for MetalSurfaceCreateInfoEXTBuilder<'a> {
21723     type Target = MetalSurfaceCreateInfoEXT;
deref(&self) -> &Self::Target21724     fn deref(&self) -> &Self::Target {
21725         &self.inner
21726     }
21727 }
21728 impl<'a> ::std::ops::DerefMut for MetalSurfaceCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21729     fn deref_mut(&mut self) -> &mut Self::Target {
21730         &mut self.inner
21731     }
21732 }
21733 impl<'a> MetalSurfaceCreateInfoEXTBuilder<'a> {
21734     #[inline]
flags(mut self, flags: MetalSurfaceCreateFlagsEXT) -> Self21735     pub fn flags(mut self, flags: MetalSurfaceCreateFlagsEXT) -> Self {
21736         self.inner.flags = flags;
21737         self
21738     }
21739     #[inline]
layer(mut self, layer: *const CAMetalLayer) -> Self21740     pub fn layer(mut self, layer: *const CAMetalLayer) -> Self {
21741         self.inner.p_layer = layer;
21742         self
21743     }
21744     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21745     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21746     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MetalSurfaceCreateInfoEXT21747     pub fn build(self) -> MetalSurfaceCreateInfoEXT {
21748         self.inner
21749     }
21750 }
21751 #[repr(C)]
21752 #[cfg_attr(feature = "debug", derive(Debug))]
21753 #[derive(Copy, Clone, Default)]
21754 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkViewportWScalingNV.html>"]
21755 pub struct ViewportWScalingNV {
21756     pub xcoeff: f32,
21757     pub ycoeff: f32,
21758 }
21759 impl ViewportWScalingNV {
builder<'a>() -> ViewportWScalingNVBuilder<'a>21760     pub fn builder<'a>() -> ViewportWScalingNVBuilder<'a> {
21761         ViewportWScalingNVBuilder {
21762             inner: Self::default(),
21763             marker: ::std::marker::PhantomData,
21764         }
21765     }
21766 }
21767 #[repr(transparent)]
21768 pub struct ViewportWScalingNVBuilder<'a> {
21769     inner: ViewportWScalingNV,
21770     marker: ::std::marker::PhantomData<&'a ()>,
21771 }
21772 impl<'a> ::std::ops::Deref for ViewportWScalingNVBuilder<'a> {
21773     type Target = ViewportWScalingNV;
deref(&self) -> &Self::Target21774     fn deref(&self) -> &Self::Target {
21775         &self.inner
21776     }
21777 }
21778 impl<'a> ::std::ops::DerefMut for ViewportWScalingNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21779     fn deref_mut(&mut self) -> &mut Self::Target {
21780         &mut self.inner
21781     }
21782 }
21783 impl<'a> ViewportWScalingNVBuilder<'a> {
21784     #[inline]
xcoeff(mut self, xcoeff: f32) -> Self21785     pub fn xcoeff(mut self, xcoeff: f32) -> Self {
21786         self.inner.xcoeff = xcoeff;
21787         self
21788     }
21789     #[inline]
ycoeff(mut self, ycoeff: f32) -> Self21790     pub fn ycoeff(mut self, ycoeff: f32) -> Self {
21791         self.inner.ycoeff = ycoeff;
21792         self
21793     }
21794     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21795     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21796     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ViewportWScalingNV21797     pub fn build(self) -> ViewportWScalingNV {
21798         self.inner
21799     }
21800 }
21801 #[repr(C)]
21802 #[cfg_attr(feature = "debug", derive(Debug))]
21803 #[derive(Copy, Clone)]
21804 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportWScalingStateCreateInfoNV.html>"]
21805 pub struct PipelineViewportWScalingStateCreateInfoNV {
21806     pub s_type: StructureType,
21807     pub p_next: *const c_void,
21808     pub viewport_w_scaling_enable: Bool32,
21809     pub viewport_count: u32,
21810     pub p_viewport_w_scalings: *const ViewportWScalingNV,
21811 }
21812 impl ::std::default::Default for PipelineViewportWScalingStateCreateInfoNV {
21813     #[inline]
default() -> Self21814     fn default() -> Self {
21815         Self {
21816             s_type: Self::STRUCTURE_TYPE,
21817             p_next: ::std::ptr::null(),
21818             viewport_w_scaling_enable: Bool32::default(),
21819             viewport_count: u32::default(),
21820             p_viewport_w_scalings: ::std::ptr::null(),
21821         }
21822     }
21823 }
21824 unsafe impl TaggedStructure for PipelineViewportWScalingStateCreateInfoNV {
21825     const STRUCTURE_TYPE: StructureType =
21826         StructureType::PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV;
21827 }
21828 impl PipelineViewportWScalingStateCreateInfoNV {
builder<'a>() -> PipelineViewportWScalingStateCreateInfoNVBuilder<'a>21829     pub fn builder<'a>() -> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
21830         PipelineViewportWScalingStateCreateInfoNVBuilder {
21831             inner: Self::default(),
21832             marker: ::std::marker::PhantomData,
21833         }
21834     }
21835 }
21836 #[repr(transparent)]
21837 pub struct PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
21838     inner: PipelineViewportWScalingStateCreateInfoNV,
21839     marker: ::std::marker::PhantomData<&'a ()>,
21840 }
21841 unsafe impl ExtendsPipelineViewportStateCreateInfo
21842     for PipelineViewportWScalingStateCreateInfoNVBuilder<'_>
21843 {
21844 }
21845 unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportWScalingStateCreateInfoNV {}
21846 impl<'a> ::std::ops::Deref for PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
21847     type Target = PipelineViewportWScalingStateCreateInfoNV;
deref(&self) -> &Self::Target21848     fn deref(&self) -> &Self::Target {
21849         &self.inner
21850     }
21851 }
21852 impl<'a> ::std::ops::DerefMut for PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21853     fn deref_mut(&mut self) -> &mut Self::Target {
21854         &mut self.inner
21855     }
21856 }
21857 impl<'a> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
21858     #[inline]
viewport_w_scaling_enable(mut self, viewport_w_scaling_enable: bool) -> Self21859     pub fn viewport_w_scaling_enable(mut self, viewport_w_scaling_enable: bool) -> Self {
21860         self.inner.viewport_w_scaling_enable = viewport_w_scaling_enable.into();
21861         self
21862     }
21863     #[inline]
viewport_w_scalings(mut self, viewport_w_scalings: &'a [ViewportWScalingNV]) -> Self21864     pub fn viewport_w_scalings(mut self, viewport_w_scalings: &'a [ViewportWScalingNV]) -> Self {
21865         self.inner.viewport_count = viewport_w_scalings.len() as _;
21866         self.inner.p_viewport_w_scalings = viewport_w_scalings.as_ptr();
21867         self
21868     }
21869     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21870     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21871     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineViewportWScalingStateCreateInfoNV21872     pub fn build(self) -> PipelineViewportWScalingStateCreateInfoNV {
21873         self.inner
21874     }
21875 }
21876 #[repr(C)]
21877 #[cfg_attr(feature = "debug", derive(Debug))]
21878 #[derive(Copy, Clone, Default)]
21879 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkViewportSwizzleNV.html>"]
21880 pub struct ViewportSwizzleNV {
21881     pub x: ViewportCoordinateSwizzleNV,
21882     pub y: ViewportCoordinateSwizzleNV,
21883     pub z: ViewportCoordinateSwizzleNV,
21884     pub w: ViewportCoordinateSwizzleNV,
21885 }
21886 impl ViewportSwizzleNV {
builder<'a>() -> ViewportSwizzleNVBuilder<'a>21887     pub fn builder<'a>() -> ViewportSwizzleNVBuilder<'a> {
21888         ViewportSwizzleNVBuilder {
21889             inner: Self::default(),
21890             marker: ::std::marker::PhantomData,
21891         }
21892     }
21893 }
21894 #[repr(transparent)]
21895 pub struct ViewportSwizzleNVBuilder<'a> {
21896     inner: ViewportSwizzleNV,
21897     marker: ::std::marker::PhantomData<&'a ()>,
21898 }
21899 impl<'a> ::std::ops::Deref for ViewportSwizzleNVBuilder<'a> {
21900     type Target = ViewportSwizzleNV;
deref(&self) -> &Self::Target21901     fn deref(&self) -> &Self::Target {
21902         &self.inner
21903     }
21904 }
21905 impl<'a> ::std::ops::DerefMut for ViewportSwizzleNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21906     fn deref_mut(&mut self) -> &mut Self::Target {
21907         &mut self.inner
21908     }
21909 }
21910 impl<'a> ViewportSwizzleNVBuilder<'a> {
21911     #[inline]
x(mut self, x: ViewportCoordinateSwizzleNV) -> Self21912     pub fn x(mut self, x: ViewportCoordinateSwizzleNV) -> Self {
21913         self.inner.x = x;
21914         self
21915     }
21916     #[inline]
y(mut self, y: ViewportCoordinateSwizzleNV) -> Self21917     pub fn y(mut self, y: ViewportCoordinateSwizzleNV) -> Self {
21918         self.inner.y = y;
21919         self
21920     }
21921     #[inline]
z(mut self, z: ViewportCoordinateSwizzleNV) -> Self21922     pub fn z(mut self, z: ViewportCoordinateSwizzleNV) -> Self {
21923         self.inner.z = z;
21924         self
21925     }
21926     #[inline]
w(mut self, w: ViewportCoordinateSwizzleNV) -> Self21927     pub fn w(mut self, w: ViewportCoordinateSwizzleNV) -> Self {
21928         self.inner.w = w;
21929         self
21930     }
21931     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21932     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21933     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ViewportSwizzleNV21934     pub fn build(self) -> ViewportSwizzleNV {
21935         self.inner
21936     }
21937 }
21938 #[repr(C)]
21939 #[cfg_attr(feature = "debug", derive(Debug))]
21940 #[derive(Copy, Clone)]
21941 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportSwizzleStateCreateInfoNV.html>"]
21942 pub struct PipelineViewportSwizzleStateCreateInfoNV {
21943     pub s_type: StructureType,
21944     pub p_next: *const c_void,
21945     pub flags: PipelineViewportSwizzleStateCreateFlagsNV,
21946     pub viewport_count: u32,
21947     pub p_viewport_swizzles: *const ViewportSwizzleNV,
21948 }
21949 impl ::std::default::Default for PipelineViewportSwizzleStateCreateInfoNV {
21950     #[inline]
default() -> Self21951     fn default() -> Self {
21952         Self {
21953             s_type: Self::STRUCTURE_TYPE,
21954             p_next: ::std::ptr::null(),
21955             flags: PipelineViewportSwizzleStateCreateFlagsNV::default(),
21956             viewport_count: u32::default(),
21957             p_viewport_swizzles: ::std::ptr::null(),
21958         }
21959     }
21960 }
21961 unsafe impl TaggedStructure for PipelineViewportSwizzleStateCreateInfoNV {
21962     const STRUCTURE_TYPE: StructureType =
21963         StructureType::PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV;
21964 }
21965 impl PipelineViewportSwizzleStateCreateInfoNV {
builder<'a>() -> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a>21966     pub fn builder<'a>() -> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
21967         PipelineViewportSwizzleStateCreateInfoNVBuilder {
21968             inner: Self::default(),
21969             marker: ::std::marker::PhantomData,
21970         }
21971     }
21972 }
21973 #[repr(transparent)]
21974 pub struct PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
21975     inner: PipelineViewportSwizzleStateCreateInfoNV,
21976     marker: ::std::marker::PhantomData<&'a ()>,
21977 }
21978 unsafe impl ExtendsPipelineViewportStateCreateInfo
21979     for PipelineViewportSwizzleStateCreateInfoNVBuilder<'_>
21980 {
21981 }
21982 unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportSwizzleStateCreateInfoNV {}
21983 impl<'a> ::std::ops::Deref for PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
21984     type Target = PipelineViewportSwizzleStateCreateInfoNV;
deref(&self) -> &Self::Target21985     fn deref(&self) -> &Self::Target {
21986         &self.inner
21987     }
21988 }
21989 impl<'a> ::std::ops::DerefMut for PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21990     fn deref_mut(&mut self) -> &mut Self::Target {
21991         &mut self.inner
21992     }
21993 }
21994 impl<'a> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
21995     #[inline]
flags(mut self, flags: PipelineViewportSwizzleStateCreateFlagsNV) -> Self21996     pub fn flags(mut self, flags: PipelineViewportSwizzleStateCreateFlagsNV) -> Self {
21997         self.inner.flags = flags;
21998         self
21999     }
22000     #[inline]
viewport_swizzles(mut self, viewport_swizzles: &'a [ViewportSwizzleNV]) -> Self22001     pub fn viewport_swizzles(mut self, viewport_swizzles: &'a [ViewportSwizzleNV]) -> Self {
22002         self.inner.viewport_count = viewport_swizzles.len() as _;
22003         self.inner.p_viewport_swizzles = viewport_swizzles.as_ptr();
22004         self
22005     }
22006     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22007     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22008     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineViewportSwizzleStateCreateInfoNV22009     pub fn build(self) -> PipelineViewportSwizzleStateCreateInfoNV {
22010         self.inner
22011     }
22012 }
22013 #[repr(C)]
22014 #[cfg_attr(feature = "debug", derive(Debug))]
22015 #[derive(Copy, Clone)]
22016 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDiscardRectanglePropertiesEXT.html>"]
22017 pub struct PhysicalDeviceDiscardRectanglePropertiesEXT {
22018     pub s_type: StructureType,
22019     pub p_next: *mut c_void,
22020     pub max_discard_rectangles: u32,
22021 }
22022 impl ::std::default::Default for PhysicalDeviceDiscardRectanglePropertiesEXT {
22023     #[inline]
default() -> Self22024     fn default() -> Self {
22025         Self {
22026             s_type: Self::STRUCTURE_TYPE,
22027             p_next: ::std::ptr::null_mut(),
22028             max_discard_rectangles: u32::default(),
22029         }
22030     }
22031 }
22032 unsafe impl TaggedStructure for PhysicalDeviceDiscardRectanglePropertiesEXT {
22033     const STRUCTURE_TYPE: StructureType =
22034         StructureType::PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT;
22035 }
22036 impl PhysicalDeviceDiscardRectanglePropertiesEXT {
builder<'a>() -> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a>22037     pub fn builder<'a>() -> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
22038         PhysicalDeviceDiscardRectanglePropertiesEXTBuilder {
22039             inner: Self::default(),
22040             marker: ::std::marker::PhantomData,
22041         }
22042     }
22043 }
22044 #[repr(transparent)]
22045 pub struct PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
22046     inner: PhysicalDeviceDiscardRectanglePropertiesEXT,
22047     marker: ::std::marker::PhantomData<&'a ()>,
22048 }
22049 unsafe impl ExtendsPhysicalDeviceProperties2
22050     for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'_>
22051 {
22052 }
22053 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDiscardRectanglePropertiesEXT {}
22054 impl<'a> ::std::ops::Deref for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
22055     type Target = PhysicalDeviceDiscardRectanglePropertiesEXT;
deref(&self) -> &Self::Target22056     fn deref(&self) -> &Self::Target {
22057         &self.inner
22058     }
22059 }
22060 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target22061     fn deref_mut(&mut self) -> &mut Self::Target {
22062         &mut self.inner
22063     }
22064 }
22065 impl<'a> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
22066     #[inline]
max_discard_rectangles(mut self, max_discard_rectangles: u32) -> Self22067     pub fn max_discard_rectangles(mut self, max_discard_rectangles: u32) -> Self {
22068         self.inner.max_discard_rectangles = max_discard_rectangles;
22069         self
22070     }
22071     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22072     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22073     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDiscardRectanglePropertiesEXT22074     pub fn build(self) -> PhysicalDeviceDiscardRectanglePropertiesEXT {
22075         self.inner
22076     }
22077 }
22078 #[repr(C)]
22079 #[cfg_attr(feature = "debug", derive(Debug))]
22080 #[derive(Copy, Clone)]
22081 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDiscardRectangleStateCreateInfoEXT.html>"]
22082 pub struct PipelineDiscardRectangleStateCreateInfoEXT {
22083     pub s_type: StructureType,
22084     pub p_next: *const c_void,
22085     pub flags: PipelineDiscardRectangleStateCreateFlagsEXT,
22086     pub discard_rectangle_mode: DiscardRectangleModeEXT,
22087     pub discard_rectangle_count: u32,
22088     pub p_discard_rectangles: *const Rect2D,
22089 }
22090 impl ::std::default::Default for PipelineDiscardRectangleStateCreateInfoEXT {
22091     #[inline]
default() -> Self22092     fn default() -> Self {
22093         Self {
22094             s_type: Self::STRUCTURE_TYPE,
22095             p_next: ::std::ptr::null(),
22096             flags: PipelineDiscardRectangleStateCreateFlagsEXT::default(),
22097             discard_rectangle_mode: DiscardRectangleModeEXT::default(),
22098             discard_rectangle_count: u32::default(),
22099             p_discard_rectangles: ::std::ptr::null(),
22100         }
22101     }
22102 }
22103 unsafe impl TaggedStructure for PipelineDiscardRectangleStateCreateInfoEXT {
22104     const STRUCTURE_TYPE: StructureType =
22105         StructureType::PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT;
22106 }
22107 impl PipelineDiscardRectangleStateCreateInfoEXT {
builder<'a>() -> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a>22108     pub fn builder<'a>() -> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
22109         PipelineDiscardRectangleStateCreateInfoEXTBuilder {
22110             inner: Self::default(),
22111             marker: ::std::marker::PhantomData,
22112         }
22113     }
22114 }
22115 #[repr(transparent)]
22116 pub struct PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
22117     inner: PipelineDiscardRectangleStateCreateInfoEXT,
22118     marker: ::std::marker::PhantomData<&'a ()>,
22119 }
22120 unsafe impl ExtendsGraphicsPipelineCreateInfo
22121     for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'_>
22122 {
22123 }
22124 unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineDiscardRectangleStateCreateInfoEXT {}
22125 impl<'a> ::std::ops::Deref for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
22126     type Target = PipelineDiscardRectangleStateCreateInfoEXT;
deref(&self) -> &Self::Target22127     fn deref(&self) -> &Self::Target {
22128         &self.inner
22129     }
22130 }
22131 impl<'a> ::std::ops::DerefMut for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target22132     fn deref_mut(&mut self) -> &mut Self::Target {
22133         &mut self.inner
22134     }
22135 }
22136 impl<'a> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
22137     #[inline]
flags(mut self, flags: PipelineDiscardRectangleStateCreateFlagsEXT) -> Self22138     pub fn flags(mut self, flags: PipelineDiscardRectangleStateCreateFlagsEXT) -> Self {
22139         self.inner.flags = flags;
22140         self
22141     }
22142     #[inline]
discard_rectangle_mode( mut self, discard_rectangle_mode: DiscardRectangleModeEXT, ) -> Self22143     pub fn discard_rectangle_mode(
22144         mut self,
22145         discard_rectangle_mode: DiscardRectangleModeEXT,
22146     ) -> Self {
22147         self.inner.discard_rectangle_mode = discard_rectangle_mode;
22148         self
22149     }
22150     #[inline]
discard_rectangles(mut self, discard_rectangles: &'a [Rect2D]) -> Self22151     pub fn discard_rectangles(mut self, discard_rectangles: &'a [Rect2D]) -> Self {
22152         self.inner.discard_rectangle_count = discard_rectangles.len() as _;
22153         self.inner.p_discard_rectangles = discard_rectangles.as_ptr();
22154         self
22155     }
22156     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22157     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22158     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineDiscardRectangleStateCreateInfoEXT22159     pub fn build(self) -> PipelineDiscardRectangleStateCreateInfoEXT {
22160         self.inner
22161     }
22162 }
22163 #[repr(C)]
22164 #[cfg_attr(feature = "debug", derive(Debug))]
22165 #[derive(Copy, Clone)]
22166 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX.html>"]
22167 pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
22168     pub s_type: StructureType,
22169     pub p_next: *mut c_void,
22170     pub per_view_position_all_components: Bool32,
22171 }
22172 impl ::std::default::Default for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
22173     #[inline]
default() -> Self22174     fn default() -> Self {
22175         Self {
22176             s_type: Self::STRUCTURE_TYPE,
22177             p_next: ::std::ptr::null_mut(),
22178             per_view_position_all_components: Bool32::default(),
22179         }
22180     }
22181 }
22182 unsafe impl TaggedStructure for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
22183     const STRUCTURE_TYPE: StructureType =
22184         StructureType::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX;
22185 }
22186 impl PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
builder<'a>() -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a>22187     pub fn builder<'a>() -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
22188         PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder {
22189             inner: Self::default(),
22190             marker: ::std::marker::PhantomData,
22191         }
22192     }
22193 }
22194 #[repr(transparent)]
22195 pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
22196     inner: PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX,
22197     marker: ::std::marker::PhantomData<&'a ()>,
22198 }
22199 unsafe impl ExtendsPhysicalDeviceProperties2
22200     for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'_>
22201 {
22202 }
22203 unsafe impl ExtendsPhysicalDeviceProperties2
22204     for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
22205 {
22206 }
22207 impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
22208     type Target = PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
deref(&self) -> &Self::Target22209     fn deref(&self) -> &Self::Target {
22210         &self.inner
22211     }
22212 }
22213 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target22214     fn deref_mut(&mut self) -> &mut Self::Target {
22215         &mut self.inner
22216     }
22217 }
22218 impl<'a> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
22219     #[inline]
per_view_position_all_components( mut self, per_view_position_all_components: bool, ) -> Self22220     pub fn per_view_position_all_components(
22221         mut self,
22222         per_view_position_all_components: bool,
22223     ) -> Self {
22224         self.inner.per_view_position_all_components = per_view_position_all_components.into();
22225         self
22226     }
22227     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22228     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22229     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX22230     pub fn build(self) -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
22231         self.inner
22232     }
22233 }
22234 #[repr(C)]
22235 #[cfg_attr(feature = "debug", derive(Debug))]
22236 #[derive(Copy, Clone, Default)]
22237 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkInputAttachmentAspectReference.html>"]
22238 pub struct InputAttachmentAspectReference {
22239     pub subpass: u32,
22240     pub input_attachment_index: u32,
22241     pub aspect_mask: ImageAspectFlags,
22242 }
22243 impl InputAttachmentAspectReference {
builder<'a>() -> InputAttachmentAspectReferenceBuilder<'a>22244     pub fn builder<'a>() -> InputAttachmentAspectReferenceBuilder<'a> {
22245         InputAttachmentAspectReferenceBuilder {
22246             inner: Self::default(),
22247             marker: ::std::marker::PhantomData,
22248         }
22249     }
22250 }
22251 #[repr(transparent)]
22252 pub struct InputAttachmentAspectReferenceBuilder<'a> {
22253     inner: InputAttachmentAspectReference,
22254     marker: ::std::marker::PhantomData<&'a ()>,
22255 }
22256 impl<'a> ::std::ops::Deref for InputAttachmentAspectReferenceBuilder<'a> {
22257     type Target = InputAttachmentAspectReference;
deref(&self) -> &Self::Target22258     fn deref(&self) -> &Self::Target {
22259         &self.inner
22260     }
22261 }
22262 impl<'a> ::std::ops::DerefMut for InputAttachmentAspectReferenceBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target22263     fn deref_mut(&mut self) -> &mut Self::Target {
22264         &mut self.inner
22265     }
22266 }
22267 impl<'a> InputAttachmentAspectReferenceBuilder<'a> {
22268     #[inline]
subpass(mut self, subpass: u32) -> Self22269     pub fn subpass(mut self, subpass: u32) -> Self {
22270         self.inner.subpass = subpass;
22271         self
22272     }
22273     #[inline]
input_attachment_index(mut self, input_attachment_index: u32) -> Self22274     pub fn input_attachment_index(mut self, input_attachment_index: u32) -> Self {
22275         self.inner.input_attachment_index = input_attachment_index;
22276         self
22277     }
22278     #[inline]
aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self22279     pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self {
22280         self.inner.aspect_mask = aspect_mask;
22281         self
22282     }
22283     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22284     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22285     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> InputAttachmentAspectReference22286     pub fn build(self) -> InputAttachmentAspectReference {
22287         self.inner
22288     }
22289 }
22290 #[repr(C)]
22291 #[cfg_attr(feature = "debug", derive(Debug))]
22292 #[derive(Copy, Clone)]
22293 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassInputAttachmentAspectCreateInfo.html>"]
22294 pub struct RenderPassInputAttachmentAspectCreateInfo {
22295     pub s_type: StructureType,
22296     pub p_next: *const c_void,
22297     pub aspect_reference_count: u32,
22298     pub p_aspect_references: *const InputAttachmentAspectReference,
22299 }
22300 impl ::std::default::Default for RenderPassInputAttachmentAspectCreateInfo {
22301     #[inline]
default() -> Self22302     fn default() -> Self {
22303         Self {
22304             s_type: Self::STRUCTURE_TYPE,
22305             p_next: ::std::ptr::null(),
22306             aspect_reference_count: u32::default(),
22307             p_aspect_references: ::std::ptr::null(),
22308         }
22309     }
22310 }
22311 unsafe impl TaggedStructure for RenderPassInputAttachmentAspectCreateInfo {
22312     const STRUCTURE_TYPE: StructureType =
22313         StructureType::RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO;
22314 }
22315 impl RenderPassInputAttachmentAspectCreateInfo {
builder<'a>() -> RenderPassInputAttachmentAspectCreateInfoBuilder<'a>22316     pub fn builder<'a>() -> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
22317         RenderPassInputAttachmentAspectCreateInfoBuilder {
22318             inner: Self::default(),
22319             marker: ::std::marker::PhantomData,
22320         }
22321     }
22322 }
22323 #[repr(transparent)]
22324 pub struct RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
22325     inner: RenderPassInputAttachmentAspectCreateInfo,
22326     marker: ::std::marker::PhantomData<&'a ()>,
22327 }
22328 unsafe impl ExtendsRenderPassCreateInfo for RenderPassInputAttachmentAspectCreateInfoBuilder<'_> {}
22329 unsafe impl ExtendsRenderPassCreateInfo for RenderPassInputAttachmentAspectCreateInfo {}
22330 impl<'a> ::std::ops::Deref for RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
22331     type Target = RenderPassInputAttachmentAspectCreateInfo;
deref(&self) -> &Self::Target22332     fn deref(&self) -> &Self::Target {
22333         &self.inner
22334     }
22335 }
22336 impl<'a> ::std::ops::DerefMut for RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target22337     fn deref_mut(&mut self) -> &mut Self::Target {
22338         &mut self.inner
22339     }
22340 }
22341 impl<'a> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
22342     #[inline]
aspect_references( mut self, aspect_references: &'a [InputAttachmentAspectReference], ) -> Self22343     pub fn aspect_references(
22344         mut self,
22345         aspect_references: &'a [InputAttachmentAspectReference],
22346     ) -> Self {
22347         self.inner.aspect_reference_count = aspect_references.len() as _;
22348         self.inner.p_aspect_references = aspect_references.as_ptr();
22349         self
22350     }
22351     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22352     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22353     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RenderPassInputAttachmentAspectCreateInfo22354     pub fn build(self) -> RenderPassInputAttachmentAspectCreateInfo {
22355         self.inner
22356     }
22357 }
22358 #[repr(C)]
22359 #[cfg_attr(feature = "debug", derive(Debug))]
22360 #[derive(Copy, Clone)]
22361 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSurfaceInfo2KHR.html>"]
22362 pub struct PhysicalDeviceSurfaceInfo2KHR {
22363     pub s_type: StructureType,
22364     pub p_next: *const c_void,
22365     pub surface: SurfaceKHR,
22366 }
22367 impl ::std::default::Default for PhysicalDeviceSurfaceInfo2KHR {
22368     #[inline]
default() -> Self22369     fn default() -> Self {
22370         Self {
22371             s_type: Self::STRUCTURE_TYPE,
22372             p_next: ::std::ptr::null(),
22373             surface: SurfaceKHR::default(),
22374         }
22375     }
22376 }
22377 unsafe impl TaggedStructure for PhysicalDeviceSurfaceInfo2KHR {
22378     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_SURFACE_INFO_2_KHR;
22379 }
22380 impl PhysicalDeviceSurfaceInfo2KHR {
builder<'a>() -> PhysicalDeviceSurfaceInfo2KHRBuilder<'a>22381     pub fn builder<'a>() -> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
22382         PhysicalDeviceSurfaceInfo2KHRBuilder {
22383             inner: Self::default(),
22384             marker: ::std::marker::PhantomData,
22385         }
22386     }
22387 }
22388 #[repr(transparent)]
22389 pub struct PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
22390     inner: PhysicalDeviceSurfaceInfo2KHR,
22391     marker: ::std::marker::PhantomData<&'a ()>,
22392 }
22393 pub unsafe trait ExtendsPhysicalDeviceSurfaceInfo2KHR {}
22394 impl<'a> ::std::ops::Deref for PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
22395     type Target = PhysicalDeviceSurfaceInfo2KHR;
deref(&self) -> &Self::Target22396     fn deref(&self) -> &Self::Target {
22397         &self.inner
22398     }
22399 }
22400 impl<'a> ::std::ops::DerefMut for PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target22401     fn deref_mut(&mut self) -> &mut Self::Target {
22402         &mut self.inner
22403     }
22404 }
22405 impl<'a> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
22406     #[inline]
surface(mut self, surface: SurfaceKHR) -> Self22407     pub fn surface(mut self, surface: SurfaceKHR) -> Self {
22408         self.inner.surface = surface;
22409         self
22410     }
22411     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
22412     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
22413     #[doc = r" valid extension structs can be pushed into the chain."]
22414     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
22415     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPhysicalDeviceSurfaceInfo2KHR>(mut self, next: &'a mut T) -> Self22416     pub fn push_next<T: ExtendsPhysicalDeviceSurfaceInfo2KHR>(mut self, next: &'a mut T) -> Self {
22417         unsafe {
22418             let next_ptr = <*const T>::cast(next);
22419             let last_next = ptr_chain_iter(next).last().unwrap();
22420             (*last_next).p_next = self.inner.p_next as _;
22421             self.inner.p_next = next_ptr;
22422         }
22423         self
22424     }
22425     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22426     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22427     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceSurfaceInfo2KHR22428     pub fn build(self) -> PhysicalDeviceSurfaceInfo2KHR {
22429         self.inner
22430     }
22431 }
22432 #[repr(C)]
22433 #[cfg_attr(feature = "debug", derive(Debug))]
22434 #[derive(Copy, Clone)]
22435 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceCapabilities2KHR.html>"]
22436 pub struct SurfaceCapabilities2KHR {
22437     pub s_type: StructureType,
22438     pub p_next: *mut c_void,
22439     pub surface_capabilities: SurfaceCapabilitiesKHR,
22440 }
22441 impl ::std::default::Default for SurfaceCapabilities2KHR {
22442     #[inline]
default() -> Self22443     fn default() -> Self {
22444         Self {
22445             s_type: Self::STRUCTURE_TYPE,
22446             p_next: ::std::ptr::null_mut(),
22447             surface_capabilities: SurfaceCapabilitiesKHR::default(),
22448         }
22449     }
22450 }
22451 unsafe impl TaggedStructure for SurfaceCapabilities2KHR {
22452     const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_CAPABILITIES_2_KHR;
22453 }
22454 impl SurfaceCapabilities2KHR {
builder<'a>() -> SurfaceCapabilities2KHRBuilder<'a>22455     pub fn builder<'a>() -> SurfaceCapabilities2KHRBuilder<'a> {
22456         SurfaceCapabilities2KHRBuilder {
22457             inner: Self::default(),
22458             marker: ::std::marker::PhantomData,
22459         }
22460     }
22461 }
22462 #[repr(transparent)]
22463 pub struct SurfaceCapabilities2KHRBuilder<'a> {
22464     inner: SurfaceCapabilities2KHR,
22465     marker: ::std::marker::PhantomData<&'a ()>,
22466 }
22467 pub unsafe trait ExtendsSurfaceCapabilities2KHR {}
22468 impl<'a> ::std::ops::Deref for SurfaceCapabilities2KHRBuilder<'a> {
22469     type Target = SurfaceCapabilities2KHR;
deref(&self) -> &Self::Target22470     fn deref(&self) -> &Self::Target {
22471         &self.inner
22472     }
22473 }
22474 impl<'a> ::std::ops::DerefMut for SurfaceCapabilities2KHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target22475     fn deref_mut(&mut self) -> &mut Self::Target {
22476         &mut self.inner
22477     }
22478 }
22479 impl<'a> SurfaceCapabilities2KHRBuilder<'a> {
22480     #[inline]
surface_capabilities(mut self, surface_capabilities: SurfaceCapabilitiesKHR) -> Self22481     pub fn surface_capabilities(mut self, surface_capabilities: SurfaceCapabilitiesKHR) -> Self {
22482         self.inner.surface_capabilities = surface_capabilities;
22483         self
22484     }
22485     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
22486     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
22487     #[doc = r" valid extension structs can be pushed into the chain."]
22488     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
22489     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSurfaceCapabilities2KHR>(mut self, next: &'a mut T) -> Self22490     pub fn push_next<T: ExtendsSurfaceCapabilities2KHR>(mut self, next: &'a mut T) -> Self {
22491         unsafe {
22492             let next_ptr = <*mut T>::cast(next);
22493             let last_next = ptr_chain_iter(next).last().unwrap();
22494             (*last_next).p_next = self.inner.p_next as _;
22495             self.inner.p_next = next_ptr;
22496         }
22497         self
22498     }
22499     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22500     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22501     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SurfaceCapabilities2KHR22502     pub fn build(self) -> SurfaceCapabilities2KHR {
22503         self.inner
22504     }
22505 }
22506 #[repr(C)]
22507 #[cfg_attr(feature = "debug", derive(Debug))]
22508 #[derive(Copy, Clone)]
22509 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceFormat2KHR.html>"]
22510 pub struct SurfaceFormat2KHR {
22511     pub s_type: StructureType,
22512     pub p_next: *mut c_void,
22513     pub surface_format: SurfaceFormatKHR,
22514 }
22515 impl ::std::default::Default for SurfaceFormat2KHR {
22516     #[inline]
default() -> Self22517     fn default() -> Self {
22518         Self {
22519             s_type: Self::STRUCTURE_TYPE,
22520             p_next: ::std::ptr::null_mut(),
22521             surface_format: SurfaceFormatKHR::default(),
22522         }
22523     }
22524 }
22525 unsafe impl TaggedStructure for SurfaceFormat2KHR {
22526     const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_FORMAT_2_KHR;
22527 }
22528 impl SurfaceFormat2KHR {
builder<'a>() -> SurfaceFormat2KHRBuilder<'a>22529     pub fn builder<'a>() -> SurfaceFormat2KHRBuilder<'a> {
22530         SurfaceFormat2KHRBuilder {
22531             inner: Self::default(),
22532             marker: ::std::marker::PhantomData,
22533         }
22534     }
22535 }
22536 #[repr(transparent)]
22537 pub struct SurfaceFormat2KHRBuilder<'a> {
22538     inner: SurfaceFormat2KHR,
22539     marker: ::std::marker::PhantomData<&'a ()>,
22540 }
22541 pub unsafe trait ExtendsSurfaceFormat2KHR {}
22542 impl<'a> ::std::ops::Deref for SurfaceFormat2KHRBuilder<'a> {
22543     type Target = SurfaceFormat2KHR;
deref(&self) -> &Self::Target22544     fn deref(&self) -> &Self::Target {
22545         &self.inner
22546     }
22547 }
22548 impl<'a> ::std::ops::DerefMut for SurfaceFormat2KHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target22549     fn deref_mut(&mut self) -> &mut Self::Target {
22550         &mut self.inner
22551     }
22552 }
22553 impl<'a> SurfaceFormat2KHRBuilder<'a> {
22554     #[inline]
surface_format(mut self, surface_format: SurfaceFormatKHR) -> Self22555     pub fn surface_format(mut self, surface_format: SurfaceFormatKHR) -> Self {
22556         self.inner.surface_format = surface_format;
22557         self
22558     }
22559     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
22560     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
22561     #[doc = r" valid extension structs can be pushed into the chain."]
22562     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
22563     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSurfaceFormat2KHR>(mut self, next: &'a mut T) -> Self22564     pub fn push_next<T: ExtendsSurfaceFormat2KHR>(mut self, next: &'a mut T) -> Self {
22565         unsafe {
22566             let next_ptr = <*mut T>::cast(next);
22567             let last_next = ptr_chain_iter(next).last().unwrap();
22568             (*last_next).p_next = self.inner.p_next as _;
22569             self.inner.p_next = next_ptr;
22570         }
22571         self
22572     }
22573     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22574     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22575     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SurfaceFormat2KHR22576     pub fn build(self) -> SurfaceFormat2KHR {
22577         self.inner
22578     }
22579 }
22580 #[repr(C)]
22581 #[cfg_attr(feature = "debug", derive(Debug))]
22582 #[derive(Copy, Clone)]
22583 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayProperties2KHR.html>"]
22584 pub struct DisplayProperties2KHR {
22585     pub s_type: StructureType,
22586     pub p_next: *mut c_void,
22587     pub display_properties: DisplayPropertiesKHR,
22588 }
22589 impl ::std::default::Default for DisplayProperties2KHR {
22590     #[inline]
default() -> Self22591     fn default() -> Self {
22592         Self {
22593             s_type: Self::STRUCTURE_TYPE,
22594             p_next: ::std::ptr::null_mut(),
22595             display_properties: DisplayPropertiesKHR::default(),
22596         }
22597     }
22598 }
22599 unsafe impl TaggedStructure for DisplayProperties2KHR {
22600     const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_PROPERTIES_2_KHR;
22601 }
22602 impl DisplayProperties2KHR {
builder<'a>() -> DisplayProperties2KHRBuilder<'a>22603     pub fn builder<'a>() -> DisplayProperties2KHRBuilder<'a> {
22604         DisplayProperties2KHRBuilder {
22605             inner: Self::default(),
22606             marker: ::std::marker::PhantomData,
22607         }
22608     }
22609 }
22610 #[repr(transparent)]
22611 pub struct DisplayProperties2KHRBuilder<'a> {
22612     inner: DisplayProperties2KHR,
22613     marker: ::std::marker::PhantomData<&'a ()>,
22614 }
22615 impl<'a> ::std::ops::Deref for DisplayProperties2KHRBuilder<'a> {
22616     type Target = DisplayProperties2KHR;
deref(&self) -> &Self::Target22617     fn deref(&self) -> &Self::Target {
22618         &self.inner
22619     }
22620 }
22621 impl<'a> ::std::ops::DerefMut for DisplayProperties2KHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target22622     fn deref_mut(&mut self) -> &mut Self::Target {
22623         &mut self.inner
22624     }
22625 }
22626 impl<'a> DisplayProperties2KHRBuilder<'a> {
22627     #[inline]
display_properties(mut self, display_properties: DisplayPropertiesKHR) -> Self22628     pub fn display_properties(mut self, display_properties: DisplayPropertiesKHR) -> Self {
22629         self.inner.display_properties = display_properties;
22630         self
22631     }
22632     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22633     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22634     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayProperties2KHR22635     pub fn build(self) -> DisplayProperties2KHR {
22636         self.inner
22637     }
22638 }
22639 #[repr(C)]
22640 #[cfg_attr(feature = "debug", derive(Debug))]
22641 #[derive(Copy, Clone)]
22642 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPlaneProperties2KHR.html>"]
22643 pub struct DisplayPlaneProperties2KHR {
22644     pub s_type: StructureType,
22645     pub p_next: *mut c_void,
22646     pub display_plane_properties: DisplayPlanePropertiesKHR,
22647 }
22648 impl ::std::default::Default for DisplayPlaneProperties2KHR {
22649     #[inline]
default() -> Self22650     fn default() -> Self {
22651         Self {
22652             s_type: Self::STRUCTURE_TYPE,
22653             p_next: ::std::ptr::null_mut(),
22654             display_plane_properties: DisplayPlanePropertiesKHR::default(),
22655         }
22656     }
22657 }
22658 unsafe impl TaggedStructure for DisplayPlaneProperties2KHR {
22659     const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_PLANE_PROPERTIES_2_KHR;
22660 }
22661 impl DisplayPlaneProperties2KHR {
builder<'a>() -> DisplayPlaneProperties2KHRBuilder<'a>22662     pub fn builder<'a>() -> DisplayPlaneProperties2KHRBuilder<'a> {
22663         DisplayPlaneProperties2KHRBuilder {
22664             inner: Self::default(),
22665             marker: ::std::marker::PhantomData,
22666         }
22667     }
22668 }
22669 #[repr(transparent)]
22670 pub struct DisplayPlaneProperties2KHRBuilder<'a> {
22671     inner: DisplayPlaneProperties2KHR,
22672     marker: ::std::marker::PhantomData<&'a ()>,
22673 }
22674 impl<'a> ::std::ops::Deref for DisplayPlaneProperties2KHRBuilder<'a> {
22675     type Target = DisplayPlaneProperties2KHR;
deref(&self) -> &Self::Target22676     fn deref(&self) -> &Self::Target {
22677         &self.inner
22678     }
22679 }
22680 impl<'a> ::std::ops::DerefMut for DisplayPlaneProperties2KHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target22681     fn deref_mut(&mut self) -> &mut Self::Target {
22682         &mut self.inner
22683     }
22684 }
22685 impl<'a> DisplayPlaneProperties2KHRBuilder<'a> {
22686     #[inline]
display_plane_properties( mut self, display_plane_properties: DisplayPlanePropertiesKHR, ) -> Self22687     pub fn display_plane_properties(
22688         mut self,
22689         display_plane_properties: DisplayPlanePropertiesKHR,
22690     ) -> Self {
22691         self.inner.display_plane_properties = display_plane_properties;
22692         self
22693     }
22694     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22695     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22696     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayPlaneProperties2KHR22697     pub fn build(self) -> DisplayPlaneProperties2KHR {
22698         self.inner
22699     }
22700 }
22701 #[repr(C)]
22702 #[cfg_attr(feature = "debug", derive(Debug))]
22703 #[derive(Copy, Clone)]
22704 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModeProperties2KHR.html>"]
22705 pub struct DisplayModeProperties2KHR {
22706     pub s_type: StructureType,
22707     pub p_next: *mut c_void,
22708     pub display_mode_properties: DisplayModePropertiesKHR,
22709 }
22710 impl ::std::default::Default for DisplayModeProperties2KHR {
22711     #[inline]
default() -> Self22712     fn default() -> Self {
22713         Self {
22714             s_type: Self::STRUCTURE_TYPE,
22715             p_next: ::std::ptr::null_mut(),
22716             display_mode_properties: DisplayModePropertiesKHR::default(),
22717         }
22718     }
22719 }
22720 unsafe impl TaggedStructure for DisplayModeProperties2KHR {
22721     const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_MODE_PROPERTIES_2_KHR;
22722 }
22723 impl DisplayModeProperties2KHR {
builder<'a>() -> DisplayModeProperties2KHRBuilder<'a>22724     pub fn builder<'a>() -> DisplayModeProperties2KHRBuilder<'a> {
22725         DisplayModeProperties2KHRBuilder {
22726             inner: Self::default(),
22727             marker: ::std::marker::PhantomData,
22728         }
22729     }
22730 }
22731 #[repr(transparent)]
22732 pub struct DisplayModeProperties2KHRBuilder<'a> {
22733     inner: DisplayModeProperties2KHR,
22734     marker: ::std::marker::PhantomData<&'a ()>,
22735 }
22736 impl<'a> ::std::ops::Deref for DisplayModeProperties2KHRBuilder<'a> {
22737     type Target = DisplayModeProperties2KHR;
deref(&self) -> &Self::Target22738     fn deref(&self) -> &Self::Target {
22739         &self.inner
22740     }
22741 }
22742 impl<'a> ::std::ops::DerefMut for DisplayModeProperties2KHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target22743     fn deref_mut(&mut self) -> &mut Self::Target {
22744         &mut self.inner
22745     }
22746 }
22747 impl<'a> DisplayModeProperties2KHRBuilder<'a> {
22748     #[inline]
display_mode_properties( mut self, display_mode_properties: DisplayModePropertiesKHR, ) -> Self22749     pub fn display_mode_properties(
22750         mut self,
22751         display_mode_properties: DisplayModePropertiesKHR,
22752     ) -> Self {
22753         self.inner.display_mode_properties = display_mode_properties;
22754         self
22755     }
22756     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22757     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22758     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayModeProperties2KHR22759     pub fn build(self) -> DisplayModeProperties2KHR {
22760         self.inner
22761     }
22762 }
22763 #[repr(C)]
22764 #[cfg_attr(feature = "debug", derive(Debug))]
22765 #[derive(Copy, Clone)]
22766 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPlaneInfo2KHR.html>"]
22767 pub struct DisplayPlaneInfo2KHR {
22768     pub s_type: StructureType,
22769     pub p_next: *const c_void,
22770     pub mode: DisplayModeKHR,
22771     pub plane_index: u32,
22772 }
22773 impl ::std::default::Default for DisplayPlaneInfo2KHR {
22774     #[inline]
default() -> Self22775     fn default() -> Self {
22776         Self {
22777             s_type: Self::STRUCTURE_TYPE,
22778             p_next: ::std::ptr::null(),
22779             mode: DisplayModeKHR::default(),
22780             plane_index: u32::default(),
22781         }
22782     }
22783 }
22784 unsafe impl TaggedStructure for DisplayPlaneInfo2KHR {
22785     const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_PLANE_INFO_2_KHR;
22786 }
22787 impl DisplayPlaneInfo2KHR {
builder<'a>() -> DisplayPlaneInfo2KHRBuilder<'a>22788     pub fn builder<'a>() -> DisplayPlaneInfo2KHRBuilder<'a> {
22789         DisplayPlaneInfo2KHRBuilder {
22790             inner: Self::default(),
22791             marker: ::std::marker::PhantomData,
22792         }
22793     }
22794 }
22795 #[repr(transparent)]
22796 pub struct DisplayPlaneInfo2KHRBuilder<'a> {
22797     inner: DisplayPlaneInfo2KHR,
22798     marker: ::std::marker::PhantomData<&'a ()>,
22799 }
22800 impl<'a> ::std::ops::Deref for DisplayPlaneInfo2KHRBuilder<'a> {
22801     type Target = DisplayPlaneInfo2KHR;
deref(&self) -> &Self::Target22802     fn deref(&self) -> &Self::Target {
22803         &self.inner
22804     }
22805 }
22806 impl<'a> ::std::ops::DerefMut for DisplayPlaneInfo2KHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target22807     fn deref_mut(&mut self) -> &mut Self::Target {
22808         &mut self.inner
22809     }
22810 }
22811 impl<'a> DisplayPlaneInfo2KHRBuilder<'a> {
22812     #[inline]
mode(mut self, mode: DisplayModeKHR) -> Self22813     pub fn mode(mut self, mode: DisplayModeKHR) -> Self {
22814         self.inner.mode = mode;
22815         self
22816     }
22817     #[inline]
plane_index(mut self, plane_index: u32) -> Self22818     pub fn plane_index(mut self, plane_index: u32) -> Self {
22819         self.inner.plane_index = plane_index;
22820         self
22821     }
22822     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22823     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22824     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayPlaneInfo2KHR22825     pub fn build(self) -> DisplayPlaneInfo2KHR {
22826         self.inner
22827     }
22828 }
22829 #[repr(C)]
22830 #[cfg_attr(feature = "debug", derive(Debug))]
22831 #[derive(Copy, Clone)]
22832 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPlaneCapabilities2KHR.html>"]
22833 pub struct DisplayPlaneCapabilities2KHR {
22834     pub s_type: StructureType,
22835     pub p_next: *mut c_void,
22836     pub capabilities: DisplayPlaneCapabilitiesKHR,
22837 }
22838 impl ::std::default::Default for DisplayPlaneCapabilities2KHR {
22839     #[inline]
default() -> Self22840     fn default() -> Self {
22841         Self {
22842             s_type: Self::STRUCTURE_TYPE,
22843             p_next: ::std::ptr::null_mut(),
22844             capabilities: DisplayPlaneCapabilitiesKHR::default(),
22845         }
22846     }
22847 }
22848 unsafe impl TaggedStructure for DisplayPlaneCapabilities2KHR {
22849     const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_PLANE_CAPABILITIES_2_KHR;
22850 }
22851 impl DisplayPlaneCapabilities2KHR {
builder<'a>() -> DisplayPlaneCapabilities2KHRBuilder<'a>22852     pub fn builder<'a>() -> DisplayPlaneCapabilities2KHRBuilder<'a> {
22853         DisplayPlaneCapabilities2KHRBuilder {
22854             inner: Self::default(),
22855             marker: ::std::marker::PhantomData,
22856         }
22857     }
22858 }
22859 #[repr(transparent)]
22860 pub struct DisplayPlaneCapabilities2KHRBuilder<'a> {
22861     inner: DisplayPlaneCapabilities2KHR,
22862     marker: ::std::marker::PhantomData<&'a ()>,
22863 }
22864 impl<'a> ::std::ops::Deref for DisplayPlaneCapabilities2KHRBuilder<'a> {
22865     type Target = DisplayPlaneCapabilities2KHR;
deref(&self) -> &Self::Target22866     fn deref(&self) -> &Self::Target {
22867         &self.inner
22868     }
22869 }
22870 impl<'a> ::std::ops::DerefMut for DisplayPlaneCapabilities2KHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target22871     fn deref_mut(&mut self) -> &mut Self::Target {
22872         &mut self.inner
22873     }
22874 }
22875 impl<'a> DisplayPlaneCapabilities2KHRBuilder<'a> {
22876     #[inline]
capabilities(mut self, capabilities: DisplayPlaneCapabilitiesKHR) -> Self22877     pub fn capabilities(mut self, capabilities: DisplayPlaneCapabilitiesKHR) -> Self {
22878         self.inner.capabilities = capabilities;
22879         self
22880     }
22881     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22882     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22883     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayPlaneCapabilities2KHR22884     pub fn build(self) -> DisplayPlaneCapabilities2KHR {
22885         self.inner
22886     }
22887 }
22888 #[repr(C)]
22889 #[cfg_attr(feature = "debug", derive(Debug))]
22890 #[derive(Copy, Clone)]
22891 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSharedPresentSurfaceCapabilitiesKHR.html>"]
22892 pub struct SharedPresentSurfaceCapabilitiesKHR {
22893     pub s_type: StructureType,
22894     pub p_next: *mut c_void,
22895     pub shared_present_supported_usage_flags: ImageUsageFlags,
22896 }
22897 impl ::std::default::Default for SharedPresentSurfaceCapabilitiesKHR {
22898     #[inline]
default() -> Self22899     fn default() -> Self {
22900         Self {
22901             s_type: Self::STRUCTURE_TYPE,
22902             p_next: ::std::ptr::null_mut(),
22903             shared_present_supported_usage_flags: ImageUsageFlags::default(),
22904         }
22905     }
22906 }
22907 unsafe impl TaggedStructure for SharedPresentSurfaceCapabilitiesKHR {
22908     const STRUCTURE_TYPE: StructureType = StructureType::SHARED_PRESENT_SURFACE_CAPABILITIES_KHR;
22909 }
22910 impl SharedPresentSurfaceCapabilitiesKHR {
builder<'a>() -> SharedPresentSurfaceCapabilitiesKHRBuilder<'a>22911     pub fn builder<'a>() -> SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
22912         SharedPresentSurfaceCapabilitiesKHRBuilder {
22913             inner: Self::default(),
22914             marker: ::std::marker::PhantomData,
22915         }
22916     }
22917 }
22918 #[repr(transparent)]
22919 pub struct SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
22920     inner: SharedPresentSurfaceCapabilitiesKHR,
22921     marker: ::std::marker::PhantomData<&'a ()>,
22922 }
22923 unsafe impl ExtendsSurfaceCapabilities2KHR for SharedPresentSurfaceCapabilitiesKHRBuilder<'_> {}
22924 unsafe impl ExtendsSurfaceCapabilities2KHR for SharedPresentSurfaceCapabilitiesKHR {}
22925 impl<'a> ::std::ops::Deref for SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
22926     type Target = SharedPresentSurfaceCapabilitiesKHR;
deref(&self) -> &Self::Target22927     fn deref(&self) -> &Self::Target {
22928         &self.inner
22929     }
22930 }
22931 impl<'a> ::std::ops::DerefMut for SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target22932     fn deref_mut(&mut self) -> &mut Self::Target {
22933         &mut self.inner
22934     }
22935 }
22936 impl<'a> SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
22937     #[inline]
shared_present_supported_usage_flags( mut self, shared_present_supported_usage_flags: ImageUsageFlags, ) -> Self22938     pub fn shared_present_supported_usage_flags(
22939         mut self,
22940         shared_present_supported_usage_flags: ImageUsageFlags,
22941     ) -> Self {
22942         self.inner.shared_present_supported_usage_flags = shared_present_supported_usage_flags;
22943         self
22944     }
22945     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22946     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22947     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SharedPresentSurfaceCapabilitiesKHR22948     pub fn build(self) -> SharedPresentSurfaceCapabilitiesKHR {
22949         self.inner
22950     }
22951 }
22952 #[repr(C)]
22953 #[cfg_attr(feature = "debug", derive(Debug))]
22954 #[derive(Copy, Clone)]
22955 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevice16BitStorageFeatures.html>"]
22956 pub struct PhysicalDevice16BitStorageFeatures {
22957     pub s_type: StructureType,
22958     pub p_next: *mut c_void,
22959     pub storage_buffer16_bit_access: Bool32,
22960     pub uniform_and_storage_buffer16_bit_access: Bool32,
22961     pub storage_push_constant16: Bool32,
22962     pub storage_input_output16: Bool32,
22963 }
22964 impl ::std::default::Default for PhysicalDevice16BitStorageFeatures {
22965     #[inline]
default() -> Self22966     fn default() -> Self {
22967         Self {
22968             s_type: Self::STRUCTURE_TYPE,
22969             p_next: ::std::ptr::null_mut(),
22970             storage_buffer16_bit_access: Bool32::default(),
22971             uniform_and_storage_buffer16_bit_access: Bool32::default(),
22972             storage_push_constant16: Bool32::default(),
22973             storage_input_output16: Bool32::default(),
22974         }
22975     }
22976 }
22977 unsafe impl TaggedStructure for PhysicalDevice16BitStorageFeatures {
22978     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
22979 }
22980 impl PhysicalDevice16BitStorageFeatures {
builder<'a>() -> PhysicalDevice16BitStorageFeaturesBuilder<'a>22981     pub fn builder<'a>() -> PhysicalDevice16BitStorageFeaturesBuilder<'a> {
22982         PhysicalDevice16BitStorageFeaturesBuilder {
22983             inner: Self::default(),
22984             marker: ::std::marker::PhantomData,
22985         }
22986     }
22987 }
22988 #[repr(transparent)]
22989 pub struct PhysicalDevice16BitStorageFeaturesBuilder<'a> {
22990     inner: PhysicalDevice16BitStorageFeatures,
22991     marker: ::std::marker::PhantomData<&'a ()>,
22992 }
22993 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice16BitStorageFeaturesBuilder<'_> {}
22994 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice16BitStorageFeatures {}
22995 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice16BitStorageFeaturesBuilder<'_> {}
22996 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice16BitStorageFeatures {}
22997 impl<'a> ::std::ops::Deref for PhysicalDevice16BitStorageFeaturesBuilder<'a> {
22998     type Target = PhysicalDevice16BitStorageFeatures;
deref(&self) -> &Self::Target22999     fn deref(&self) -> &Self::Target {
23000         &self.inner
23001     }
23002 }
23003 impl<'a> ::std::ops::DerefMut for PhysicalDevice16BitStorageFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target23004     fn deref_mut(&mut self) -> &mut Self::Target {
23005         &mut self.inner
23006     }
23007 }
23008 impl<'a> PhysicalDevice16BitStorageFeaturesBuilder<'a> {
23009     #[inline]
storage_buffer16_bit_access(mut self, storage_buffer16_bit_access: bool) -> Self23010     pub fn storage_buffer16_bit_access(mut self, storage_buffer16_bit_access: bool) -> Self {
23011         self.inner.storage_buffer16_bit_access = storage_buffer16_bit_access.into();
23012         self
23013     }
23014     #[inline]
uniform_and_storage_buffer16_bit_access( mut self, uniform_and_storage_buffer16_bit_access: bool, ) -> Self23015     pub fn uniform_and_storage_buffer16_bit_access(
23016         mut self,
23017         uniform_and_storage_buffer16_bit_access: bool,
23018     ) -> Self {
23019         self.inner.uniform_and_storage_buffer16_bit_access =
23020             uniform_and_storage_buffer16_bit_access.into();
23021         self
23022     }
23023     #[inline]
storage_push_constant16(mut self, storage_push_constant16: bool) -> Self23024     pub fn storage_push_constant16(mut self, storage_push_constant16: bool) -> Self {
23025         self.inner.storage_push_constant16 = storage_push_constant16.into();
23026         self
23027     }
23028     #[inline]
storage_input_output16(mut self, storage_input_output16: bool) -> Self23029     pub fn storage_input_output16(mut self, storage_input_output16: bool) -> Self {
23030         self.inner.storage_input_output16 = storage_input_output16.into();
23031         self
23032     }
23033     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23034     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23035     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevice16BitStorageFeatures23036     pub fn build(self) -> PhysicalDevice16BitStorageFeatures {
23037         self.inner
23038     }
23039 }
23040 #[repr(C)]
23041 #[cfg_attr(feature = "debug", derive(Debug))]
23042 #[derive(Copy, Clone)]
23043 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSubgroupProperties.html>"]
23044 pub struct PhysicalDeviceSubgroupProperties {
23045     pub s_type: StructureType,
23046     pub p_next: *mut c_void,
23047     pub subgroup_size: u32,
23048     pub supported_stages: ShaderStageFlags,
23049     pub supported_operations: SubgroupFeatureFlags,
23050     pub quad_operations_in_all_stages: Bool32,
23051 }
23052 impl ::std::default::Default for PhysicalDeviceSubgroupProperties {
23053     #[inline]
default() -> Self23054     fn default() -> Self {
23055         Self {
23056             s_type: Self::STRUCTURE_TYPE,
23057             p_next: ::std::ptr::null_mut(),
23058             subgroup_size: u32::default(),
23059             supported_stages: ShaderStageFlags::default(),
23060             supported_operations: SubgroupFeatureFlags::default(),
23061             quad_operations_in_all_stages: Bool32::default(),
23062         }
23063     }
23064 }
23065 unsafe impl TaggedStructure for PhysicalDeviceSubgroupProperties {
23066     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
23067 }
23068 impl PhysicalDeviceSubgroupProperties {
builder<'a>() -> PhysicalDeviceSubgroupPropertiesBuilder<'a>23069     pub fn builder<'a>() -> PhysicalDeviceSubgroupPropertiesBuilder<'a> {
23070         PhysicalDeviceSubgroupPropertiesBuilder {
23071             inner: Self::default(),
23072             marker: ::std::marker::PhantomData,
23073         }
23074     }
23075 }
23076 #[repr(transparent)]
23077 pub struct PhysicalDeviceSubgroupPropertiesBuilder<'a> {
23078     inner: PhysicalDeviceSubgroupProperties,
23079     marker: ::std::marker::PhantomData<&'a ()>,
23080 }
23081 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupPropertiesBuilder<'_> {}
23082 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupProperties {}
23083 impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupPropertiesBuilder<'a> {
23084     type Target = PhysicalDeviceSubgroupProperties;
deref(&self) -> &Self::Target23085     fn deref(&self) -> &Self::Target {
23086         &self.inner
23087     }
23088 }
23089 impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target23090     fn deref_mut(&mut self) -> &mut Self::Target {
23091         &mut self.inner
23092     }
23093 }
23094 impl<'a> PhysicalDeviceSubgroupPropertiesBuilder<'a> {
23095     #[inline]
subgroup_size(mut self, subgroup_size: u32) -> Self23096     pub fn subgroup_size(mut self, subgroup_size: u32) -> Self {
23097         self.inner.subgroup_size = subgroup_size;
23098         self
23099     }
23100     #[inline]
supported_stages(mut self, supported_stages: ShaderStageFlags) -> Self23101     pub fn supported_stages(mut self, supported_stages: ShaderStageFlags) -> Self {
23102         self.inner.supported_stages = supported_stages;
23103         self
23104     }
23105     #[inline]
supported_operations(mut self, supported_operations: SubgroupFeatureFlags) -> Self23106     pub fn supported_operations(mut self, supported_operations: SubgroupFeatureFlags) -> Self {
23107         self.inner.supported_operations = supported_operations;
23108         self
23109     }
23110     #[inline]
quad_operations_in_all_stages(mut self, quad_operations_in_all_stages: bool) -> Self23111     pub fn quad_operations_in_all_stages(mut self, quad_operations_in_all_stages: bool) -> Self {
23112         self.inner.quad_operations_in_all_stages = quad_operations_in_all_stages.into();
23113         self
23114     }
23115     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23116     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23117     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceSubgroupProperties23118     pub fn build(self) -> PhysicalDeviceSubgroupProperties {
23119         self.inner
23120     }
23121 }
23122 #[repr(C)]
23123 #[cfg_attr(feature = "debug", derive(Debug))]
23124 #[derive(Copy, Clone)]
23125 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures.html>"]
23126 pub struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
23127     pub s_type: StructureType,
23128     pub p_next: *mut c_void,
23129     pub shader_subgroup_extended_types: Bool32,
23130 }
23131 impl ::std::default::Default for PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
23132     #[inline]
default() -> Self23133     fn default() -> Self {
23134         Self {
23135             s_type: Self::STRUCTURE_TYPE,
23136             p_next: ::std::ptr::null_mut(),
23137             shader_subgroup_extended_types: Bool32::default(),
23138         }
23139     }
23140 }
23141 unsafe impl TaggedStructure for PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
23142     const STRUCTURE_TYPE: StructureType =
23143         StructureType::PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
23144 }
23145 impl PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
builder<'a>() -> PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a>23146     pub fn builder<'a>() -> PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
23147         PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder {
23148             inner: Self::default(),
23149             marker: ::std::marker::PhantomData,
23150         }
23151     }
23152 }
23153 #[repr(transparent)]
23154 pub struct PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
23155     inner: PhysicalDeviceShaderSubgroupExtendedTypesFeatures,
23156     marker: ::std::marker::PhantomData<&'a ()>,
23157 }
23158 unsafe impl ExtendsPhysicalDeviceFeatures2
23159     for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'_>
23160 {
23161 }
23162 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderSubgroupExtendedTypesFeatures {}
23163 unsafe impl ExtendsDeviceCreateInfo
23164     for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'_>
23165 {
23166 }
23167 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSubgroupExtendedTypesFeatures {}
23168 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
23169     type Target = PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
deref(&self) -> &Self::Target23170     fn deref(&self) -> &Self::Target {
23171         &self.inner
23172     }
23173 }
23174 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target23175     fn deref_mut(&mut self) -> &mut Self::Target {
23176         &mut self.inner
23177     }
23178 }
23179 impl<'a> PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
23180     #[inline]
shader_subgroup_extended_types(mut self, shader_subgroup_extended_types: bool) -> Self23181     pub fn shader_subgroup_extended_types(mut self, shader_subgroup_extended_types: bool) -> Self {
23182         self.inner.shader_subgroup_extended_types = shader_subgroup_extended_types.into();
23183         self
23184     }
23185     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23186     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23187     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderSubgroupExtendedTypesFeatures23188     pub fn build(self) -> PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
23189         self.inner
23190     }
23191 }
23192 #[repr(C)]
23193 #[cfg_attr(feature = "debug", derive(Debug))]
23194 #[derive(Copy, Clone)]
23195 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferMemoryRequirementsInfo2.html>"]
23196 pub struct BufferMemoryRequirementsInfo2 {
23197     pub s_type: StructureType,
23198     pub p_next: *const c_void,
23199     pub buffer: Buffer,
23200 }
23201 impl ::std::default::Default for BufferMemoryRequirementsInfo2 {
23202     #[inline]
default() -> Self23203     fn default() -> Self {
23204         Self {
23205             s_type: Self::STRUCTURE_TYPE,
23206             p_next: ::std::ptr::null(),
23207             buffer: Buffer::default(),
23208         }
23209     }
23210 }
23211 unsafe impl TaggedStructure for BufferMemoryRequirementsInfo2 {
23212     const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_MEMORY_REQUIREMENTS_INFO_2;
23213 }
23214 impl BufferMemoryRequirementsInfo2 {
builder<'a>() -> BufferMemoryRequirementsInfo2Builder<'a>23215     pub fn builder<'a>() -> BufferMemoryRequirementsInfo2Builder<'a> {
23216         BufferMemoryRequirementsInfo2Builder {
23217             inner: Self::default(),
23218             marker: ::std::marker::PhantomData,
23219         }
23220     }
23221 }
23222 #[repr(transparent)]
23223 pub struct BufferMemoryRequirementsInfo2Builder<'a> {
23224     inner: BufferMemoryRequirementsInfo2,
23225     marker: ::std::marker::PhantomData<&'a ()>,
23226 }
23227 impl<'a> ::std::ops::Deref for BufferMemoryRequirementsInfo2Builder<'a> {
23228     type Target = BufferMemoryRequirementsInfo2;
deref(&self) -> &Self::Target23229     fn deref(&self) -> &Self::Target {
23230         &self.inner
23231     }
23232 }
23233 impl<'a> ::std::ops::DerefMut for BufferMemoryRequirementsInfo2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target23234     fn deref_mut(&mut self) -> &mut Self::Target {
23235         &mut self.inner
23236     }
23237 }
23238 impl<'a> BufferMemoryRequirementsInfo2Builder<'a> {
23239     #[inline]
buffer(mut self, buffer: Buffer) -> Self23240     pub fn buffer(mut self, buffer: Buffer) -> Self {
23241         self.inner.buffer = buffer;
23242         self
23243     }
23244     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23245     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23246     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferMemoryRequirementsInfo223247     pub fn build(self) -> BufferMemoryRequirementsInfo2 {
23248         self.inner
23249     }
23250 }
23251 #[repr(C)]
23252 #[cfg_attr(feature = "debug", derive(Debug))]
23253 #[derive(Copy, Clone)]
23254 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceBufferMemoryRequirements.html>"]
23255 pub struct DeviceBufferMemoryRequirements {
23256     pub s_type: StructureType,
23257     pub p_next: *const c_void,
23258     pub p_create_info: *const BufferCreateInfo,
23259 }
23260 impl ::std::default::Default for DeviceBufferMemoryRequirements {
23261     #[inline]
default() -> Self23262     fn default() -> Self {
23263         Self {
23264             s_type: Self::STRUCTURE_TYPE,
23265             p_next: ::std::ptr::null(),
23266             p_create_info: ::std::ptr::null(),
23267         }
23268     }
23269 }
23270 unsafe impl TaggedStructure for DeviceBufferMemoryRequirements {
23271     const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_BUFFER_MEMORY_REQUIREMENTS;
23272 }
23273 impl DeviceBufferMemoryRequirements {
builder<'a>() -> DeviceBufferMemoryRequirementsBuilder<'a>23274     pub fn builder<'a>() -> DeviceBufferMemoryRequirementsBuilder<'a> {
23275         DeviceBufferMemoryRequirementsBuilder {
23276             inner: Self::default(),
23277             marker: ::std::marker::PhantomData,
23278         }
23279     }
23280 }
23281 #[repr(transparent)]
23282 pub struct DeviceBufferMemoryRequirementsBuilder<'a> {
23283     inner: DeviceBufferMemoryRequirements,
23284     marker: ::std::marker::PhantomData<&'a ()>,
23285 }
23286 impl<'a> ::std::ops::Deref for DeviceBufferMemoryRequirementsBuilder<'a> {
23287     type Target = DeviceBufferMemoryRequirements;
deref(&self) -> &Self::Target23288     fn deref(&self) -> &Self::Target {
23289         &self.inner
23290     }
23291 }
23292 impl<'a> ::std::ops::DerefMut for DeviceBufferMemoryRequirementsBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target23293     fn deref_mut(&mut self) -> &mut Self::Target {
23294         &mut self.inner
23295     }
23296 }
23297 impl<'a> DeviceBufferMemoryRequirementsBuilder<'a> {
23298     #[inline]
create_info(mut self, create_info: &'a BufferCreateInfo) -> Self23299     pub fn create_info(mut self, create_info: &'a BufferCreateInfo) -> Self {
23300         self.inner.p_create_info = create_info;
23301         self
23302     }
23303     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23304     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23305     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceBufferMemoryRequirements23306     pub fn build(self) -> DeviceBufferMemoryRequirements {
23307         self.inner
23308     }
23309 }
23310 #[repr(C)]
23311 #[cfg_attr(feature = "debug", derive(Debug))]
23312 #[derive(Copy, Clone)]
23313 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageMemoryRequirementsInfo2.html>"]
23314 pub struct ImageMemoryRequirementsInfo2 {
23315     pub s_type: StructureType,
23316     pub p_next: *const c_void,
23317     pub image: Image,
23318 }
23319 impl ::std::default::Default for ImageMemoryRequirementsInfo2 {
23320     #[inline]
default() -> Self23321     fn default() -> Self {
23322         Self {
23323             s_type: Self::STRUCTURE_TYPE,
23324             p_next: ::std::ptr::null(),
23325             image: Image::default(),
23326         }
23327     }
23328 }
23329 unsafe impl TaggedStructure for ImageMemoryRequirementsInfo2 {
23330     const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_MEMORY_REQUIREMENTS_INFO_2;
23331 }
23332 impl ImageMemoryRequirementsInfo2 {
builder<'a>() -> ImageMemoryRequirementsInfo2Builder<'a>23333     pub fn builder<'a>() -> ImageMemoryRequirementsInfo2Builder<'a> {
23334         ImageMemoryRequirementsInfo2Builder {
23335             inner: Self::default(),
23336             marker: ::std::marker::PhantomData,
23337         }
23338     }
23339 }
23340 #[repr(transparent)]
23341 pub struct ImageMemoryRequirementsInfo2Builder<'a> {
23342     inner: ImageMemoryRequirementsInfo2,
23343     marker: ::std::marker::PhantomData<&'a ()>,
23344 }
23345 pub unsafe trait ExtendsImageMemoryRequirementsInfo2 {}
23346 impl<'a> ::std::ops::Deref for ImageMemoryRequirementsInfo2Builder<'a> {
23347     type Target = ImageMemoryRequirementsInfo2;
deref(&self) -> &Self::Target23348     fn deref(&self) -> &Self::Target {
23349         &self.inner
23350     }
23351 }
23352 impl<'a> ::std::ops::DerefMut for ImageMemoryRequirementsInfo2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target23353     fn deref_mut(&mut self) -> &mut Self::Target {
23354         &mut self.inner
23355     }
23356 }
23357 impl<'a> ImageMemoryRequirementsInfo2Builder<'a> {
23358     #[inline]
image(mut self, image: Image) -> Self23359     pub fn image(mut self, image: Image) -> Self {
23360         self.inner.image = image;
23361         self
23362     }
23363     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
23364     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
23365     #[doc = r" valid extension structs can be pushed into the chain."]
23366     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
23367     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsImageMemoryRequirementsInfo2>(mut self, next: &'a mut T) -> Self23368     pub fn push_next<T: ExtendsImageMemoryRequirementsInfo2>(mut self, next: &'a mut T) -> Self {
23369         unsafe {
23370             let next_ptr = <*const T>::cast(next);
23371             let last_next = ptr_chain_iter(next).last().unwrap();
23372             (*last_next).p_next = self.inner.p_next as _;
23373             self.inner.p_next = next_ptr;
23374         }
23375         self
23376     }
23377     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23378     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23379     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageMemoryRequirementsInfo223380     pub fn build(self) -> ImageMemoryRequirementsInfo2 {
23381         self.inner
23382     }
23383 }
23384 #[repr(C)]
23385 #[cfg_attr(feature = "debug", derive(Debug))]
23386 #[derive(Copy, Clone)]
23387 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSparseMemoryRequirementsInfo2.html>"]
23388 pub struct ImageSparseMemoryRequirementsInfo2 {
23389     pub s_type: StructureType,
23390     pub p_next: *const c_void,
23391     pub image: Image,
23392 }
23393 impl ::std::default::Default for ImageSparseMemoryRequirementsInfo2 {
23394     #[inline]
default() -> Self23395     fn default() -> Self {
23396         Self {
23397             s_type: Self::STRUCTURE_TYPE,
23398             p_next: ::std::ptr::null(),
23399             image: Image::default(),
23400         }
23401     }
23402 }
23403 unsafe impl TaggedStructure for ImageSparseMemoryRequirementsInfo2 {
23404     const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2;
23405 }
23406 impl ImageSparseMemoryRequirementsInfo2 {
builder<'a>() -> ImageSparseMemoryRequirementsInfo2Builder<'a>23407     pub fn builder<'a>() -> ImageSparseMemoryRequirementsInfo2Builder<'a> {
23408         ImageSparseMemoryRequirementsInfo2Builder {
23409             inner: Self::default(),
23410             marker: ::std::marker::PhantomData,
23411         }
23412     }
23413 }
23414 #[repr(transparent)]
23415 pub struct ImageSparseMemoryRequirementsInfo2Builder<'a> {
23416     inner: ImageSparseMemoryRequirementsInfo2,
23417     marker: ::std::marker::PhantomData<&'a ()>,
23418 }
23419 impl<'a> ::std::ops::Deref for ImageSparseMemoryRequirementsInfo2Builder<'a> {
23420     type Target = ImageSparseMemoryRequirementsInfo2;
deref(&self) -> &Self::Target23421     fn deref(&self) -> &Self::Target {
23422         &self.inner
23423     }
23424 }
23425 impl<'a> ::std::ops::DerefMut for ImageSparseMemoryRequirementsInfo2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target23426     fn deref_mut(&mut self) -> &mut Self::Target {
23427         &mut self.inner
23428     }
23429 }
23430 impl<'a> ImageSparseMemoryRequirementsInfo2Builder<'a> {
23431     #[inline]
image(mut self, image: Image) -> Self23432     pub fn image(mut self, image: Image) -> Self {
23433         self.inner.image = image;
23434         self
23435     }
23436     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23437     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23438     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageSparseMemoryRequirementsInfo223439     pub fn build(self) -> ImageSparseMemoryRequirementsInfo2 {
23440         self.inner
23441     }
23442 }
23443 #[repr(C)]
23444 #[cfg_attr(feature = "debug", derive(Debug))]
23445 #[derive(Copy, Clone)]
23446 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceImageMemoryRequirements.html>"]
23447 pub struct DeviceImageMemoryRequirements {
23448     pub s_type: StructureType,
23449     pub p_next: *const c_void,
23450     pub p_create_info: *const ImageCreateInfo,
23451     pub plane_aspect: ImageAspectFlags,
23452 }
23453 impl ::std::default::Default for DeviceImageMemoryRequirements {
23454     #[inline]
default() -> Self23455     fn default() -> Self {
23456         Self {
23457             s_type: Self::STRUCTURE_TYPE,
23458             p_next: ::std::ptr::null(),
23459             p_create_info: ::std::ptr::null(),
23460             plane_aspect: ImageAspectFlags::default(),
23461         }
23462     }
23463 }
23464 unsafe impl TaggedStructure for DeviceImageMemoryRequirements {
23465     const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_IMAGE_MEMORY_REQUIREMENTS;
23466 }
23467 impl DeviceImageMemoryRequirements {
builder<'a>() -> DeviceImageMemoryRequirementsBuilder<'a>23468     pub fn builder<'a>() -> DeviceImageMemoryRequirementsBuilder<'a> {
23469         DeviceImageMemoryRequirementsBuilder {
23470             inner: Self::default(),
23471             marker: ::std::marker::PhantomData,
23472         }
23473     }
23474 }
23475 #[repr(transparent)]
23476 pub struct DeviceImageMemoryRequirementsBuilder<'a> {
23477     inner: DeviceImageMemoryRequirements,
23478     marker: ::std::marker::PhantomData<&'a ()>,
23479 }
23480 impl<'a> ::std::ops::Deref for DeviceImageMemoryRequirementsBuilder<'a> {
23481     type Target = DeviceImageMemoryRequirements;
deref(&self) -> &Self::Target23482     fn deref(&self) -> &Self::Target {
23483         &self.inner
23484     }
23485 }
23486 impl<'a> ::std::ops::DerefMut for DeviceImageMemoryRequirementsBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target23487     fn deref_mut(&mut self) -> &mut Self::Target {
23488         &mut self.inner
23489     }
23490 }
23491 impl<'a> DeviceImageMemoryRequirementsBuilder<'a> {
23492     #[inline]
create_info(mut self, create_info: &'a ImageCreateInfo) -> Self23493     pub fn create_info(mut self, create_info: &'a ImageCreateInfo) -> Self {
23494         self.inner.p_create_info = create_info;
23495         self
23496     }
23497     #[inline]
plane_aspect(mut self, plane_aspect: ImageAspectFlags) -> Self23498     pub fn plane_aspect(mut self, plane_aspect: ImageAspectFlags) -> Self {
23499         self.inner.plane_aspect = plane_aspect;
23500         self
23501     }
23502     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23503     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23504     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceImageMemoryRequirements23505     pub fn build(self) -> DeviceImageMemoryRequirements {
23506         self.inner
23507     }
23508 }
23509 #[repr(C)]
23510 #[cfg_attr(feature = "debug", derive(Debug))]
23511 #[derive(Copy, Clone)]
23512 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryRequirements2.html>"]
23513 pub struct MemoryRequirements2 {
23514     pub s_type: StructureType,
23515     pub p_next: *mut c_void,
23516     pub memory_requirements: MemoryRequirements,
23517 }
23518 impl ::std::default::Default for MemoryRequirements2 {
23519     #[inline]
default() -> Self23520     fn default() -> Self {
23521         Self {
23522             s_type: Self::STRUCTURE_TYPE,
23523             p_next: ::std::ptr::null_mut(),
23524             memory_requirements: MemoryRequirements::default(),
23525         }
23526     }
23527 }
23528 unsafe impl TaggedStructure for MemoryRequirements2 {
23529     const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_REQUIREMENTS_2;
23530 }
23531 impl MemoryRequirements2 {
builder<'a>() -> MemoryRequirements2Builder<'a>23532     pub fn builder<'a>() -> MemoryRequirements2Builder<'a> {
23533         MemoryRequirements2Builder {
23534             inner: Self::default(),
23535             marker: ::std::marker::PhantomData,
23536         }
23537     }
23538 }
23539 #[repr(transparent)]
23540 pub struct MemoryRequirements2Builder<'a> {
23541     inner: MemoryRequirements2,
23542     marker: ::std::marker::PhantomData<&'a ()>,
23543 }
23544 pub unsafe trait ExtendsMemoryRequirements2 {}
23545 impl<'a> ::std::ops::Deref for MemoryRequirements2Builder<'a> {
23546     type Target = MemoryRequirements2;
deref(&self) -> &Self::Target23547     fn deref(&self) -> &Self::Target {
23548         &self.inner
23549     }
23550 }
23551 impl<'a> ::std::ops::DerefMut for MemoryRequirements2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target23552     fn deref_mut(&mut self) -> &mut Self::Target {
23553         &mut self.inner
23554     }
23555 }
23556 impl<'a> MemoryRequirements2Builder<'a> {
23557     #[inline]
memory_requirements(mut self, memory_requirements: MemoryRequirements) -> Self23558     pub fn memory_requirements(mut self, memory_requirements: MemoryRequirements) -> Self {
23559         self.inner.memory_requirements = memory_requirements;
23560         self
23561     }
23562     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
23563     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
23564     #[doc = r" valid extension structs can be pushed into the chain."]
23565     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
23566     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsMemoryRequirements2>(mut self, next: &'a mut T) -> Self23567     pub fn push_next<T: ExtendsMemoryRequirements2>(mut self, next: &'a mut T) -> Self {
23568         unsafe {
23569             let next_ptr = <*mut T>::cast(next);
23570             let last_next = ptr_chain_iter(next).last().unwrap();
23571             (*last_next).p_next = self.inner.p_next as _;
23572             self.inner.p_next = next_ptr;
23573         }
23574         self
23575     }
23576     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23577     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23578     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryRequirements223579     pub fn build(self) -> MemoryRequirements2 {
23580         self.inner
23581     }
23582 }
23583 #[repr(C)]
23584 #[cfg_attr(feature = "debug", derive(Debug))]
23585 #[derive(Copy, Clone)]
23586 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageMemoryRequirements2.html>"]
23587 pub struct SparseImageMemoryRequirements2 {
23588     pub s_type: StructureType,
23589     pub p_next: *mut c_void,
23590     pub memory_requirements: SparseImageMemoryRequirements,
23591 }
23592 impl ::std::default::Default for SparseImageMemoryRequirements2 {
23593     #[inline]
default() -> Self23594     fn default() -> Self {
23595         Self {
23596             s_type: Self::STRUCTURE_TYPE,
23597             p_next: ::std::ptr::null_mut(),
23598             memory_requirements: SparseImageMemoryRequirements::default(),
23599         }
23600     }
23601 }
23602 unsafe impl TaggedStructure for SparseImageMemoryRequirements2 {
23603     const STRUCTURE_TYPE: StructureType = StructureType::SPARSE_IMAGE_MEMORY_REQUIREMENTS_2;
23604 }
23605 impl SparseImageMemoryRequirements2 {
builder<'a>() -> SparseImageMemoryRequirements2Builder<'a>23606     pub fn builder<'a>() -> SparseImageMemoryRequirements2Builder<'a> {
23607         SparseImageMemoryRequirements2Builder {
23608             inner: Self::default(),
23609             marker: ::std::marker::PhantomData,
23610         }
23611     }
23612 }
23613 #[repr(transparent)]
23614 pub struct SparseImageMemoryRequirements2Builder<'a> {
23615     inner: SparseImageMemoryRequirements2,
23616     marker: ::std::marker::PhantomData<&'a ()>,
23617 }
23618 impl<'a> ::std::ops::Deref for SparseImageMemoryRequirements2Builder<'a> {
23619     type Target = SparseImageMemoryRequirements2;
deref(&self) -> &Self::Target23620     fn deref(&self) -> &Self::Target {
23621         &self.inner
23622     }
23623 }
23624 impl<'a> ::std::ops::DerefMut for SparseImageMemoryRequirements2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target23625     fn deref_mut(&mut self) -> &mut Self::Target {
23626         &mut self.inner
23627     }
23628 }
23629 impl<'a> SparseImageMemoryRequirements2Builder<'a> {
23630     #[inline]
memory_requirements( mut self, memory_requirements: SparseImageMemoryRequirements, ) -> Self23631     pub fn memory_requirements(
23632         mut self,
23633         memory_requirements: SparseImageMemoryRequirements,
23634     ) -> Self {
23635         self.inner.memory_requirements = memory_requirements;
23636         self
23637     }
23638     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23639     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23640     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SparseImageMemoryRequirements223641     pub fn build(self) -> SparseImageMemoryRequirements2 {
23642         self.inner
23643     }
23644 }
23645 #[repr(C)]
23646 #[cfg_attr(feature = "debug", derive(Debug))]
23647 #[derive(Copy, Clone)]
23648 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePointClippingProperties.html>"]
23649 pub struct PhysicalDevicePointClippingProperties {
23650     pub s_type: StructureType,
23651     pub p_next: *mut c_void,
23652     pub point_clipping_behavior: PointClippingBehavior,
23653 }
23654 impl ::std::default::Default for PhysicalDevicePointClippingProperties {
23655     #[inline]
default() -> Self23656     fn default() -> Self {
23657         Self {
23658             s_type: Self::STRUCTURE_TYPE,
23659             p_next: ::std::ptr::null_mut(),
23660             point_clipping_behavior: PointClippingBehavior::default(),
23661         }
23662     }
23663 }
23664 unsafe impl TaggedStructure for PhysicalDevicePointClippingProperties {
23665     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
23666 }
23667 impl PhysicalDevicePointClippingProperties {
builder<'a>() -> PhysicalDevicePointClippingPropertiesBuilder<'a>23668     pub fn builder<'a>() -> PhysicalDevicePointClippingPropertiesBuilder<'a> {
23669         PhysicalDevicePointClippingPropertiesBuilder {
23670             inner: Self::default(),
23671             marker: ::std::marker::PhantomData,
23672         }
23673     }
23674 }
23675 #[repr(transparent)]
23676 pub struct PhysicalDevicePointClippingPropertiesBuilder<'a> {
23677     inner: PhysicalDevicePointClippingProperties,
23678     marker: ::std::marker::PhantomData<&'a ()>,
23679 }
23680 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePointClippingPropertiesBuilder<'_> {}
23681 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePointClippingProperties {}
23682 impl<'a> ::std::ops::Deref for PhysicalDevicePointClippingPropertiesBuilder<'a> {
23683     type Target = PhysicalDevicePointClippingProperties;
deref(&self) -> &Self::Target23684     fn deref(&self) -> &Self::Target {
23685         &self.inner
23686     }
23687 }
23688 impl<'a> ::std::ops::DerefMut for PhysicalDevicePointClippingPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target23689     fn deref_mut(&mut self) -> &mut Self::Target {
23690         &mut self.inner
23691     }
23692 }
23693 impl<'a> PhysicalDevicePointClippingPropertiesBuilder<'a> {
23694     #[inline]
point_clipping_behavior( mut self, point_clipping_behavior: PointClippingBehavior, ) -> Self23695     pub fn point_clipping_behavior(
23696         mut self,
23697         point_clipping_behavior: PointClippingBehavior,
23698     ) -> Self {
23699         self.inner.point_clipping_behavior = point_clipping_behavior;
23700         self
23701     }
23702     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23703     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23704     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePointClippingProperties23705     pub fn build(self) -> PhysicalDevicePointClippingProperties {
23706         self.inner
23707     }
23708 }
23709 #[repr(C)]
23710 #[cfg_attr(feature = "debug", derive(Debug))]
23711 #[derive(Copy, Clone)]
23712 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryDedicatedRequirements.html>"]
23713 pub struct MemoryDedicatedRequirements {
23714     pub s_type: StructureType,
23715     pub p_next: *mut c_void,
23716     pub prefers_dedicated_allocation: Bool32,
23717     pub requires_dedicated_allocation: Bool32,
23718 }
23719 impl ::std::default::Default for MemoryDedicatedRequirements {
23720     #[inline]
default() -> Self23721     fn default() -> Self {
23722         Self {
23723             s_type: Self::STRUCTURE_TYPE,
23724             p_next: ::std::ptr::null_mut(),
23725             prefers_dedicated_allocation: Bool32::default(),
23726             requires_dedicated_allocation: Bool32::default(),
23727         }
23728     }
23729 }
23730 unsafe impl TaggedStructure for MemoryDedicatedRequirements {
23731     const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_DEDICATED_REQUIREMENTS;
23732 }
23733 impl MemoryDedicatedRequirements {
builder<'a>() -> MemoryDedicatedRequirementsBuilder<'a>23734     pub fn builder<'a>() -> MemoryDedicatedRequirementsBuilder<'a> {
23735         MemoryDedicatedRequirementsBuilder {
23736             inner: Self::default(),
23737             marker: ::std::marker::PhantomData,
23738         }
23739     }
23740 }
23741 #[repr(transparent)]
23742 pub struct MemoryDedicatedRequirementsBuilder<'a> {
23743     inner: MemoryDedicatedRequirements,
23744     marker: ::std::marker::PhantomData<&'a ()>,
23745 }
23746 unsafe impl ExtendsMemoryRequirements2 for MemoryDedicatedRequirementsBuilder<'_> {}
23747 unsafe impl ExtendsMemoryRequirements2 for MemoryDedicatedRequirements {}
23748 impl<'a> ::std::ops::Deref for MemoryDedicatedRequirementsBuilder<'a> {
23749     type Target = MemoryDedicatedRequirements;
deref(&self) -> &Self::Target23750     fn deref(&self) -> &Self::Target {
23751         &self.inner
23752     }
23753 }
23754 impl<'a> ::std::ops::DerefMut for MemoryDedicatedRequirementsBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target23755     fn deref_mut(&mut self) -> &mut Self::Target {
23756         &mut self.inner
23757     }
23758 }
23759 impl<'a> MemoryDedicatedRequirementsBuilder<'a> {
23760     #[inline]
prefers_dedicated_allocation(mut self, prefers_dedicated_allocation: bool) -> Self23761     pub fn prefers_dedicated_allocation(mut self, prefers_dedicated_allocation: bool) -> Self {
23762         self.inner.prefers_dedicated_allocation = prefers_dedicated_allocation.into();
23763         self
23764     }
23765     #[inline]
requires_dedicated_allocation(mut self, requires_dedicated_allocation: bool) -> Self23766     pub fn requires_dedicated_allocation(mut self, requires_dedicated_allocation: bool) -> Self {
23767         self.inner.requires_dedicated_allocation = requires_dedicated_allocation.into();
23768         self
23769     }
23770     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23771     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23772     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryDedicatedRequirements23773     pub fn build(self) -> MemoryDedicatedRequirements {
23774         self.inner
23775     }
23776 }
23777 #[repr(C)]
23778 #[cfg_attr(feature = "debug", derive(Debug))]
23779 #[derive(Copy, Clone)]
23780 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryDedicatedAllocateInfo.html>"]
23781 pub struct MemoryDedicatedAllocateInfo {
23782     pub s_type: StructureType,
23783     pub p_next: *const c_void,
23784     pub image: Image,
23785     pub buffer: Buffer,
23786 }
23787 impl ::std::default::Default for MemoryDedicatedAllocateInfo {
23788     #[inline]
default() -> Self23789     fn default() -> Self {
23790         Self {
23791             s_type: Self::STRUCTURE_TYPE,
23792             p_next: ::std::ptr::null(),
23793             image: Image::default(),
23794             buffer: Buffer::default(),
23795         }
23796     }
23797 }
23798 unsafe impl TaggedStructure for MemoryDedicatedAllocateInfo {
23799     const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_DEDICATED_ALLOCATE_INFO;
23800 }
23801 impl MemoryDedicatedAllocateInfo {
builder<'a>() -> MemoryDedicatedAllocateInfoBuilder<'a>23802     pub fn builder<'a>() -> MemoryDedicatedAllocateInfoBuilder<'a> {
23803         MemoryDedicatedAllocateInfoBuilder {
23804             inner: Self::default(),
23805             marker: ::std::marker::PhantomData,
23806         }
23807     }
23808 }
23809 #[repr(transparent)]
23810 pub struct MemoryDedicatedAllocateInfoBuilder<'a> {
23811     inner: MemoryDedicatedAllocateInfo,
23812     marker: ::std::marker::PhantomData<&'a ()>,
23813 }
23814 unsafe impl ExtendsMemoryAllocateInfo for MemoryDedicatedAllocateInfoBuilder<'_> {}
23815 unsafe impl ExtendsMemoryAllocateInfo for MemoryDedicatedAllocateInfo {}
23816 impl<'a> ::std::ops::Deref for MemoryDedicatedAllocateInfoBuilder<'a> {
23817     type Target = MemoryDedicatedAllocateInfo;
deref(&self) -> &Self::Target23818     fn deref(&self) -> &Self::Target {
23819         &self.inner
23820     }
23821 }
23822 impl<'a> ::std::ops::DerefMut for MemoryDedicatedAllocateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target23823     fn deref_mut(&mut self) -> &mut Self::Target {
23824         &mut self.inner
23825     }
23826 }
23827 impl<'a> MemoryDedicatedAllocateInfoBuilder<'a> {
23828     #[inline]
image(mut self, image: Image) -> Self23829     pub fn image(mut self, image: Image) -> Self {
23830         self.inner.image = image;
23831         self
23832     }
23833     #[inline]
buffer(mut self, buffer: Buffer) -> Self23834     pub fn buffer(mut self, buffer: Buffer) -> Self {
23835         self.inner.buffer = buffer;
23836         self
23837     }
23838     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23839     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23840     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryDedicatedAllocateInfo23841     pub fn build(self) -> MemoryDedicatedAllocateInfo {
23842         self.inner
23843     }
23844 }
23845 #[repr(C)]
23846 #[cfg_attr(feature = "debug", derive(Debug))]
23847 #[derive(Copy, Clone)]
23848 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewUsageCreateInfo.html>"]
23849 pub struct ImageViewUsageCreateInfo {
23850     pub s_type: StructureType,
23851     pub p_next: *const c_void,
23852     pub usage: ImageUsageFlags,
23853 }
23854 impl ::std::default::Default for ImageViewUsageCreateInfo {
23855     #[inline]
default() -> Self23856     fn default() -> Self {
23857         Self {
23858             s_type: Self::STRUCTURE_TYPE,
23859             p_next: ::std::ptr::null(),
23860             usage: ImageUsageFlags::default(),
23861         }
23862     }
23863 }
23864 unsafe impl TaggedStructure for ImageViewUsageCreateInfo {
23865     const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_USAGE_CREATE_INFO;
23866 }
23867 impl ImageViewUsageCreateInfo {
builder<'a>() -> ImageViewUsageCreateInfoBuilder<'a>23868     pub fn builder<'a>() -> ImageViewUsageCreateInfoBuilder<'a> {
23869         ImageViewUsageCreateInfoBuilder {
23870             inner: Self::default(),
23871             marker: ::std::marker::PhantomData,
23872         }
23873     }
23874 }
23875 #[repr(transparent)]
23876 pub struct ImageViewUsageCreateInfoBuilder<'a> {
23877     inner: ImageViewUsageCreateInfo,
23878     marker: ::std::marker::PhantomData<&'a ()>,
23879 }
23880 unsafe impl ExtendsImageViewCreateInfo for ImageViewUsageCreateInfoBuilder<'_> {}
23881 unsafe impl ExtendsImageViewCreateInfo for ImageViewUsageCreateInfo {}
23882 impl<'a> ::std::ops::Deref for ImageViewUsageCreateInfoBuilder<'a> {
23883     type Target = ImageViewUsageCreateInfo;
deref(&self) -> &Self::Target23884     fn deref(&self) -> &Self::Target {
23885         &self.inner
23886     }
23887 }
23888 impl<'a> ::std::ops::DerefMut for ImageViewUsageCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target23889     fn deref_mut(&mut self) -> &mut Self::Target {
23890         &mut self.inner
23891     }
23892 }
23893 impl<'a> ImageViewUsageCreateInfoBuilder<'a> {
23894     #[inline]
usage(mut self, usage: ImageUsageFlags) -> Self23895     pub fn usage(mut self, usage: ImageUsageFlags) -> Self {
23896         self.inner.usage = usage;
23897         self
23898     }
23899     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23900     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23901     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageViewUsageCreateInfo23902     pub fn build(self) -> ImageViewUsageCreateInfo {
23903         self.inner
23904     }
23905 }
23906 #[repr(C)]
23907 #[cfg_attr(feature = "debug", derive(Debug))]
23908 #[derive(Copy, Clone)]
23909 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewSlicedCreateInfoEXT.html>"]
23910 pub struct ImageViewSlicedCreateInfoEXT {
23911     pub s_type: StructureType,
23912     pub p_next: *const c_void,
23913     pub slice_offset: u32,
23914     pub slice_count: u32,
23915 }
23916 impl ::std::default::Default for ImageViewSlicedCreateInfoEXT {
23917     #[inline]
default() -> Self23918     fn default() -> Self {
23919         Self {
23920             s_type: Self::STRUCTURE_TYPE,
23921             p_next: ::std::ptr::null(),
23922             slice_offset: u32::default(),
23923             slice_count: u32::default(),
23924         }
23925     }
23926 }
23927 unsafe impl TaggedStructure for ImageViewSlicedCreateInfoEXT {
23928     const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_SLICED_CREATE_INFO_EXT;
23929 }
23930 impl ImageViewSlicedCreateInfoEXT {
builder<'a>() -> ImageViewSlicedCreateInfoEXTBuilder<'a>23931     pub fn builder<'a>() -> ImageViewSlicedCreateInfoEXTBuilder<'a> {
23932         ImageViewSlicedCreateInfoEXTBuilder {
23933             inner: Self::default(),
23934             marker: ::std::marker::PhantomData,
23935         }
23936     }
23937 }
23938 #[repr(transparent)]
23939 pub struct ImageViewSlicedCreateInfoEXTBuilder<'a> {
23940     inner: ImageViewSlicedCreateInfoEXT,
23941     marker: ::std::marker::PhantomData<&'a ()>,
23942 }
23943 unsafe impl ExtendsImageViewCreateInfo for ImageViewSlicedCreateInfoEXTBuilder<'_> {}
23944 unsafe impl ExtendsImageViewCreateInfo for ImageViewSlicedCreateInfoEXT {}
23945 impl<'a> ::std::ops::Deref for ImageViewSlicedCreateInfoEXTBuilder<'a> {
23946     type Target = ImageViewSlicedCreateInfoEXT;
deref(&self) -> &Self::Target23947     fn deref(&self) -> &Self::Target {
23948         &self.inner
23949     }
23950 }
23951 impl<'a> ::std::ops::DerefMut for ImageViewSlicedCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target23952     fn deref_mut(&mut self) -> &mut Self::Target {
23953         &mut self.inner
23954     }
23955 }
23956 impl<'a> ImageViewSlicedCreateInfoEXTBuilder<'a> {
23957     #[inline]
slice_offset(mut self, slice_offset: u32) -> Self23958     pub fn slice_offset(mut self, slice_offset: u32) -> Self {
23959         self.inner.slice_offset = slice_offset;
23960         self
23961     }
23962     #[inline]
slice_count(mut self, slice_count: u32) -> Self23963     pub fn slice_count(mut self, slice_count: u32) -> Self {
23964         self.inner.slice_count = slice_count;
23965         self
23966     }
23967     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23968     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23969     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageViewSlicedCreateInfoEXT23970     pub fn build(self) -> ImageViewSlicedCreateInfoEXT {
23971         self.inner
23972     }
23973 }
23974 #[repr(C)]
23975 #[cfg_attr(feature = "debug", derive(Debug))]
23976 #[derive(Copy, Clone)]
23977 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineTessellationDomainOriginStateCreateInfo.html>"]
23978 pub struct PipelineTessellationDomainOriginStateCreateInfo {
23979     pub s_type: StructureType,
23980     pub p_next: *const c_void,
23981     pub domain_origin: TessellationDomainOrigin,
23982 }
23983 impl ::std::default::Default for PipelineTessellationDomainOriginStateCreateInfo {
23984     #[inline]
default() -> Self23985     fn default() -> Self {
23986         Self {
23987             s_type: Self::STRUCTURE_TYPE,
23988             p_next: ::std::ptr::null(),
23989             domain_origin: TessellationDomainOrigin::default(),
23990         }
23991     }
23992 }
23993 unsafe impl TaggedStructure for PipelineTessellationDomainOriginStateCreateInfo {
23994     const STRUCTURE_TYPE: StructureType =
23995         StructureType::PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO;
23996 }
23997 impl PipelineTessellationDomainOriginStateCreateInfo {
builder<'a>() -> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a>23998     pub fn builder<'a>() -> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
23999         PipelineTessellationDomainOriginStateCreateInfoBuilder {
24000             inner: Self::default(),
24001             marker: ::std::marker::PhantomData,
24002         }
24003     }
24004 }
24005 #[repr(transparent)]
24006 pub struct PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
24007     inner: PipelineTessellationDomainOriginStateCreateInfo,
24008     marker: ::std::marker::PhantomData<&'a ()>,
24009 }
24010 unsafe impl ExtendsPipelineTessellationStateCreateInfo
24011     for PipelineTessellationDomainOriginStateCreateInfoBuilder<'_>
24012 {
24013 }
24014 unsafe impl ExtendsPipelineTessellationStateCreateInfo
24015     for PipelineTessellationDomainOriginStateCreateInfo
24016 {
24017 }
24018 impl<'a> ::std::ops::Deref for PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
24019     type Target = PipelineTessellationDomainOriginStateCreateInfo;
deref(&self) -> &Self::Target24020     fn deref(&self) -> &Self::Target {
24021         &self.inner
24022     }
24023 }
24024 impl<'a> ::std::ops::DerefMut for PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target24025     fn deref_mut(&mut self) -> &mut Self::Target {
24026         &mut self.inner
24027     }
24028 }
24029 impl<'a> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
24030     #[inline]
domain_origin(mut self, domain_origin: TessellationDomainOrigin) -> Self24031     pub fn domain_origin(mut self, domain_origin: TessellationDomainOrigin) -> Self {
24032         self.inner.domain_origin = domain_origin;
24033         self
24034     }
24035     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24036     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24037     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineTessellationDomainOriginStateCreateInfo24038     pub fn build(self) -> PipelineTessellationDomainOriginStateCreateInfo {
24039         self.inner
24040     }
24041 }
24042 #[repr(C)]
24043 #[cfg_attr(feature = "debug", derive(Debug))]
24044 #[derive(Copy, Clone)]
24045 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerYcbcrConversionInfo.html>"]
24046 pub struct SamplerYcbcrConversionInfo {
24047     pub s_type: StructureType,
24048     pub p_next: *const c_void,
24049     pub conversion: SamplerYcbcrConversion,
24050 }
24051 impl ::std::default::Default for SamplerYcbcrConversionInfo {
24052     #[inline]
default() -> Self24053     fn default() -> Self {
24054         Self {
24055             s_type: Self::STRUCTURE_TYPE,
24056             p_next: ::std::ptr::null(),
24057             conversion: SamplerYcbcrConversion::default(),
24058         }
24059     }
24060 }
24061 unsafe impl TaggedStructure for SamplerYcbcrConversionInfo {
24062     const STRUCTURE_TYPE: StructureType = StructureType::SAMPLER_YCBCR_CONVERSION_INFO;
24063 }
24064 impl SamplerYcbcrConversionInfo {
builder<'a>() -> SamplerYcbcrConversionInfoBuilder<'a>24065     pub fn builder<'a>() -> SamplerYcbcrConversionInfoBuilder<'a> {
24066         SamplerYcbcrConversionInfoBuilder {
24067             inner: Self::default(),
24068             marker: ::std::marker::PhantomData,
24069         }
24070     }
24071 }
24072 #[repr(transparent)]
24073 pub struct SamplerYcbcrConversionInfoBuilder<'a> {
24074     inner: SamplerYcbcrConversionInfo,
24075     marker: ::std::marker::PhantomData<&'a ()>,
24076 }
24077 unsafe impl ExtendsSamplerCreateInfo for SamplerYcbcrConversionInfoBuilder<'_> {}
24078 unsafe impl ExtendsSamplerCreateInfo for SamplerYcbcrConversionInfo {}
24079 unsafe impl ExtendsImageViewCreateInfo for SamplerYcbcrConversionInfoBuilder<'_> {}
24080 unsafe impl ExtendsImageViewCreateInfo for SamplerYcbcrConversionInfo {}
24081 impl<'a> ::std::ops::Deref for SamplerYcbcrConversionInfoBuilder<'a> {
24082     type Target = SamplerYcbcrConversionInfo;
deref(&self) -> &Self::Target24083     fn deref(&self) -> &Self::Target {
24084         &self.inner
24085     }
24086 }
24087 impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target24088     fn deref_mut(&mut self) -> &mut Self::Target {
24089         &mut self.inner
24090     }
24091 }
24092 impl<'a> SamplerYcbcrConversionInfoBuilder<'a> {
24093     #[inline]
conversion(mut self, conversion: SamplerYcbcrConversion) -> Self24094     pub fn conversion(mut self, conversion: SamplerYcbcrConversion) -> Self {
24095         self.inner.conversion = conversion;
24096         self
24097     }
24098     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24099     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24100     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SamplerYcbcrConversionInfo24101     pub fn build(self) -> SamplerYcbcrConversionInfo {
24102         self.inner
24103     }
24104 }
24105 #[repr(C)]
24106 #[cfg_attr(feature = "debug", derive(Debug))]
24107 #[derive(Copy, Clone)]
24108 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerYcbcrConversionCreateInfo.html>"]
24109 pub struct SamplerYcbcrConversionCreateInfo {
24110     pub s_type: StructureType,
24111     pub p_next: *const c_void,
24112     pub format: Format,
24113     pub ycbcr_model: SamplerYcbcrModelConversion,
24114     pub ycbcr_range: SamplerYcbcrRange,
24115     pub components: ComponentMapping,
24116     pub x_chroma_offset: ChromaLocation,
24117     pub y_chroma_offset: ChromaLocation,
24118     pub chroma_filter: Filter,
24119     pub force_explicit_reconstruction: Bool32,
24120 }
24121 impl ::std::default::Default for SamplerYcbcrConversionCreateInfo {
24122     #[inline]
default() -> Self24123     fn default() -> Self {
24124         Self {
24125             s_type: Self::STRUCTURE_TYPE,
24126             p_next: ::std::ptr::null(),
24127             format: Format::default(),
24128             ycbcr_model: SamplerYcbcrModelConversion::default(),
24129             ycbcr_range: SamplerYcbcrRange::default(),
24130             components: ComponentMapping::default(),
24131             x_chroma_offset: ChromaLocation::default(),
24132             y_chroma_offset: ChromaLocation::default(),
24133             chroma_filter: Filter::default(),
24134             force_explicit_reconstruction: Bool32::default(),
24135         }
24136     }
24137 }
24138 unsafe impl TaggedStructure for SamplerYcbcrConversionCreateInfo {
24139     const STRUCTURE_TYPE: StructureType = StructureType::SAMPLER_YCBCR_CONVERSION_CREATE_INFO;
24140 }
24141 impl SamplerYcbcrConversionCreateInfo {
builder<'a>() -> SamplerYcbcrConversionCreateInfoBuilder<'a>24142     pub fn builder<'a>() -> SamplerYcbcrConversionCreateInfoBuilder<'a> {
24143         SamplerYcbcrConversionCreateInfoBuilder {
24144             inner: Self::default(),
24145             marker: ::std::marker::PhantomData,
24146         }
24147     }
24148 }
24149 #[repr(transparent)]
24150 pub struct SamplerYcbcrConversionCreateInfoBuilder<'a> {
24151     inner: SamplerYcbcrConversionCreateInfo,
24152     marker: ::std::marker::PhantomData<&'a ()>,
24153 }
24154 pub unsafe trait ExtendsSamplerYcbcrConversionCreateInfo {}
24155 impl<'a> ::std::ops::Deref for SamplerYcbcrConversionCreateInfoBuilder<'a> {
24156     type Target = SamplerYcbcrConversionCreateInfo;
deref(&self) -> &Self::Target24157     fn deref(&self) -> &Self::Target {
24158         &self.inner
24159     }
24160 }
24161 impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target24162     fn deref_mut(&mut self) -> &mut Self::Target {
24163         &mut self.inner
24164     }
24165 }
24166 impl<'a> SamplerYcbcrConversionCreateInfoBuilder<'a> {
24167     #[inline]
format(mut self, format: Format) -> Self24168     pub fn format(mut self, format: Format) -> Self {
24169         self.inner.format = format;
24170         self
24171     }
24172     #[inline]
ycbcr_model(mut self, ycbcr_model: SamplerYcbcrModelConversion) -> Self24173     pub fn ycbcr_model(mut self, ycbcr_model: SamplerYcbcrModelConversion) -> Self {
24174         self.inner.ycbcr_model = ycbcr_model;
24175         self
24176     }
24177     #[inline]
ycbcr_range(mut self, ycbcr_range: SamplerYcbcrRange) -> Self24178     pub fn ycbcr_range(mut self, ycbcr_range: SamplerYcbcrRange) -> Self {
24179         self.inner.ycbcr_range = ycbcr_range;
24180         self
24181     }
24182     #[inline]
components(mut self, components: ComponentMapping) -> Self24183     pub fn components(mut self, components: ComponentMapping) -> Self {
24184         self.inner.components = components;
24185         self
24186     }
24187     #[inline]
x_chroma_offset(mut self, x_chroma_offset: ChromaLocation) -> Self24188     pub fn x_chroma_offset(mut self, x_chroma_offset: ChromaLocation) -> Self {
24189         self.inner.x_chroma_offset = x_chroma_offset;
24190         self
24191     }
24192     #[inline]
y_chroma_offset(mut self, y_chroma_offset: ChromaLocation) -> Self24193     pub fn y_chroma_offset(mut self, y_chroma_offset: ChromaLocation) -> Self {
24194         self.inner.y_chroma_offset = y_chroma_offset;
24195         self
24196     }
24197     #[inline]
chroma_filter(mut self, chroma_filter: Filter) -> Self24198     pub fn chroma_filter(mut self, chroma_filter: Filter) -> Self {
24199         self.inner.chroma_filter = chroma_filter;
24200         self
24201     }
24202     #[inline]
force_explicit_reconstruction(mut self, force_explicit_reconstruction: bool) -> Self24203     pub fn force_explicit_reconstruction(mut self, force_explicit_reconstruction: bool) -> Self {
24204         self.inner.force_explicit_reconstruction = force_explicit_reconstruction.into();
24205         self
24206     }
24207     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
24208     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
24209     #[doc = r" valid extension structs can be pushed into the chain."]
24210     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
24211     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSamplerYcbcrConversionCreateInfo>( mut self, next: &'a mut T, ) -> Self24212     pub fn push_next<T: ExtendsSamplerYcbcrConversionCreateInfo>(
24213         mut self,
24214         next: &'a mut T,
24215     ) -> Self {
24216         unsafe {
24217             let next_ptr = <*const T>::cast(next);
24218             let last_next = ptr_chain_iter(next).last().unwrap();
24219             (*last_next).p_next = self.inner.p_next as _;
24220             self.inner.p_next = next_ptr;
24221         }
24222         self
24223     }
24224     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24225     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24226     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SamplerYcbcrConversionCreateInfo24227     pub fn build(self) -> SamplerYcbcrConversionCreateInfo {
24228         self.inner
24229     }
24230 }
24231 #[repr(C)]
24232 #[cfg_attr(feature = "debug", derive(Debug))]
24233 #[derive(Copy, Clone)]
24234 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindImagePlaneMemoryInfo.html>"]
24235 pub struct BindImagePlaneMemoryInfo {
24236     pub s_type: StructureType,
24237     pub p_next: *const c_void,
24238     pub plane_aspect: ImageAspectFlags,
24239 }
24240 impl ::std::default::Default for BindImagePlaneMemoryInfo {
24241     #[inline]
default() -> Self24242     fn default() -> Self {
24243         Self {
24244             s_type: Self::STRUCTURE_TYPE,
24245             p_next: ::std::ptr::null(),
24246             plane_aspect: ImageAspectFlags::default(),
24247         }
24248     }
24249 }
24250 unsafe impl TaggedStructure for BindImagePlaneMemoryInfo {
24251     const STRUCTURE_TYPE: StructureType = StructureType::BIND_IMAGE_PLANE_MEMORY_INFO;
24252 }
24253 impl BindImagePlaneMemoryInfo {
builder<'a>() -> BindImagePlaneMemoryInfoBuilder<'a>24254     pub fn builder<'a>() -> BindImagePlaneMemoryInfoBuilder<'a> {
24255         BindImagePlaneMemoryInfoBuilder {
24256             inner: Self::default(),
24257             marker: ::std::marker::PhantomData,
24258         }
24259     }
24260 }
24261 #[repr(transparent)]
24262 pub struct BindImagePlaneMemoryInfoBuilder<'a> {
24263     inner: BindImagePlaneMemoryInfo,
24264     marker: ::std::marker::PhantomData<&'a ()>,
24265 }
24266 unsafe impl ExtendsBindImageMemoryInfo for BindImagePlaneMemoryInfoBuilder<'_> {}
24267 unsafe impl ExtendsBindImageMemoryInfo for BindImagePlaneMemoryInfo {}
24268 impl<'a> ::std::ops::Deref for BindImagePlaneMemoryInfoBuilder<'a> {
24269     type Target = BindImagePlaneMemoryInfo;
deref(&self) -> &Self::Target24270     fn deref(&self) -> &Self::Target {
24271         &self.inner
24272     }
24273 }
24274 impl<'a> ::std::ops::DerefMut for BindImagePlaneMemoryInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target24275     fn deref_mut(&mut self) -> &mut Self::Target {
24276         &mut self.inner
24277     }
24278 }
24279 impl<'a> BindImagePlaneMemoryInfoBuilder<'a> {
24280     #[inline]
plane_aspect(mut self, plane_aspect: ImageAspectFlags) -> Self24281     pub fn plane_aspect(mut self, plane_aspect: ImageAspectFlags) -> Self {
24282         self.inner.plane_aspect = plane_aspect;
24283         self
24284     }
24285     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24286     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24287     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BindImagePlaneMemoryInfo24288     pub fn build(self) -> BindImagePlaneMemoryInfo {
24289         self.inner
24290     }
24291 }
24292 #[repr(C)]
24293 #[cfg_attr(feature = "debug", derive(Debug))]
24294 #[derive(Copy, Clone)]
24295 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImagePlaneMemoryRequirementsInfo.html>"]
24296 pub struct ImagePlaneMemoryRequirementsInfo {
24297     pub s_type: StructureType,
24298     pub p_next: *const c_void,
24299     pub plane_aspect: ImageAspectFlags,
24300 }
24301 impl ::std::default::Default for ImagePlaneMemoryRequirementsInfo {
24302     #[inline]
default() -> Self24303     fn default() -> Self {
24304         Self {
24305             s_type: Self::STRUCTURE_TYPE,
24306             p_next: ::std::ptr::null(),
24307             plane_aspect: ImageAspectFlags::default(),
24308         }
24309     }
24310 }
24311 unsafe impl TaggedStructure for ImagePlaneMemoryRequirementsInfo {
24312     const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO;
24313 }
24314 impl ImagePlaneMemoryRequirementsInfo {
builder<'a>() -> ImagePlaneMemoryRequirementsInfoBuilder<'a>24315     pub fn builder<'a>() -> ImagePlaneMemoryRequirementsInfoBuilder<'a> {
24316         ImagePlaneMemoryRequirementsInfoBuilder {
24317             inner: Self::default(),
24318             marker: ::std::marker::PhantomData,
24319         }
24320     }
24321 }
24322 #[repr(transparent)]
24323 pub struct ImagePlaneMemoryRequirementsInfoBuilder<'a> {
24324     inner: ImagePlaneMemoryRequirementsInfo,
24325     marker: ::std::marker::PhantomData<&'a ()>,
24326 }
24327 unsafe impl ExtendsImageMemoryRequirementsInfo2 for ImagePlaneMemoryRequirementsInfoBuilder<'_> {}
24328 unsafe impl ExtendsImageMemoryRequirementsInfo2 for ImagePlaneMemoryRequirementsInfo {}
24329 impl<'a> ::std::ops::Deref for ImagePlaneMemoryRequirementsInfoBuilder<'a> {
24330     type Target = ImagePlaneMemoryRequirementsInfo;
deref(&self) -> &Self::Target24331     fn deref(&self) -> &Self::Target {
24332         &self.inner
24333     }
24334 }
24335 impl<'a> ::std::ops::DerefMut for ImagePlaneMemoryRequirementsInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target24336     fn deref_mut(&mut self) -> &mut Self::Target {
24337         &mut self.inner
24338     }
24339 }
24340 impl<'a> ImagePlaneMemoryRequirementsInfoBuilder<'a> {
24341     #[inline]
plane_aspect(mut self, plane_aspect: ImageAspectFlags) -> Self24342     pub fn plane_aspect(mut self, plane_aspect: ImageAspectFlags) -> Self {
24343         self.inner.plane_aspect = plane_aspect;
24344         self
24345     }
24346     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24347     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24348     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImagePlaneMemoryRequirementsInfo24349     pub fn build(self) -> ImagePlaneMemoryRequirementsInfo {
24350         self.inner
24351     }
24352 }
24353 #[repr(C)]
24354 #[cfg_attr(feature = "debug", derive(Debug))]
24355 #[derive(Copy, Clone)]
24356 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSamplerYcbcrConversionFeatures.html>"]
24357 pub struct PhysicalDeviceSamplerYcbcrConversionFeatures {
24358     pub s_type: StructureType,
24359     pub p_next: *mut c_void,
24360     pub sampler_ycbcr_conversion: Bool32,
24361 }
24362 impl ::std::default::Default for PhysicalDeviceSamplerYcbcrConversionFeatures {
24363     #[inline]
default() -> Self24364     fn default() -> Self {
24365         Self {
24366             s_type: Self::STRUCTURE_TYPE,
24367             p_next: ::std::ptr::null_mut(),
24368             sampler_ycbcr_conversion: Bool32::default(),
24369         }
24370     }
24371 }
24372 unsafe impl TaggedStructure for PhysicalDeviceSamplerYcbcrConversionFeatures {
24373     const STRUCTURE_TYPE: StructureType =
24374         StructureType::PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
24375 }
24376 impl PhysicalDeviceSamplerYcbcrConversionFeatures {
builder<'a>() -> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a>24377     pub fn builder<'a>() -> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
24378         PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder {
24379             inner: Self::default(),
24380             marker: ::std::marker::PhantomData,
24381         }
24382     }
24383 }
24384 #[repr(transparent)]
24385 pub struct PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
24386     inner: PhysicalDeviceSamplerYcbcrConversionFeatures,
24387     marker: ::std::marker::PhantomData<&'a ()>,
24388 }
24389 unsafe impl ExtendsPhysicalDeviceFeatures2
24390     for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'_>
24391 {
24392 }
24393 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSamplerYcbcrConversionFeatures {}
24394 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'_> {}
24395 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSamplerYcbcrConversionFeatures {}
24396 impl<'a> ::std::ops::Deref for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
24397     type Target = PhysicalDeviceSamplerYcbcrConversionFeatures;
deref(&self) -> &Self::Target24398     fn deref(&self) -> &Self::Target {
24399         &self.inner
24400     }
24401 }
24402 impl<'a> ::std::ops::DerefMut for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target24403     fn deref_mut(&mut self) -> &mut Self::Target {
24404         &mut self.inner
24405     }
24406 }
24407 impl<'a> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
24408     #[inline]
sampler_ycbcr_conversion(mut self, sampler_ycbcr_conversion: bool) -> Self24409     pub fn sampler_ycbcr_conversion(mut self, sampler_ycbcr_conversion: bool) -> Self {
24410         self.inner.sampler_ycbcr_conversion = sampler_ycbcr_conversion.into();
24411         self
24412     }
24413     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24414     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24415     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceSamplerYcbcrConversionFeatures24416     pub fn build(self) -> PhysicalDeviceSamplerYcbcrConversionFeatures {
24417         self.inner
24418     }
24419 }
24420 #[repr(C)]
24421 #[cfg_attr(feature = "debug", derive(Debug))]
24422 #[derive(Copy, Clone)]
24423 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerYcbcrConversionImageFormatProperties.html>"]
24424 pub struct SamplerYcbcrConversionImageFormatProperties {
24425     pub s_type: StructureType,
24426     pub p_next: *mut c_void,
24427     pub combined_image_sampler_descriptor_count: u32,
24428 }
24429 impl ::std::default::Default for SamplerYcbcrConversionImageFormatProperties {
24430     #[inline]
default() -> Self24431     fn default() -> Self {
24432         Self {
24433             s_type: Self::STRUCTURE_TYPE,
24434             p_next: ::std::ptr::null_mut(),
24435             combined_image_sampler_descriptor_count: u32::default(),
24436         }
24437     }
24438 }
24439 unsafe impl TaggedStructure for SamplerYcbcrConversionImageFormatProperties {
24440     const STRUCTURE_TYPE: StructureType =
24441         StructureType::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
24442 }
24443 impl SamplerYcbcrConversionImageFormatProperties {
builder<'a>() -> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a>24444     pub fn builder<'a>() -> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
24445         SamplerYcbcrConversionImageFormatPropertiesBuilder {
24446             inner: Self::default(),
24447             marker: ::std::marker::PhantomData,
24448         }
24449     }
24450 }
24451 #[repr(transparent)]
24452 pub struct SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
24453     inner: SamplerYcbcrConversionImageFormatProperties,
24454     marker: ::std::marker::PhantomData<&'a ()>,
24455 }
24456 unsafe impl ExtendsImageFormatProperties2
24457     for SamplerYcbcrConversionImageFormatPropertiesBuilder<'_>
24458 {
24459 }
24460 unsafe impl ExtendsImageFormatProperties2 for SamplerYcbcrConversionImageFormatProperties {}
24461 impl<'a> ::std::ops::Deref for SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
24462     type Target = SamplerYcbcrConversionImageFormatProperties;
deref(&self) -> &Self::Target24463     fn deref(&self) -> &Self::Target {
24464         &self.inner
24465     }
24466 }
24467 impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target24468     fn deref_mut(&mut self) -> &mut Self::Target {
24469         &mut self.inner
24470     }
24471 }
24472 impl<'a> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
24473     #[inline]
combined_image_sampler_descriptor_count( mut self, combined_image_sampler_descriptor_count: u32, ) -> Self24474     pub fn combined_image_sampler_descriptor_count(
24475         mut self,
24476         combined_image_sampler_descriptor_count: u32,
24477     ) -> Self {
24478         self.inner.combined_image_sampler_descriptor_count =
24479             combined_image_sampler_descriptor_count;
24480         self
24481     }
24482     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24483     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24484     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SamplerYcbcrConversionImageFormatProperties24485     pub fn build(self) -> SamplerYcbcrConversionImageFormatProperties {
24486         self.inner
24487     }
24488 }
24489 #[repr(C)]
24490 #[cfg_attr(feature = "debug", derive(Debug))]
24491 #[derive(Copy, Clone)]
24492 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkTextureLODGatherFormatPropertiesAMD.html>"]
24493 pub struct TextureLODGatherFormatPropertiesAMD {
24494     pub s_type: StructureType,
24495     pub p_next: *mut c_void,
24496     pub supports_texture_gather_lod_bias_amd: Bool32,
24497 }
24498 impl ::std::default::Default for TextureLODGatherFormatPropertiesAMD {
24499     #[inline]
default() -> Self24500     fn default() -> Self {
24501         Self {
24502             s_type: Self::STRUCTURE_TYPE,
24503             p_next: ::std::ptr::null_mut(),
24504             supports_texture_gather_lod_bias_amd: Bool32::default(),
24505         }
24506     }
24507 }
24508 unsafe impl TaggedStructure for TextureLODGatherFormatPropertiesAMD {
24509     const STRUCTURE_TYPE: StructureType = StructureType::TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD;
24510 }
24511 impl TextureLODGatherFormatPropertiesAMD {
builder<'a>() -> TextureLODGatherFormatPropertiesAMDBuilder<'a>24512     pub fn builder<'a>() -> TextureLODGatherFormatPropertiesAMDBuilder<'a> {
24513         TextureLODGatherFormatPropertiesAMDBuilder {
24514             inner: Self::default(),
24515             marker: ::std::marker::PhantomData,
24516         }
24517     }
24518 }
24519 #[repr(transparent)]
24520 pub struct TextureLODGatherFormatPropertiesAMDBuilder<'a> {
24521     inner: TextureLODGatherFormatPropertiesAMD,
24522     marker: ::std::marker::PhantomData<&'a ()>,
24523 }
24524 unsafe impl ExtendsImageFormatProperties2 for TextureLODGatherFormatPropertiesAMDBuilder<'_> {}
24525 unsafe impl ExtendsImageFormatProperties2 for TextureLODGatherFormatPropertiesAMD {}
24526 impl<'a> ::std::ops::Deref for TextureLODGatherFormatPropertiesAMDBuilder<'a> {
24527     type Target = TextureLODGatherFormatPropertiesAMD;
deref(&self) -> &Self::Target24528     fn deref(&self) -> &Self::Target {
24529         &self.inner
24530     }
24531 }
24532 impl<'a> ::std::ops::DerefMut for TextureLODGatherFormatPropertiesAMDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target24533     fn deref_mut(&mut self) -> &mut Self::Target {
24534         &mut self.inner
24535     }
24536 }
24537 impl<'a> TextureLODGatherFormatPropertiesAMDBuilder<'a> {
24538     #[inline]
supports_texture_gather_lod_bias_amd( mut self, supports_texture_gather_lod_bias_amd: bool, ) -> Self24539     pub fn supports_texture_gather_lod_bias_amd(
24540         mut self,
24541         supports_texture_gather_lod_bias_amd: bool,
24542     ) -> Self {
24543         self.inner.supports_texture_gather_lod_bias_amd =
24544             supports_texture_gather_lod_bias_amd.into();
24545         self
24546     }
24547     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24548     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24549     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> TextureLODGatherFormatPropertiesAMD24550     pub fn build(self) -> TextureLODGatherFormatPropertiesAMD {
24551         self.inner
24552     }
24553 }
24554 #[repr(C)]
24555 #[cfg_attr(feature = "debug", derive(Debug))]
24556 #[derive(Copy, Clone)]
24557 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkConditionalRenderingBeginInfoEXT.html>"]
24558 pub struct ConditionalRenderingBeginInfoEXT {
24559     pub s_type: StructureType,
24560     pub p_next: *const c_void,
24561     pub buffer: Buffer,
24562     pub offset: DeviceSize,
24563     pub flags: ConditionalRenderingFlagsEXT,
24564 }
24565 impl ::std::default::Default for ConditionalRenderingBeginInfoEXT {
24566     #[inline]
default() -> Self24567     fn default() -> Self {
24568         Self {
24569             s_type: Self::STRUCTURE_TYPE,
24570             p_next: ::std::ptr::null(),
24571             buffer: Buffer::default(),
24572             offset: DeviceSize::default(),
24573             flags: ConditionalRenderingFlagsEXT::default(),
24574         }
24575     }
24576 }
24577 unsafe impl TaggedStructure for ConditionalRenderingBeginInfoEXT {
24578     const STRUCTURE_TYPE: StructureType = StructureType::CONDITIONAL_RENDERING_BEGIN_INFO_EXT;
24579 }
24580 impl ConditionalRenderingBeginInfoEXT {
builder<'a>() -> ConditionalRenderingBeginInfoEXTBuilder<'a>24581     pub fn builder<'a>() -> ConditionalRenderingBeginInfoEXTBuilder<'a> {
24582         ConditionalRenderingBeginInfoEXTBuilder {
24583             inner: Self::default(),
24584             marker: ::std::marker::PhantomData,
24585         }
24586     }
24587 }
24588 #[repr(transparent)]
24589 pub struct ConditionalRenderingBeginInfoEXTBuilder<'a> {
24590     inner: ConditionalRenderingBeginInfoEXT,
24591     marker: ::std::marker::PhantomData<&'a ()>,
24592 }
24593 impl<'a> ::std::ops::Deref for ConditionalRenderingBeginInfoEXTBuilder<'a> {
24594     type Target = ConditionalRenderingBeginInfoEXT;
deref(&self) -> &Self::Target24595     fn deref(&self) -> &Self::Target {
24596         &self.inner
24597     }
24598 }
24599 impl<'a> ::std::ops::DerefMut for ConditionalRenderingBeginInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target24600     fn deref_mut(&mut self) -> &mut Self::Target {
24601         &mut self.inner
24602     }
24603 }
24604 impl<'a> ConditionalRenderingBeginInfoEXTBuilder<'a> {
24605     #[inline]
buffer(mut self, buffer: Buffer) -> Self24606     pub fn buffer(mut self, buffer: Buffer) -> Self {
24607         self.inner.buffer = buffer;
24608         self
24609     }
24610     #[inline]
offset(mut self, offset: DeviceSize) -> Self24611     pub fn offset(mut self, offset: DeviceSize) -> Self {
24612         self.inner.offset = offset;
24613         self
24614     }
24615     #[inline]
flags(mut self, flags: ConditionalRenderingFlagsEXT) -> Self24616     pub fn flags(mut self, flags: ConditionalRenderingFlagsEXT) -> Self {
24617         self.inner.flags = flags;
24618         self
24619     }
24620     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24621     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24622     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ConditionalRenderingBeginInfoEXT24623     pub fn build(self) -> ConditionalRenderingBeginInfoEXT {
24624         self.inner
24625     }
24626 }
24627 #[repr(C)]
24628 #[cfg_attr(feature = "debug", derive(Debug))]
24629 #[derive(Copy, Clone)]
24630 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkProtectedSubmitInfo.html>"]
24631 pub struct ProtectedSubmitInfo {
24632     pub s_type: StructureType,
24633     pub p_next: *const c_void,
24634     pub protected_submit: Bool32,
24635 }
24636 impl ::std::default::Default for ProtectedSubmitInfo {
24637     #[inline]
default() -> Self24638     fn default() -> Self {
24639         Self {
24640             s_type: Self::STRUCTURE_TYPE,
24641             p_next: ::std::ptr::null(),
24642             protected_submit: Bool32::default(),
24643         }
24644     }
24645 }
24646 unsafe impl TaggedStructure for ProtectedSubmitInfo {
24647     const STRUCTURE_TYPE: StructureType = StructureType::PROTECTED_SUBMIT_INFO;
24648 }
24649 impl ProtectedSubmitInfo {
builder<'a>() -> ProtectedSubmitInfoBuilder<'a>24650     pub fn builder<'a>() -> ProtectedSubmitInfoBuilder<'a> {
24651         ProtectedSubmitInfoBuilder {
24652             inner: Self::default(),
24653             marker: ::std::marker::PhantomData,
24654         }
24655     }
24656 }
24657 #[repr(transparent)]
24658 pub struct ProtectedSubmitInfoBuilder<'a> {
24659     inner: ProtectedSubmitInfo,
24660     marker: ::std::marker::PhantomData<&'a ()>,
24661 }
24662 unsafe impl ExtendsSubmitInfo for ProtectedSubmitInfoBuilder<'_> {}
24663 unsafe impl ExtendsSubmitInfo for ProtectedSubmitInfo {}
24664 impl<'a> ::std::ops::Deref for ProtectedSubmitInfoBuilder<'a> {
24665     type Target = ProtectedSubmitInfo;
deref(&self) -> &Self::Target24666     fn deref(&self) -> &Self::Target {
24667         &self.inner
24668     }
24669 }
24670 impl<'a> ::std::ops::DerefMut for ProtectedSubmitInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target24671     fn deref_mut(&mut self) -> &mut Self::Target {
24672         &mut self.inner
24673     }
24674 }
24675 impl<'a> ProtectedSubmitInfoBuilder<'a> {
24676     #[inline]
protected_submit(mut self, protected_submit: bool) -> Self24677     pub fn protected_submit(mut self, protected_submit: bool) -> Self {
24678         self.inner.protected_submit = protected_submit.into();
24679         self
24680     }
24681     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24682     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24683     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ProtectedSubmitInfo24684     pub fn build(self) -> ProtectedSubmitInfo {
24685         self.inner
24686     }
24687 }
24688 #[repr(C)]
24689 #[cfg_attr(feature = "debug", derive(Debug))]
24690 #[derive(Copy, Clone)]
24691 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProtectedMemoryFeatures.html>"]
24692 pub struct PhysicalDeviceProtectedMemoryFeatures {
24693     pub s_type: StructureType,
24694     pub p_next: *mut c_void,
24695     pub protected_memory: Bool32,
24696 }
24697 impl ::std::default::Default for PhysicalDeviceProtectedMemoryFeatures {
24698     #[inline]
default() -> Self24699     fn default() -> Self {
24700         Self {
24701             s_type: Self::STRUCTURE_TYPE,
24702             p_next: ::std::ptr::null_mut(),
24703             protected_memory: Bool32::default(),
24704         }
24705     }
24706 }
24707 unsafe impl TaggedStructure for PhysicalDeviceProtectedMemoryFeatures {
24708     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
24709 }
24710 impl PhysicalDeviceProtectedMemoryFeatures {
builder<'a>() -> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a>24711     pub fn builder<'a>() -> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
24712         PhysicalDeviceProtectedMemoryFeaturesBuilder {
24713             inner: Self::default(),
24714             marker: ::std::marker::PhantomData,
24715         }
24716     }
24717 }
24718 #[repr(transparent)]
24719 pub struct PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
24720     inner: PhysicalDeviceProtectedMemoryFeatures,
24721     marker: ::std::marker::PhantomData<&'a ()>,
24722 }
24723 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProtectedMemoryFeaturesBuilder<'_> {}
24724 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProtectedMemoryFeatures {}
24725 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProtectedMemoryFeaturesBuilder<'_> {}
24726 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProtectedMemoryFeatures {}
24727 impl<'a> ::std::ops::Deref for PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
24728     type Target = PhysicalDeviceProtectedMemoryFeatures;
deref(&self) -> &Self::Target24729     fn deref(&self) -> &Self::Target {
24730         &self.inner
24731     }
24732 }
24733 impl<'a> ::std::ops::DerefMut for PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target24734     fn deref_mut(&mut self) -> &mut Self::Target {
24735         &mut self.inner
24736     }
24737 }
24738 impl<'a> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
24739     #[inline]
protected_memory(mut self, protected_memory: bool) -> Self24740     pub fn protected_memory(mut self, protected_memory: bool) -> Self {
24741         self.inner.protected_memory = protected_memory.into();
24742         self
24743     }
24744     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24745     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24746     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceProtectedMemoryFeatures24747     pub fn build(self) -> PhysicalDeviceProtectedMemoryFeatures {
24748         self.inner
24749     }
24750 }
24751 #[repr(C)]
24752 #[cfg_attr(feature = "debug", derive(Debug))]
24753 #[derive(Copy, Clone)]
24754 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProtectedMemoryProperties.html>"]
24755 pub struct PhysicalDeviceProtectedMemoryProperties {
24756     pub s_type: StructureType,
24757     pub p_next: *mut c_void,
24758     pub protected_no_fault: Bool32,
24759 }
24760 impl ::std::default::Default for PhysicalDeviceProtectedMemoryProperties {
24761     #[inline]
default() -> Self24762     fn default() -> Self {
24763         Self {
24764             s_type: Self::STRUCTURE_TYPE,
24765             p_next: ::std::ptr::null_mut(),
24766             protected_no_fault: Bool32::default(),
24767         }
24768     }
24769 }
24770 unsafe impl TaggedStructure for PhysicalDeviceProtectedMemoryProperties {
24771     const STRUCTURE_TYPE: StructureType =
24772         StructureType::PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES;
24773 }
24774 impl PhysicalDeviceProtectedMemoryProperties {
builder<'a>() -> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a>24775     pub fn builder<'a>() -> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
24776         PhysicalDeviceProtectedMemoryPropertiesBuilder {
24777             inner: Self::default(),
24778             marker: ::std::marker::PhantomData,
24779         }
24780     }
24781 }
24782 #[repr(transparent)]
24783 pub struct PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
24784     inner: PhysicalDeviceProtectedMemoryProperties,
24785     marker: ::std::marker::PhantomData<&'a ()>,
24786 }
24787 unsafe impl ExtendsPhysicalDeviceProperties2
24788     for PhysicalDeviceProtectedMemoryPropertiesBuilder<'_>
24789 {
24790 }
24791 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceProtectedMemoryProperties {}
24792 impl<'a> ::std::ops::Deref for PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
24793     type Target = PhysicalDeviceProtectedMemoryProperties;
deref(&self) -> &Self::Target24794     fn deref(&self) -> &Self::Target {
24795         &self.inner
24796     }
24797 }
24798 impl<'a> ::std::ops::DerefMut for PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target24799     fn deref_mut(&mut self) -> &mut Self::Target {
24800         &mut self.inner
24801     }
24802 }
24803 impl<'a> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
24804     #[inline]
protected_no_fault(mut self, protected_no_fault: bool) -> Self24805     pub fn protected_no_fault(mut self, protected_no_fault: bool) -> Self {
24806         self.inner.protected_no_fault = protected_no_fault.into();
24807         self
24808     }
24809     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24810     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24811     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceProtectedMemoryProperties24812     pub fn build(self) -> PhysicalDeviceProtectedMemoryProperties {
24813         self.inner
24814     }
24815 }
24816 #[repr(C)]
24817 #[cfg_attr(feature = "debug", derive(Debug))]
24818 #[derive(Copy, Clone)]
24819 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceQueueInfo2.html>"]
24820 pub struct DeviceQueueInfo2 {
24821     pub s_type: StructureType,
24822     pub p_next: *const c_void,
24823     pub flags: DeviceQueueCreateFlags,
24824     pub queue_family_index: u32,
24825     pub queue_index: u32,
24826 }
24827 impl ::std::default::Default for DeviceQueueInfo2 {
24828     #[inline]
default() -> Self24829     fn default() -> Self {
24830         Self {
24831             s_type: Self::STRUCTURE_TYPE,
24832             p_next: ::std::ptr::null(),
24833             flags: DeviceQueueCreateFlags::default(),
24834             queue_family_index: u32::default(),
24835             queue_index: u32::default(),
24836         }
24837     }
24838 }
24839 unsafe impl TaggedStructure for DeviceQueueInfo2 {
24840     const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_QUEUE_INFO_2;
24841 }
24842 impl DeviceQueueInfo2 {
builder<'a>() -> DeviceQueueInfo2Builder<'a>24843     pub fn builder<'a>() -> DeviceQueueInfo2Builder<'a> {
24844         DeviceQueueInfo2Builder {
24845             inner: Self::default(),
24846             marker: ::std::marker::PhantomData,
24847         }
24848     }
24849 }
24850 #[repr(transparent)]
24851 pub struct DeviceQueueInfo2Builder<'a> {
24852     inner: DeviceQueueInfo2,
24853     marker: ::std::marker::PhantomData<&'a ()>,
24854 }
24855 impl<'a> ::std::ops::Deref for DeviceQueueInfo2Builder<'a> {
24856     type Target = DeviceQueueInfo2;
deref(&self) -> &Self::Target24857     fn deref(&self) -> &Self::Target {
24858         &self.inner
24859     }
24860 }
24861 impl<'a> ::std::ops::DerefMut for DeviceQueueInfo2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target24862     fn deref_mut(&mut self) -> &mut Self::Target {
24863         &mut self.inner
24864     }
24865 }
24866 impl<'a> DeviceQueueInfo2Builder<'a> {
24867     #[inline]
flags(mut self, flags: DeviceQueueCreateFlags) -> Self24868     pub fn flags(mut self, flags: DeviceQueueCreateFlags) -> Self {
24869         self.inner.flags = flags;
24870         self
24871     }
24872     #[inline]
queue_family_index(mut self, queue_family_index: u32) -> Self24873     pub fn queue_family_index(mut self, queue_family_index: u32) -> Self {
24874         self.inner.queue_family_index = queue_family_index;
24875         self
24876     }
24877     #[inline]
queue_index(mut self, queue_index: u32) -> Self24878     pub fn queue_index(mut self, queue_index: u32) -> Self {
24879         self.inner.queue_index = queue_index;
24880         self
24881     }
24882     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24883     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24884     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceQueueInfo224885     pub fn build(self) -> DeviceQueueInfo2 {
24886         self.inner
24887     }
24888 }
24889 #[repr(C)]
24890 #[cfg_attr(feature = "debug", derive(Debug))]
24891 #[derive(Copy, Clone)]
24892 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageToColorStateCreateInfoNV.html>"]
24893 pub struct PipelineCoverageToColorStateCreateInfoNV {
24894     pub s_type: StructureType,
24895     pub p_next: *const c_void,
24896     pub flags: PipelineCoverageToColorStateCreateFlagsNV,
24897     pub coverage_to_color_enable: Bool32,
24898     pub coverage_to_color_location: u32,
24899 }
24900 impl ::std::default::Default for PipelineCoverageToColorStateCreateInfoNV {
24901     #[inline]
default() -> Self24902     fn default() -> Self {
24903         Self {
24904             s_type: Self::STRUCTURE_TYPE,
24905             p_next: ::std::ptr::null(),
24906             flags: PipelineCoverageToColorStateCreateFlagsNV::default(),
24907             coverage_to_color_enable: Bool32::default(),
24908             coverage_to_color_location: u32::default(),
24909         }
24910     }
24911 }
24912 unsafe impl TaggedStructure for PipelineCoverageToColorStateCreateInfoNV {
24913     const STRUCTURE_TYPE: StructureType =
24914         StructureType::PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV;
24915 }
24916 impl PipelineCoverageToColorStateCreateInfoNV {
builder<'a>() -> PipelineCoverageToColorStateCreateInfoNVBuilder<'a>24917     pub fn builder<'a>() -> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
24918         PipelineCoverageToColorStateCreateInfoNVBuilder {
24919             inner: Self::default(),
24920             marker: ::std::marker::PhantomData,
24921         }
24922     }
24923 }
24924 #[repr(transparent)]
24925 pub struct PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
24926     inner: PipelineCoverageToColorStateCreateInfoNV,
24927     marker: ::std::marker::PhantomData<&'a ()>,
24928 }
24929 unsafe impl ExtendsPipelineMultisampleStateCreateInfo
24930     for PipelineCoverageToColorStateCreateInfoNVBuilder<'_>
24931 {
24932 }
24933 unsafe impl ExtendsPipelineMultisampleStateCreateInfo for PipelineCoverageToColorStateCreateInfoNV {}
24934 impl<'a> ::std::ops::Deref for PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
24935     type Target = PipelineCoverageToColorStateCreateInfoNV;
deref(&self) -> &Self::Target24936     fn deref(&self) -> &Self::Target {
24937         &self.inner
24938     }
24939 }
24940 impl<'a> ::std::ops::DerefMut for PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target24941     fn deref_mut(&mut self) -> &mut Self::Target {
24942         &mut self.inner
24943     }
24944 }
24945 impl<'a> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
24946     #[inline]
flags(mut self, flags: PipelineCoverageToColorStateCreateFlagsNV) -> Self24947     pub fn flags(mut self, flags: PipelineCoverageToColorStateCreateFlagsNV) -> Self {
24948         self.inner.flags = flags;
24949         self
24950     }
24951     #[inline]
coverage_to_color_enable(mut self, coverage_to_color_enable: bool) -> Self24952     pub fn coverage_to_color_enable(mut self, coverage_to_color_enable: bool) -> Self {
24953         self.inner.coverage_to_color_enable = coverage_to_color_enable.into();
24954         self
24955     }
24956     #[inline]
coverage_to_color_location(mut self, coverage_to_color_location: u32) -> Self24957     pub fn coverage_to_color_location(mut self, coverage_to_color_location: u32) -> Self {
24958         self.inner.coverage_to_color_location = coverage_to_color_location;
24959         self
24960     }
24961     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24962     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24963     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineCoverageToColorStateCreateInfoNV24964     pub fn build(self) -> PipelineCoverageToColorStateCreateInfoNV {
24965         self.inner
24966     }
24967 }
24968 #[repr(C)]
24969 #[cfg_attr(feature = "debug", derive(Debug))]
24970 #[derive(Copy, Clone)]
24971 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSamplerFilterMinmaxProperties.html>"]
24972 pub struct PhysicalDeviceSamplerFilterMinmaxProperties {
24973     pub s_type: StructureType,
24974     pub p_next: *mut c_void,
24975     pub filter_minmax_single_component_formats: Bool32,
24976     pub filter_minmax_image_component_mapping: Bool32,
24977 }
24978 impl ::std::default::Default for PhysicalDeviceSamplerFilterMinmaxProperties {
24979     #[inline]
default() -> Self24980     fn default() -> Self {
24981         Self {
24982             s_type: Self::STRUCTURE_TYPE,
24983             p_next: ::std::ptr::null_mut(),
24984             filter_minmax_single_component_formats: Bool32::default(),
24985             filter_minmax_image_component_mapping: Bool32::default(),
24986         }
24987     }
24988 }
24989 unsafe impl TaggedStructure for PhysicalDeviceSamplerFilterMinmaxProperties {
24990     const STRUCTURE_TYPE: StructureType =
24991         StructureType::PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
24992 }
24993 impl PhysicalDeviceSamplerFilterMinmaxProperties {
builder<'a>() -> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a>24994     pub fn builder<'a>() -> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
24995         PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder {
24996             inner: Self::default(),
24997             marker: ::std::marker::PhantomData,
24998         }
24999     }
25000 }
25001 #[repr(transparent)]
25002 pub struct PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
25003     inner: PhysicalDeviceSamplerFilterMinmaxProperties,
25004     marker: ::std::marker::PhantomData<&'a ()>,
25005 }
25006 unsafe impl ExtendsPhysicalDeviceProperties2
25007     for PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'_>
25008 {
25009 }
25010 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSamplerFilterMinmaxProperties {}
25011 impl<'a> ::std::ops::Deref for PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
25012     type Target = PhysicalDeviceSamplerFilterMinmaxProperties;
deref(&self) -> &Self::Target25013     fn deref(&self) -> &Self::Target {
25014         &self.inner
25015     }
25016 }
25017 impl<'a> ::std::ops::DerefMut for PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target25018     fn deref_mut(&mut self) -> &mut Self::Target {
25019         &mut self.inner
25020     }
25021 }
25022 impl<'a> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
25023     #[inline]
filter_minmax_single_component_formats( mut self, filter_minmax_single_component_formats: bool, ) -> Self25024     pub fn filter_minmax_single_component_formats(
25025         mut self,
25026         filter_minmax_single_component_formats: bool,
25027     ) -> Self {
25028         self.inner.filter_minmax_single_component_formats =
25029             filter_minmax_single_component_formats.into();
25030         self
25031     }
25032     #[inline]
filter_minmax_image_component_mapping( mut self, filter_minmax_image_component_mapping: bool, ) -> Self25033     pub fn filter_minmax_image_component_mapping(
25034         mut self,
25035         filter_minmax_image_component_mapping: bool,
25036     ) -> Self {
25037         self.inner.filter_minmax_image_component_mapping =
25038             filter_minmax_image_component_mapping.into();
25039         self
25040     }
25041     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25042     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25043     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceSamplerFilterMinmaxProperties25044     pub fn build(self) -> PhysicalDeviceSamplerFilterMinmaxProperties {
25045         self.inner
25046     }
25047 }
25048 #[repr(C)]
25049 #[cfg_attr(feature = "debug", derive(Debug))]
25050 #[derive(Copy, Clone, Default)]
25051 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSampleLocationEXT.html>"]
25052 pub struct SampleLocationEXT {
25053     pub x: f32,
25054     pub y: f32,
25055 }
25056 impl SampleLocationEXT {
builder<'a>() -> SampleLocationEXTBuilder<'a>25057     pub fn builder<'a>() -> SampleLocationEXTBuilder<'a> {
25058         SampleLocationEXTBuilder {
25059             inner: Self::default(),
25060             marker: ::std::marker::PhantomData,
25061         }
25062     }
25063 }
25064 #[repr(transparent)]
25065 pub struct SampleLocationEXTBuilder<'a> {
25066     inner: SampleLocationEXT,
25067     marker: ::std::marker::PhantomData<&'a ()>,
25068 }
25069 impl<'a> ::std::ops::Deref for SampleLocationEXTBuilder<'a> {
25070     type Target = SampleLocationEXT;
deref(&self) -> &Self::Target25071     fn deref(&self) -> &Self::Target {
25072         &self.inner
25073     }
25074 }
25075 impl<'a> ::std::ops::DerefMut for SampleLocationEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target25076     fn deref_mut(&mut self) -> &mut Self::Target {
25077         &mut self.inner
25078     }
25079 }
25080 impl<'a> SampleLocationEXTBuilder<'a> {
25081     #[inline]
x(mut self, x: f32) -> Self25082     pub fn x(mut self, x: f32) -> Self {
25083         self.inner.x = x;
25084         self
25085     }
25086     #[inline]
y(mut self, y: f32) -> Self25087     pub fn y(mut self, y: f32) -> Self {
25088         self.inner.y = y;
25089         self
25090     }
25091     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25092     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25093     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SampleLocationEXT25094     pub fn build(self) -> SampleLocationEXT {
25095         self.inner
25096     }
25097 }
25098 #[repr(C)]
25099 #[cfg_attr(feature = "debug", derive(Debug))]
25100 #[derive(Copy, Clone)]
25101 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSampleLocationsInfoEXT.html>"]
25102 pub struct SampleLocationsInfoEXT {
25103     pub s_type: StructureType,
25104     pub p_next: *const c_void,
25105     pub sample_locations_per_pixel: SampleCountFlags,
25106     pub sample_location_grid_size: Extent2D,
25107     pub sample_locations_count: u32,
25108     pub p_sample_locations: *const SampleLocationEXT,
25109 }
25110 impl ::std::default::Default for SampleLocationsInfoEXT {
25111     #[inline]
default() -> Self25112     fn default() -> Self {
25113         Self {
25114             s_type: Self::STRUCTURE_TYPE,
25115             p_next: ::std::ptr::null(),
25116             sample_locations_per_pixel: SampleCountFlags::default(),
25117             sample_location_grid_size: Extent2D::default(),
25118             sample_locations_count: u32::default(),
25119             p_sample_locations: ::std::ptr::null(),
25120         }
25121     }
25122 }
25123 unsafe impl TaggedStructure for SampleLocationsInfoEXT {
25124     const STRUCTURE_TYPE: StructureType = StructureType::SAMPLE_LOCATIONS_INFO_EXT;
25125 }
25126 impl SampleLocationsInfoEXT {
builder<'a>() -> SampleLocationsInfoEXTBuilder<'a>25127     pub fn builder<'a>() -> SampleLocationsInfoEXTBuilder<'a> {
25128         SampleLocationsInfoEXTBuilder {
25129             inner: Self::default(),
25130             marker: ::std::marker::PhantomData,
25131         }
25132     }
25133 }
25134 #[repr(transparent)]
25135 pub struct SampleLocationsInfoEXTBuilder<'a> {
25136     inner: SampleLocationsInfoEXT,
25137     marker: ::std::marker::PhantomData<&'a ()>,
25138 }
25139 unsafe impl ExtendsImageMemoryBarrier for SampleLocationsInfoEXTBuilder<'_> {}
25140 unsafe impl ExtendsImageMemoryBarrier for SampleLocationsInfoEXT {}
25141 unsafe impl ExtendsImageMemoryBarrier2 for SampleLocationsInfoEXTBuilder<'_> {}
25142 unsafe impl ExtendsImageMemoryBarrier2 for SampleLocationsInfoEXT {}
25143 impl<'a> ::std::ops::Deref for SampleLocationsInfoEXTBuilder<'a> {
25144     type Target = SampleLocationsInfoEXT;
deref(&self) -> &Self::Target25145     fn deref(&self) -> &Self::Target {
25146         &self.inner
25147     }
25148 }
25149 impl<'a> ::std::ops::DerefMut for SampleLocationsInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target25150     fn deref_mut(&mut self) -> &mut Self::Target {
25151         &mut self.inner
25152     }
25153 }
25154 impl<'a> SampleLocationsInfoEXTBuilder<'a> {
25155     #[inline]
sample_locations_per_pixel( mut self, sample_locations_per_pixel: SampleCountFlags, ) -> Self25156     pub fn sample_locations_per_pixel(
25157         mut self,
25158         sample_locations_per_pixel: SampleCountFlags,
25159     ) -> Self {
25160         self.inner.sample_locations_per_pixel = sample_locations_per_pixel;
25161         self
25162     }
25163     #[inline]
sample_location_grid_size(mut self, sample_location_grid_size: Extent2D) -> Self25164     pub fn sample_location_grid_size(mut self, sample_location_grid_size: Extent2D) -> Self {
25165         self.inner.sample_location_grid_size = sample_location_grid_size;
25166         self
25167     }
25168     #[inline]
sample_locations(mut self, sample_locations: &'a [SampleLocationEXT]) -> Self25169     pub fn sample_locations(mut self, sample_locations: &'a [SampleLocationEXT]) -> Self {
25170         self.inner.sample_locations_count = sample_locations.len() as _;
25171         self.inner.p_sample_locations = sample_locations.as_ptr();
25172         self
25173     }
25174     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25175     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25176     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SampleLocationsInfoEXT25177     pub fn build(self) -> SampleLocationsInfoEXT {
25178         self.inner
25179     }
25180 }
25181 #[repr(C)]
25182 #[cfg_attr(feature = "debug", derive(Debug))]
25183 #[derive(Copy, Clone, Default)]
25184 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentSampleLocationsEXT.html>"]
25185 pub struct AttachmentSampleLocationsEXT {
25186     pub attachment_index: u32,
25187     pub sample_locations_info: SampleLocationsInfoEXT,
25188 }
25189 impl AttachmentSampleLocationsEXT {
builder<'a>() -> AttachmentSampleLocationsEXTBuilder<'a>25190     pub fn builder<'a>() -> AttachmentSampleLocationsEXTBuilder<'a> {
25191         AttachmentSampleLocationsEXTBuilder {
25192             inner: Self::default(),
25193             marker: ::std::marker::PhantomData,
25194         }
25195     }
25196 }
25197 #[repr(transparent)]
25198 pub struct AttachmentSampleLocationsEXTBuilder<'a> {
25199     inner: AttachmentSampleLocationsEXT,
25200     marker: ::std::marker::PhantomData<&'a ()>,
25201 }
25202 impl<'a> ::std::ops::Deref for AttachmentSampleLocationsEXTBuilder<'a> {
25203     type Target = AttachmentSampleLocationsEXT;
deref(&self) -> &Self::Target25204     fn deref(&self) -> &Self::Target {
25205         &self.inner
25206     }
25207 }
25208 impl<'a> ::std::ops::DerefMut for AttachmentSampleLocationsEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target25209     fn deref_mut(&mut self) -> &mut Self::Target {
25210         &mut self.inner
25211     }
25212 }
25213 impl<'a> AttachmentSampleLocationsEXTBuilder<'a> {
25214     #[inline]
attachment_index(mut self, attachment_index: u32) -> Self25215     pub fn attachment_index(mut self, attachment_index: u32) -> Self {
25216         self.inner.attachment_index = attachment_index;
25217         self
25218     }
25219     #[inline]
sample_locations_info(mut self, sample_locations_info: SampleLocationsInfoEXT) -> Self25220     pub fn sample_locations_info(mut self, sample_locations_info: SampleLocationsInfoEXT) -> Self {
25221         self.inner.sample_locations_info = sample_locations_info;
25222         self
25223     }
25224     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25225     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25226     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AttachmentSampleLocationsEXT25227     pub fn build(self) -> AttachmentSampleLocationsEXT {
25228         self.inner
25229     }
25230 }
25231 #[repr(C)]
25232 #[cfg_attr(feature = "debug", derive(Debug))]
25233 #[derive(Copy, Clone, Default)]
25234 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassSampleLocationsEXT.html>"]
25235 pub struct SubpassSampleLocationsEXT {
25236     pub subpass_index: u32,
25237     pub sample_locations_info: SampleLocationsInfoEXT,
25238 }
25239 impl SubpassSampleLocationsEXT {
builder<'a>() -> SubpassSampleLocationsEXTBuilder<'a>25240     pub fn builder<'a>() -> SubpassSampleLocationsEXTBuilder<'a> {
25241         SubpassSampleLocationsEXTBuilder {
25242             inner: Self::default(),
25243             marker: ::std::marker::PhantomData,
25244         }
25245     }
25246 }
25247 #[repr(transparent)]
25248 pub struct SubpassSampleLocationsEXTBuilder<'a> {
25249     inner: SubpassSampleLocationsEXT,
25250     marker: ::std::marker::PhantomData<&'a ()>,
25251 }
25252 impl<'a> ::std::ops::Deref for SubpassSampleLocationsEXTBuilder<'a> {
25253     type Target = SubpassSampleLocationsEXT;
deref(&self) -> &Self::Target25254     fn deref(&self) -> &Self::Target {
25255         &self.inner
25256     }
25257 }
25258 impl<'a> ::std::ops::DerefMut for SubpassSampleLocationsEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target25259     fn deref_mut(&mut self) -> &mut Self::Target {
25260         &mut self.inner
25261     }
25262 }
25263 impl<'a> SubpassSampleLocationsEXTBuilder<'a> {
25264     #[inline]
subpass_index(mut self, subpass_index: u32) -> Self25265     pub fn subpass_index(mut self, subpass_index: u32) -> Self {
25266         self.inner.subpass_index = subpass_index;
25267         self
25268     }
25269     #[inline]
sample_locations_info(mut self, sample_locations_info: SampleLocationsInfoEXT) -> Self25270     pub fn sample_locations_info(mut self, sample_locations_info: SampleLocationsInfoEXT) -> Self {
25271         self.inner.sample_locations_info = sample_locations_info;
25272         self
25273     }
25274     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25275     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25276     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SubpassSampleLocationsEXT25277     pub fn build(self) -> SubpassSampleLocationsEXT {
25278         self.inner
25279     }
25280 }
25281 #[repr(C)]
25282 #[cfg_attr(feature = "debug", derive(Debug))]
25283 #[derive(Copy, Clone)]
25284 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassSampleLocationsBeginInfoEXT.html>"]
25285 pub struct RenderPassSampleLocationsBeginInfoEXT {
25286     pub s_type: StructureType,
25287     pub p_next: *const c_void,
25288     pub attachment_initial_sample_locations_count: u32,
25289     pub p_attachment_initial_sample_locations: *const AttachmentSampleLocationsEXT,
25290     pub post_subpass_sample_locations_count: u32,
25291     pub p_post_subpass_sample_locations: *const SubpassSampleLocationsEXT,
25292 }
25293 impl ::std::default::Default for RenderPassSampleLocationsBeginInfoEXT {
25294     #[inline]
default() -> Self25295     fn default() -> Self {
25296         Self {
25297             s_type: Self::STRUCTURE_TYPE,
25298             p_next: ::std::ptr::null(),
25299             attachment_initial_sample_locations_count: u32::default(),
25300             p_attachment_initial_sample_locations: ::std::ptr::null(),
25301             post_subpass_sample_locations_count: u32::default(),
25302             p_post_subpass_sample_locations: ::std::ptr::null(),
25303         }
25304     }
25305 }
25306 unsafe impl TaggedStructure for RenderPassSampleLocationsBeginInfoEXT {
25307     const STRUCTURE_TYPE: StructureType =
25308         StructureType::RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT;
25309 }
25310 impl RenderPassSampleLocationsBeginInfoEXT {
builder<'a>() -> RenderPassSampleLocationsBeginInfoEXTBuilder<'a>25311     pub fn builder<'a>() -> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
25312         RenderPassSampleLocationsBeginInfoEXTBuilder {
25313             inner: Self::default(),
25314             marker: ::std::marker::PhantomData,
25315         }
25316     }
25317 }
25318 #[repr(transparent)]
25319 pub struct RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
25320     inner: RenderPassSampleLocationsBeginInfoEXT,
25321     marker: ::std::marker::PhantomData<&'a ()>,
25322 }
25323 unsafe impl ExtendsRenderPassBeginInfo for RenderPassSampleLocationsBeginInfoEXTBuilder<'_> {}
25324 unsafe impl ExtendsRenderPassBeginInfo for RenderPassSampleLocationsBeginInfoEXT {}
25325 impl<'a> ::std::ops::Deref for RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
25326     type Target = RenderPassSampleLocationsBeginInfoEXT;
deref(&self) -> &Self::Target25327     fn deref(&self) -> &Self::Target {
25328         &self.inner
25329     }
25330 }
25331 impl<'a> ::std::ops::DerefMut for RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target25332     fn deref_mut(&mut self) -> &mut Self::Target {
25333         &mut self.inner
25334     }
25335 }
25336 impl<'a> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
25337     #[inline]
attachment_initial_sample_locations( mut self, attachment_initial_sample_locations: &'a [AttachmentSampleLocationsEXT], ) -> Self25338     pub fn attachment_initial_sample_locations(
25339         mut self,
25340         attachment_initial_sample_locations: &'a [AttachmentSampleLocationsEXT],
25341     ) -> Self {
25342         self.inner.attachment_initial_sample_locations_count =
25343             attachment_initial_sample_locations.len() as _;
25344         self.inner.p_attachment_initial_sample_locations =
25345             attachment_initial_sample_locations.as_ptr();
25346         self
25347     }
25348     #[inline]
post_subpass_sample_locations( mut self, post_subpass_sample_locations: &'a [SubpassSampleLocationsEXT], ) -> Self25349     pub fn post_subpass_sample_locations(
25350         mut self,
25351         post_subpass_sample_locations: &'a [SubpassSampleLocationsEXT],
25352     ) -> Self {
25353         self.inner.post_subpass_sample_locations_count = post_subpass_sample_locations.len() as _;
25354         self.inner.p_post_subpass_sample_locations = post_subpass_sample_locations.as_ptr();
25355         self
25356     }
25357     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25358     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25359     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RenderPassSampleLocationsBeginInfoEXT25360     pub fn build(self) -> RenderPassSampleLocationsBeginInfoEXT {
25361         self.inner
25362     }
25363 }
25364 #[repr(C)]
25365 #[cfg_attr(feature = "debug", derive(Debug))]
25366 #[derive(Copy, Clone)]
25367 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineSampleLocationsStateCreateInfoEXT.html>"]
25368 pub struct PipelineSampleLocationsStateCreateInfoEXT {
25369     pub s_type: StructureType,
25370     pub p_next: *const c_void,
25371     pub sample_locations_enable: Bool32,
25372     pub sample_locations_info: SampleLocationsInfoEXT,
25373 }
25374 impl ::std::default::Default for PipelineSampleLocationsStateCreateInfoEXT {
25375     #[inline]
default() -> Self25376     fn default() -> Self {
25377         Self {
25378             s_type: Self::STRUCTURE_TYPE,
25379             p_next: ::std::ptr::null(),
25380             sample_locations_enable: Bool32::default(),
25381             sample_locations_info: SampleLocationsInfoEXT::default(),
25382         }
25383     }
25384 }
25385 unsafe impl TaggedStructure for PipelineSampleLocationsStateCreateInfoEXT {
25386     const STRUCTURE_TYPE: StructureType =
25387         StructureType::PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT;
25388 }
25389 impl PipelineSampleLocationsStateCreateInfoEXT {
builder<'a>() -> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a>25390     pub fn builder<'a>() -> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
25391         PipelineSampleLocationsStateCreateInfoEXTBuilder {
25392             inner: Self::default(),
25393             marker: ::std::marker::PhantomData,
25394         }
25395     }
25396 }
25397 #[repr(transparent)]
25398 pub struct PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
25399     inner: PipelineSampleLocationsStateCreateInfoEXT,
25400     marker: ::std::marker::PhantomData<&'a ()>,
25401 }
25402 unsafe impl ExtendsPipelineMultisampleStateCreateInfo
25403     for PipelineSampleLocationsStateCreateInfoEXTBuilder<'_>
25404 {
25405 }
25406 unsafe impl ExtendsPipelineMultisampleStateCreateInfo
25407     for PipelineSampleLocationsStateCreateInfoEXT
25408 {
25409 }
25410 impl<'a> ::std::ops::Deref for PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
25411     type Target = PipelineSampleLocationsStateCreateInfoEXT;
deref(&self) -> &Self::Target25412     fn deref(&self) -> &Self::Target {
25413         &self.inner
25414     }
25415 }
25416 impl<'a> ::std::ops::DerefMut for PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target25417     fn deref_mut(&mut self) -> &mut Self::Target {
25418         &mut self.inner
25419     }
25420 }
25421 impl<'a> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
25422     #[inline]
sample_locations_enable(mut self, sample_locations_enable: bool) -> Self25423     pub fn sample_locations_enable(mut self, sample_locations_enable: bool) -> Self {
25424         self.inner.sample_locations_enable = sample_locations_enable.into();
25425         self
25426     }
25427     #[inline]
sample_locations_info(mut self, sample_locations_info: SampleLocationsInfoEXT) -> Self25428     pub fn sample_locations_info(mut self, sample_locations_info: SampleLocationsInfoEXT) -> Self {
25429         self.inner.sample_locations_info = sample_locations_info;
25430         self
25431     }
25432     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25433     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25434     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineSampleLocationsStateCreateInfoEXT25435     pub fn build(self) -> PipelineSampleLocationsStateCreateInfoEXT {
25436         self.inner
25437     }
25438 }
25439 #[repr(C)]
25440 #[cfg_attr(feature = "debug", derive(Debug))]
25441 #[derive(Copy, Clone)]
25442 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSampleLocationsPropertiesEXT.html>"]
25443 pub struct PhysicalDeviceSampleLocationsPropertiesEXT {
25444     pub s_type: StructureType,
25445     pub p_next: *mut c_void,
25446     pub sample_location_sample_counts: SampleCountFlags,
25447     pub max_sample_location_grid_size: Extent2D,
25448     pub sample_location_coordinate_range: [f32; 2],
25449     pub sample_location_sub_pixel_bits: u32,
25450     pub variable_sample_locations: Bool32,
25451 }
25452 impl ::std::default::Default for PhysicalDeviceSampleLocationsPropertiesEXT {
25453     #[inline]
default() -> Self25454     fn default() -> Self {
25455         Self {
25456             s_type: Self::STRUCTURE_TYPE,
25457             p_next: ::std::ptr::null_mut(),
25458             sample_location_sample_counts: SampleCountFlags::default(),
25459             max_sample_location_grid_size: Extent2D::default(),
25460             sample_location_coordinate_range: unsafe { ::std::mem::zeroed() },
25461             sample_location_sub_pixel_bits: u32::default(),
25462             variable_sample_locations: Bool32::default(),
25463         }
25464     }
25465 }
25466 unsafe impl TaggedStructure for PhysicalDeviceSampleLocationsPropertiesEXT {
25467     const STRUCTURE_TYPE: StructureType =
25468         StructureType::PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT;
25469 }
25470 impl PhysicalDeviceSampleLocationsPropertiesEXT {
builder<'a>() -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a>25471     pub fn builder<'a>() -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
25472         PhysicalDeviceSampleLocationsPropertiesEXTBuilder {
25473             inner: Self::default(),
25474             marker: ::std::marker::PhantomData,
25475         }
25476     }
25477 }
25478 #[repr(transparent)]
25479 pub struct PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
25480     inner: PhysicalDeviceSampleLocationsPropertiesEXT,
25481     marker: ::std::marker::PhantomData<&'a ()>,
25482 }
25483 unsafe impl ExtendsPhysicalDeviceProperties2
25484     for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'_>
25485 {
25486 }
25487 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSampleLocationsPropertiesEXT {}
25488 impl<'a> ::std::ops::Deref for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
25489     type Target = PhysicalDeviceSampleLocationsPropertiesEXT;
deref(&self) -> &Self::Target25490     fn deref(&self) -> &Self::Target {
25491         &self.inner
25492     }
25493 }
25494 impl<'a> ::std::ops::DerefMut for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target25495     fn deref_mut(&mut self) -> &mut Self::Target {
25496         &mut self.inner
25497     }
25498 }
25499 impl<'a> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
25500     #[inline]
sample_location_sample_counts( mut self, sample_location_sample_counts: SampleCountFlags, ) -> Self25501     pub fn sample_location_sample_counts(
25502         mut self,
25503         sample_location_sample_counts: SampleCountFlags,
25504     ) -> Self {
25505         self.inner.sample_location_sample_counts = sample_location_sample_counts;
25506         self
25507     }
25508     #[inline]
max_sample_location_grid_size( mut self, max_sample_location_grid_size: Extent2D, ) -> Self25509     pub fn max_sample_location_grid_size(
25510         mut self,
25511         max_sample_location_grid_size: Extent2D,
25512     ) -> Self {
25513         self.inner.max_sample_location_grid_size = max_sample_location_grid_size;
25514         self
25515     }
25516     #[inline]
sample_location_coordinate_range( mut self, sample_location_coordinate_range: [f32; 2], ) -> Self25517     pub fn sample_location_coordinate_range(
25518         mut self,
25519         sample_location_coordinate_range: [f32; 2],
25520     ) -> Self {
25521         self.inner.sample_location_coordinate_range = sample_location_coordinate_range;
25522         self
25523     }
25524     #[inline]
sample_location_sub_pixel_bits(mut self, sample_location_sub_pixel_bits: u32) -> Self25525     pub fn sample_location_sub_pixel_bits(mut self, sample_location_sub_pixel_bits: u32) -> Self {
25526         self.inner.sample_location_sub_pixel_bits = sample_location_sub_pixel_bits;
25527         self
25528     }
25529     #[inline]
variable_sample_locations(mut self, variable_sample_locations: bool) -> Self25530     pub fn variable_sample_locations(mut self, variable_sample_locations: bool) -> Self {
25531         self.inner.variable_sample_locations = variable_sample_locations.into();
25532         self
25533     }
25534     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25535     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25536     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceSampleLocationsPropertiesEXT25537     pub fn build(self) -> PhysicalDeviceSampleLocationsPropertiesEXT {
25538         self.inner
25539     }
25540 }
25541 #[repr(C)]
25542 #[cfg_attr(feature = "debug", derive(Debug))]
25543 #[derive(Copy, Clone)]
25544 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMultisamplePropertiesEXT.html>"]
25545 pub struct MultisamplePropertiesEXT {
25546     pub s_type: StructureType,
25547     pub p_next: *mut c_void,
25548     pub max_sample_location_grid_size: Extent2D,
25549 }
25550 impl ::std::default::Default for MultisamplePropertiesEXT {
25551     #[inline]
default() -> Self25552     fn default() -> Self {
25553         Self {
25554             s_type: Self::STRUCTURE_TYPE,
25555             p_next: ::std::ptr::null_mut(),
25556             max_sample_location_grid_size: Extent2D::default(),
25557         }
25558     }
25559 }
25560 unsafe impl TaggedStructure for MultisamplePropertiesEXT {
25561     const STRUCTURE_TYPE: StructureType = StructureType::MULTISAMPLE_PROPERTIES_EXT;
25562 }
25563 impl MultisamplePropertiesEXT {
builder<'a>() -> MultisamplePropertiesEXTBuilder<'a>25564     pub fn builder<'a>() -> MultisamplePropertiesEXTBuilder<'a> {
25565         MultisamplePropertiesEXTBuilder {
25566             inner: Self::default(),
25567             marker: ::std::marker::PhantomData,
25568         }
25569     }
25570 }
25571 #[repr(transparent)]
25572 pub struct MultisamplePropertiesEXTBuilder<'a> {
25573     inner: MultisamplePropertiesEXT,
25574     marker: ::std::marker::PhantomData<&'a ()>,
25575 }
25576 impl<'a> ::std::ops::Deref for MultisamplePropertiesEXTBuilder<'a> {
25577     type Target = MultisamplePropertiesEXT;
deref(&self) -> &Self::Target25578     fn deref(&self) -> &Self::Target {
25579         &self.inner
25580     }
25581 }
25582 impl<'a> ::std::ops::DerefMut for MultisamplePropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target25583     fn deref_mut(&mut self) -> &mut Self::Target {
25584         &mut self.inner
25585     }
25586 }
25587 impl<'a> MultisamplePropertiesEXTBuilder<'a> {
25588     #[inline]
max_sample_location_grid_size( mut self, max_sample_location_grid_size: Extent2D, ) -> Self25589     pub fn max_sample_location_grid_size(
25590         mut self,
25591         max_sample_location_grid_size: Extent2D,
25592     ) -> Self {
25593         self.inner.max_sample_location_grid_size = max_sample_location_grid_size;
25594         self
25595     }
25596     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25597     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25598     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MultisamplePropertiesEXT25599     pub fn build(self) -> MultisamplePropertiesEXT {
25600         self.inner
25601     }
25602 }
25603 #[repr(C)]
25604 #[cfg_attr(feature = "debug", derive(Debug))]
25605 #[derive(Copy, Clone)]
25606 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerReductionModeCreateInfo.html>"]
25607 pub struct SamplerReductionModeCreateInfo {
25608     pub s_type: StructureType,
25609     pub p_next: *const c_void,
25610     pub reduction_mode: SamplerReductionMode,
25611 }
25612 impl ::std::default::Default for SamplerReductionModeCreateInfo {
25613     #[inline]
default() -> Self25614     fn default() -> Self {
25615         Self {
25616             s_type: Self::STRUCTURE_TYPE,
25617             p_next: ::std::ptr::null(),
25618             reduction_mode: SamplerReductionMode::default(),
25619         }
25620     }
25621 }
25622 unsafe impl TaggedStructure for SamplerReductionModeCreateInfo {
25623     const STRUCTURE_TYPE: StructureType = StructureType::SAMPLER_REDUCTION_MODE_CREATE_INFO;
25624 }
25625 impl SamplerReductionModeCreateInfo {
builder<'a>() -> SamplerReductionModeCreateInfoBuilder<'a>25626     pub fn builder<'a>() -> SamplerReductionModeCreateInfoBuilder<'a> {
25627         SamplerReductionModeCreateInfoBuilder {
25628             inner: Self::default(),
25629             marker: ::std::marker::PhantomData,
25630         }
25631     }
25632 }
25633 #[repr(transparent)]
25634 pub struct SamplerReductionModeCreateInfoBuilder<'a> {
25635     inner: SamplerReductionModeCreateInfo,
25636     marker: ::std::marker::PhantomData<&'a ()>,
25637 }
25638 unsafe impl ExtendsSamplerCreateInfo for SamplerReductionModeCreateInfoBuilder<'_> {}
25639 unsafe impl ExtendsSamplerCreateInfo for SamplerReductionModeCreateInfo {}
25640 impl<'a> ::std::ops::Deref for SamplerReductionModeCreateInfoBuilder<'a> {
25641     type Target = SamplerReductionModeCreateInfo;
deref(&self) -> &Self::Target25642     fn deref(&self) -> &Self::Target {
25643         &self.inner
25644     }
25645 }
25646 impl<'a> ::std::ops::DerefMut for SamplerReductionModeCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target25647     fn deref_mut(&mut self) -> &mut Self::Target {
25648         &mut self.inner
25649     }
25650 }
25651 impl<'a> SamplerReductionModeCreateInfoBuilder<'a> {
25652     #[inline]
reduction_mode(mut self, reduction_mode: SamplerReductionMode) -> Self25653     pub fn reduction_mode(mut self, reduction_mode: SamplerReductionMode) -> Self {
25654         self.inner.reduction_mode = reduction_mode;
25655         self
25656     }
25657     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25658     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25659     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SamplerReductionModeCreateInfo25660     pub fn build(self) -> SamplerReductionModeCreateInfo {
25661         self.inner
25662     }
25663 }
25664 #[repr(C)]
25665 #[cfg_attr(feature = "debug", derive(Debug))]
25666 #[derive(Copy, Clone)]
25667 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT.html>"]
25668 pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
25669     pub s_type: StructureType,
25670     pub p_next: *mut c_void,
25671     pub advanced_blend_coherent_operations: Bool32,
25672 }
25673 impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
25674     #[inline]
default() -> Self25675     fn default() -> Self {
25676         Self {
25677             s_type: Self::STRUCTURE_TYPE,
25678             p_next: ::std::ptr::null_mut(),
25679             advanced_blend_coherent_operations: Bool32::default(),
25680         }
25681     }
25682 }
25683 unsafe impl TaggedStructure for PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
25684     const STRUCTURE_TYPE: StructureType =
25685         StructureType::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
25686 }
25687 impl PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
builder<'a>() -> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a>25688     pub fn builder<'a>() -> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
25689         PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder {
25690             inner: Self::default(),
25691             marker: ::std::marker::PhantomData,
25692         }
25693     }
25694 }
25695 #[repr(transparent)]
25696 pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
25697     inner: PhysicalDeviceBlendOperationAdvancedFeaturesEXT,
25698     marker: ::std::marker::PhantomData<&'a ()>,
25699 }
25700 unsafe impl ExtendsPhysicalDeviceFeatures2
25701     for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'_>
25702 {
25703 }
25704 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBlendOperationAdvancedFeaturesEXT {}
25705 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'_> {}
25706 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBlendOperationAdvancedFeaturesEXT {}
25707 impl<'a> ::std::ops::Deref for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
25708     type Target = PhysicalDeviceBlendOperationAdvancedFeaturesEXT;
deref(&self) -> &Self::Target25709     fn deref(&self) -> &Self::Target {
25710         &self.inner
25711     }
25712 }
25713 impl<'a> ::std::ops::DerefMut for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target25714     fn deref_mut(&mut self) -> &mut Self::Target {
25715         &mut self.inner
25716     }
25717 }
25718 impl<'a> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
25719     #[inline]
advanced_blend_coherent_operations( mut self, advanced_blend_coherent_operations: bool, ) -> Self25720     pub fn advanced_blend_coherent_operations(
25721         mut self,
25722         advanced_blend_coherent_operations: bool,
25723     ) -> Self {
25724         self.inner.advanced_blend_coherent_operations = advanced_blend_coherent_operations.into();
25725         self
25726     }
25727     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25728     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25729     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceBlendOperationAdvancedFeaturesEXT25730     pub fn build(self) -> PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
25731         self.inner
25732     }
25733 }
25734 #[repr(C)]
25735 #[cfg_attr(feature = "debug", derive(Debug))]
25736 #[derive(Copy, Clone)]
25737 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiDrawFeaturesEXT.html>"]
25738 pub struct PhysicalDeviceMultiDrawFeaturesEXT {
25739     pub s_type: StructureType,
25740     pub p_next: *mut c_void,
25741     pub multi_draw: Bool32,
25742 }
25743 impl ::std::default::Default for PhysicalDeviceMultiDrawFeaturesEXT {
25744     #[inline]
default() -> Self25745     fn default() -> Self {
25746         Self {
25747             s_type: Self::STRUCTURE_TYPE,
25748             p_next: ::std::ptr::null_mut(),
25749             multi_draw: Bool32::default(),
25750         }
25751     }
25752 }
25753 unsafe impl TaggedStructure for PhysicalDeviceMultiDrawFeaturesEXT {
25754     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
25755 }
25756 impl PhysicalDeviceMultiDrawFeaturesEXT {
builder<'a>() -> PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a>25757     pub fn builder<'a>() -> PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> {
25758         PhysicalDeviceMultiDrawFeaturesEXTBuilder {
25759             inner: Self::default(),
25760             marker: ::std::marker::PhantomData,
25761         }
25762     }
25763 }
25764 #[repr(transparent)]
25765 pub struct PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> {
25766     inner: PhysicalDeviceMultiDrawFeaturesEXT,
25767     marker: ::std::marker::PhantomData<&'a ()>,
25768 }
25769 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiDrawFeaturesEXTBuilder<'_> {}
25770 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiDrawFeaturesEXT {}
25771 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiDrawFeaturesEXTBuilder<'_> {}
25772 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiDrawFeaturesEXT {}
25773 impl<'a> ::std::ops::Deref for PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> {
25774     type Target = PhysicalDeviceMultiDrawFeaturesEXT;
deref(&self) -> &Self::Target25775     fn deref(&self) -> &Self::Target {
25776         &self.inner
25777     }
25778 }
25779 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target25780     fn deref_mut(&mut self) -> &mut Self::Target {
25781         &mut self.inner
25782     }
25783 }
25784 impl<'a> PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> {
25785     #[inline]
multi_draw(mut self, multi_draw: bool) -> Self25786     pub fn multi_draw(mut self, multi_draw: bool) -> Self {
25787         self.inner.multi_draw = multi_draw.into();
25788         self
25789     }
25790     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25791     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25792     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMultiDrawFeaturesEXT25793     pub fn build(self) -> PhysicalDeviceMultiDrawFeaturesEXT {
25794         self.inner
25795     }
25796 }
25797 #[repr(C)]
25798 #[cfg_attr(feature = "debug", derive(Debug))]
25799 #[derive(Copy, Clone)]
25800 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT.html>"]
25801 pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
25802     pub s_type: StructureType,
25803     pub p_next: *mut c_void,
25804     pub advanced_blend_max_color_attachments: u32,
25805     pub advanced_blend_independent_blend: Bool32,
25806     pub advanced_blend_non_premultiplied_src_color: Bool32,
25807     pub advanced_blend_non_premultiplied_dst_color: Bool32,
25808     pub advanced_blend_correlated_overlap: Bool32,
25809     pub advanced_blend_all_operations: Bool32,
25810 }
25811 impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
25812     #[inline]
default() -> Self25813     fn default() -> Self {
25814         Self {
25815             s_type: Self::STRUCTURE_TYPE,
25816             p_next: ::std::ptr::null_mut(),
25817             advanced_blend_max_color_attachments: u32::default(),
25818             advanced_blend_independent_blend: Bool32::default(),
25819             advanced_blend_non_premultiplied_src_color: Bool32::default(),
25820             advanced_blend_non_premultiplied_dst_color: Bool32::default(),
25821             advanced_blend_correlated_overlap: Bool32::default(),
25822             advanced_blend_all_operations: Bool32::default(),
25823         }
25824     }
25825 }
25826 unsafe impl TaggedStructure for PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
25827     const STRUCTURE_TYPE: StructureType =
25828         StructureType::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT;
25829 }
25830 impl PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
builder<'a>() -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a>25831     pub fn builder<'a>() -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
25832         PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder {
25833             inner: Self::default(),
25834             marker: ::std::marker::PhantomData,
25835         }
25836     }
25837 }
25838 #[repr(transparent)]
25839 pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
25840     inner: PhysicalDeviceBlendOperationAdvancedPropertiesEXT,
25841     marker: ::std::marker::PhantomData<&'a ()>,
25842 }
25843 unsafe impl ExtendsPhysicalDeviceProperties2
25844     for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'_>
25845 {
25846 }
25847 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceBlendOperationAdvancedPropertiesEXT {}
25848 impl<'a> ::std::ops::Deref for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
25849     type Target = PhysicalDeviceBlendOperationAdvancedPropertiesEXT;
deref(&self) -> &Self::Target25850     fn deref(&self) -> &Self::Target {
25851         &self.inner
25852     }
25853 }
25854 impl<'a> ::std::ops::DerefMut for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target25855     fn deref_mut(&mut self) -> &mut Self::Target {
25856         &mut self.inner
25857     }
25858 }
25859 impl<'a> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
25860     #[inline]
advanced_blend_max_color_attachments( mut self, advanced_blend_max_color_attachments: u32, ) -> Self25861     pub fn advanced_blend_max_color_attachments(
25862         mut self,
25863         advanced_blend_max_color_attachments: u32,
25864     ) -> Self {
25865         self.inner.advanced_blend_max_color_attachments = advanced_blend_max_color_attachments;
25866         self
25867     }
25868     #[inline]
advanced_blend_independent_blend( mut self, advanced_blend_independent_blend: bool, ) -> Self25869     pub fn advanced_blend_independent_blend(
25870         mut self,
25871         advanced_blend_independent_blend: bool,
25872     ) -> Self {
25873         self.inner.advanced_blend_independent_blend = advanced_blend_independent_blend.into();
25874         self
25875     }
25876     #[inline]
advanced_blend_non_premultiplied_src_color( mut self, advanced_blend_non_premultiplied_src_color: bool, ) -> Self25877     pub fn advanced_blend_non_premultiplied_src_color(
25878         mut self,
25879         advanced_blend_non_premultiplied_src_color: bool,
25880     ) -> Self {
25881         self.inner.advanced_blend_non_premultiplied_src_color =
25882             advanced_blend_non_premultiplied_src_color.into();
25883         self
25884     }
25885     #[inline]
advanced_blend_non_premultiplied_dst_color( mut self, advanced_blend_non_premultiplied_dst_color: bool, ) -> Self25886     pub fn advanced_blend_non_premultiplied_dst_color(
25887         mut self,
25888         advanced_blend_non_premultiplied_dst_color: bool,
25889     ) -> Self {
25890         self.inner.advanced_blend_non_premultiplied_dst_color =
25891             advanced_blend_non_premultiplied_dst_color.into();
25892         self
25893     }
25894     #[inline]
advanced_blend_correlated_overlap( mut self, advanced_blend_correlated_overlap: bool, ) -> Self25895     pub fn advanced_blend_correlated_overlap(
25896         mut self,
25897         advanced_blend_correlated_overlap: bool,
25898     ) -> Self {
25899         self.inner.advanced_blend_correlated_overlap = advanced_blend_correlated_overlap.into();
25900         self
25901     }
25902     #[inline]
advanced_blend_all_operations(mut self, advanced_blend_all_operations: bool) -> Self25903     pub fn advanced_blend_all_operations(mut self, advanced_blend_all_operations: bool) -> Self {
25904         self.inner.advanced_blend_all_operations = advanced_blend_all_operations.into();
25905         self
25906     }
25907     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25908     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25909     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXT25910     pub fn build(self) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
25911         self.inner
25912     }
25913 }
25914 #[repr(C)]
25915 #[cfg_attr(feature = "debug", derive(Debug))]
25916 #[derive(Copy, Clone)]
25917 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineColorBlendAdvancedStateCreateInfoEXT.html>"]
25918 pub struct PipelineColorBlendAdvancedStateCreateInfoEXT {
25919     pub s_type: StructureType,
25920     pub p_next: *const c_void,
25921     pub src_premultiplied: Bool32,
25922     pub dst_premultiplied: Bool32,
25923     pub blend_overlap: BlendOverlapEXT,
25924 }
25925 impl ::std::default::Default for PipelineColorBlendAdvancedStateCreateInfoEXT {
25926     #[inline]
default() -> Self25927     fn default() -> Self {
25928         Self {
25929             s_type: Self::STRUCTURE_TYPE,
25930             p_next: ::std::ptr::null(),
25931             src_premultiplied: Bool32::default(),
25932             dst_premultiplied: Bool32::default(),
25933             blend_overlap: BlendOverlapEXT::default(),
25934         }
25935     }
25936 }
25937 unsafe impl TaggedStructure for PipelineColorBlendAdvancedStateCreateInfoEXT {
25938     const STRUCTURE_TYPE: StructureType =
25939         StructureType::PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT;
25940 }
25941 impl PipelineColorBlendAdvancedStateCreateInfoEXT {
builder<'a>() -> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a>25942     pub fn builder<'a>() -> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
25943         PipelineColorBlendAdvancedStateCreateInfoEXTBuilder {
25944             inner: Self::default(),
25945             marker: ::std::marker::PhantomData,
25946         }
25947     }
25948 }
25949 #[repr(transparent)]
25950 pub struct PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
25951     inner: PipelineColorBlendAdvancedStateCreateInfoEXT,
25952     marker: ::std::marker::PhantomData<&'a ()>,
25953 }
25954 unsafe impl ExtendsPipelineColorBlendStateCreateInfo
25955     for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'_>
25956 {
25957 }
25958 unsafe impl ExtendsPipelineColorBlendStateCreateInfo
25959     for PipelineColorBlendAdvancedStateCreateInfoEXT
25960 {
25961 }
25962 impl<'a> ::std::ops::Deref for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
25963     type Target = PipelineColorBlendAdvancedStateCreateInfoEXT;
deref(&self) -> &Self::Target25964     fn deref(&self) -> &Self::Target {
25965         &self.inner
25966     }
25967 }
25968 impl<'a> ::std::ops::DerefMut for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target25969     fn deref_mut(&mut self) -> &mut Self::Target {
25970         &mut self.inner
25971     }
25972 }
25973 impl<'a> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
25974     #[inline]
src_premultiplied(mut self, src_premultiplied: bool) -> Self25975     pub fn src_premultiplied(mut self, src_premultiplied: bool) -> Self {
25976         self.inner.src_premultiplied = src_premultiplied.into();
25977         self
25978     }
25979     #[inline]
dst_premultiplied(mut self, dst_premultiplied: bool) -> Self25980     pub fn dst_premultiplied(mut self, dst_premultiplied: bool) -> Self {
25981         self.inner.dst_premultiplied = dst_premultiplied.into();
25982         self
25983     }
25984     #[inline]
blend_overlap(mut self, blend_overlap: BlendOverlapEXT) -> Self25985     pub fn blend_overlap(mut self, blend_overlap: BlendOverlapEXT) -> Self {
25986         self.inner.blend_overlap = blend_overlap;
25987         self
25988     }
25989     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25990     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25991     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineColorBlendAdvancedStateCreateInfoEXT25992     pub fn build(self) -> PipelineColorBlendAdvancedStateCreateInfoEXT {
25993         self.inner
25994     }
25995 }
25996 #[repr(C)]
25997 #[cfg_attr(feature = "debug", derive(Debug))]
25998 #[derive(Copy, Clone)]
25999 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceInlineUniformBlockFeatures.html>"]
26000 pub struct PhysicalDeviceInlineUniformBlockFeatures {
26001     pub s_type: StructureType,
26002     pub p_next: *mut c_void,
26003     pub inline_uniform_block: Bool32,
26004     pub descriptor_binding_inline_uniform_block_update_after_bind: Bool32,
26005 }
26006 impl ::std::default::Default for PhysicalDeviceInlineUniformBlockFeatures {
26007     #[inline]
default() -> Self26008     fn default() -> Self {
26009         Self {
26010             s_type: Self::STRUCTURE_TYPE,
26011             p_next: ::std::ptr::null_mut(),
26012             inline_uniform_block: Bool32::default(),
26013             descriptor_binding_inline_uniform_block_update_after_bind: Bool32::default(),
26014         }
26015     }
26016 }
26017 unsafe impl TaggedStructure for PhysicalDeviceInlineUniformBlockFeatures {
26018     const STRUCTURE_TYPE: StructureType =
26019         StructureType::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
26020 }
26021 impl PhysicalDeviceInlineUniformBlockFeatures {
builder<'a>() -> PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a>26022     pub fn builder<'a>() -> PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> {
26023         PhysicalDeviceInlineUniformBlockFeaturesBuilder {
26024             inner: Self::default(),
26025             marker: ::std::marker::PhantomData,
26026         }
26027     }
26028 }
26029 #[repr(transparent)]
26030 pub struct PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> {
26031     inner: PhysicalDeviceInlineUniformBlockFeatures,
26032     marker: ::std::marker::PhantomData<&'a ()>,
26033 }
26034 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'_> {}
26035 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInlineUniformBlockFeatures {}
26036 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'_> {}
26037 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeatures {}
26038 impl<'a> ::std::ops::Deref for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> {
26039     type Target = PhysicalDeviceInlineUniformBlockFeatures;
deref(&self) -> &Self::Target26040     fn deref(&self) -> &Self::Target {
26041         &self.inner
26042     }
26043 }
26044 impl<'a> ::std::ops::DerefMut for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target26045     fn deref_mut(&mut self) -> &mut Self::Target {
26046         &mut self.inner
26047     }
26048 }
26049 impl<'a> PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> {
26050     #[inline]
inline_uniform_block(mut self, inline_uniform_block: bool) -> Self26051     pub fn inline_uniform_block(mut self, inline_uniform_block: bool) -> Self {
26052         self.inner.inline_uniform_block = inline_uniform_block.into();
26053         self
26054     }
26055     #[inline]
descriptor_binding_inline_uniform_block_update_after_bind( mut self, descriptor_binding_inline_uniform_block_update_after_bind: bool, ) -> Self26056     pub fn descriptor_binding_inline_uniform_block_update_after_bind(
26057         mut self,
26058         descriptor_binding_inline_uniform_block_update_after_bind: bool,
26059     ) -> Self {
26060         self.inner
26061             .descriptor_binding_inline_uniform_block_update_after_bind =
26062             descriptor_binding_inline_uniform_block_update_after_bind.into();
26063         self
26064     }
26065     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26066     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26067     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceInlineUniformBlockFeatures26068     pub fn build(self) -> PhysicalDeviceInlineUniformBlockFeatures {
26069         self.inner
26070     }
26071 }
26072 #[repr(C)]
26073 #[cfg_attr(feature = "debug", derive(Debug))]
26074 #[derive(Copy, Clone)]
26075 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceInlineUniformBlockProperties.html>"]
26076 pub struct PhysicalDeviceInlineUniformBlockProperties {
26077     pub s_type: StructureType,
26078     pub p_next: *mut c_void,
26079     pub max_inline_uniform_block_size: u32,
26080     pub max_per_stage_descriptor_inline_uniform_blocks: u32,
26081     pub max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32,
26082     pub max_descriptor_set_inline_uniform_blocks: u32,
26083     pub max_descriptor_set_update_after_bind_inline_uniform_blocks: u32,
26084 }
26085 impl ::std::default::Default for PhysicalDeviceInlineUniformBlockProperties {
26086     #[inline]
default() -> Self26087     fn default() -> Self {
26088         Self {
26089             s_type: Self::STRUCTURE_TYPE,
26090             p_next: ::std::ptr::null_mut(),
26091             max_inline_uniform_block_size: u32::default(),
26092             max_per_stage_descriptor_inline_uniform_blocks: u32::default(),
26093             max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32::default(),
26094             max_descriptor_set_inline_uniform_blocks: u32::default(),
26095             max_descriptor_set_update_after_bind_inline_uniform_blocks: u32::default(),
26096         }
26097     }
26098 }
26099 unsafe impl TaggedStructure for PhysicalDeviceInlineUniformBlockProperties {
26100     const STRUCTURE_TYPE: StructureType =
26101         StructureType::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
26102 }
26103 impl PhysicalDeviceInlineUniformBlockProperties {
builder<'a>() -> PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a>26104     pub fn builder<'a>() -> PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> {
26105         PhysicalDeviceInlineUniformBlockPropertiesBuilder {
26106             inner: Self::default(),
26107             marker: ::std::marker::PhantomData,
26108         }
26109     }
26110 }
26111 #[repr(transparent)]
26112 pub struct PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> {
26113     inner: PhysicalDeviceInlineUniformBlockProperties,
26114     marker: ::std::marker::PhantomData<&'a ()>,
26115 }
26116 unsafe impl ExtendsPhysicalDeviceProperties2
26117     for PhysicalDeviceInlineUniformBlockPropertiesBuilder<'_>
26118 {
26119 }
26120 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceInlineUniformBlockProperties {}
26121 impl<'a> ::std::ops::Deref for PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> {
26122     type Target = PhysicalDeviceInlineUniformBlockProperties;
deref(&self) -> &Self::Target26123     fn deref(&self) -> &Self::Target {
26124         &self.inner
26125     }
26126 }
26127 impl<'a> ::std::ops::DerefMut for PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target26128     fn deref_mut(&mut self) -> &mut Self::Target {
26129         &mut self.inner
26130     }
26131 }
26132 impl<'a> PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> {
26133     #[inline]
max_inline_uniform_block_size(mut self, max_inline_uniform_block_size: u32) -> Self26134     pub fn max_inline_uniform_block_size(mut self, max_inline_uniform_block_size: u32) -> Self {
26135         self.inner.max_inline_uniform_block_size = max_inline_uniform_block_size;
26136         self
26137     }
26138     #[inline]
max_per_stage_descriptor_inline_uniform_blocks( mut self, max_per_stage_descriptor_inline_uniform_blocks: u32, ) -> Self26139     pub fn max_per_stage_descriptor_inline_uniform_blocks(
26140         mut self,
26141         max_per_stage_descriptor_inline_uniform_blocks: u32,
26142     ) -> Self {
26143         self.inner.max_per_stage_descriptor_inline_uniform_blocks =
26144             max_per_stage_descriptor_inline_uniform_blocks;
26145         self
26146     }
26147     #[inline]
max_per_stage_descriptor_update_after_bind_inline_uniform_blocks( mut self, max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32, ) -> Self26148     pub fn max_per_stage_descriptor_update_after_bind_inline_uniform_blocks(
26149         mut self,
26150         max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32,
26151     ) -> Self {
26152         self.inner
26153             .max_per_stage_descriptor_update_after_bind_inline_uniform_blocks =
26154             max_per_stage_descriptor_update_after_bind_inline_uniform_blocks;
26155         self
26156     }
26157     #[inline]
max_descriptor_set_inline_uniform_blocks( mut self, max_descriptor_set_inline_uniform_blocks: u32, ) -> Self26158     pub fn max_descriptor_set_inline_uniform_blocks(
26159         mut self,
26160         max_descriptor_set_inline_uniform_blocks: u32,
26161     ) -> Self {
26162         self.inner.max_descriptor_set_inline_uniform_blocks =
26163             max_descriptor_set_inline_uniform_blocks;
26164         self
26165     }
26166     #[inline]
max_descriptor_set_update_after_bind_inline_uniform_blocks( mut self, max_descriptor_set_update_after_bind_inline_uniform_blocks: u32, ) -> Self26167     pub fn max_descriptor_set_update_after_bind_inline_uniform_blocks(
26168         mut self,
26169         max_descriptor_set_update_after_bind_inline_uniform_blocks: u32,
26170     ) -> Self {
26171         self.inner
26172             .max_descriptor_set_update_after_bind_inline_uniform_blocks =
26173             max_descriptor_set_update_after_bind_inline_uniform_blocks;
26174         self
26175     }
26176     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26177     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26178     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceInlineUniformBlockProperties26179     pub fn build(self) -> PhysicalDeviceInlineUniformBlockProperties {
26180         self.inner
26181     }
26182 }
26183 #[repr(C)]
26184 #[cfg_attr(feature = "debug", derive(Debug))]
26185 #[derive(Copy, Clone)]
26186 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWriteDescriptorSetInlineUniformBlock.html>"]
26187 pub struct WriteDescriptorSetInlineUniformBlock {
26188     pub s_type: StructureType,
26189     pub p_next: *const c_void,
26190     pub data_size: u32,
26191     pub p_data: *const c_void,
26192 }
26193 impl ::std::default::Default for WriteDescriptorSetInlineUniformBlock {
26194     #[inline]
default() -> Self26195     fn default() -> Self {
26196         Self {
26197             s_type: Self::STRUCTURE_TYPE,
26198             p_next: ::std::ptr::null(),
26199             data_size: u32::default(),
26200             p_data: ::std::ptr::null(),
26201         }
26202     }
26203 }
26204 unsafe impl TaggedStructure for WriteDescriptorSetInlineUniformBlock {
26205     const STRUCTURE_TYPE: StructureType = StructureType::WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK;
26206 }
26207 impl WriteDescriptorSetInlineUniformBlock {
builder<'a>() -> WriteDescriptorSetInlineUniformBlockBuilder<'a>26208     pub fn builder<'a>() -> WriteDescriptorSetInlineUniformBlockBuilder<'a> {
26209         WriteDescriptorSetInlineUniformBlockBuilder {
26210             inner: Self::default(),
26211             marker: ::std::marker::PhantomData,
26212         }
26213     }
26214 }
26215 #[repr(transparent)]
26216 pub struct WriteDescriptorSetInlineUniformBlockBuilder<'a> {
26217     inner: WriteDescriptorSetInlineUniformBlock,
26218     marker: ::std::marker::PhantomData<&'a ()>,
26219 }
26220 unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetInlineUniformBlockBuilder<'_> {}
26221 unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetInlineUniformBlock {}
26222 impl<'a> ::std::ops::Deref for WriteDescriptorSetInlineUniformBlockBuilder<'a> {
26223     type Target = WriteDescriptorSetInlineUniformBlock;
deref(&self) -> &Self::Target26224     fn deref(&self) -> &Self::Target {
26225         &self.inner
26226     }
26227 }
26228 impl<'a> ::std::ops::DerefMut for WriteDescriptorSetInlineUniformBlockBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target26229     fn deref_mut(&mut self) -> &mut Self::Target {
26230         &mut self.inner
26231     }
26232 }
26233 impl<'a> WriteDescriptorSetInlineUniformBlockBuilder<'a> {
26234     #[inline]
data(mut self, data: &'a [u8]) -> Self26235     pub fn data(mut self, data: &'a [u8]) -> Self {
26236         self.inner.data_size = data.len() as _;
26237         self.inner.p_data = data.as_ptr().cast();
26238         self
26239     }
26240     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26241     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26242     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> WriteDescriptorSetInlineUniformBlock26243     pub fn build(self) -> WriteDescriptorSetInlineUniformBlock {
26244         self.inner
26245     }
26246 }
26247 #[repr(C)]
26248 #[cfg_attr(feature = "debug", derive(Debug))]
26249 #[derive(Copy, Clone)]
26250 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPoolInlineUniformBlockCreateInfo.html>"]
26251 pub struct DescriptorPoolInlineUniformBlockCreateInfo {
26252     pub s_type: StructureType,
26253     pub p_next: *const c_void,
26254     pub max_inline_uniform_block_bindings: u32,
26255 }
26256 impl ::std::default::Default for DescriptorPoolInlineUniformBlockCreateInfo {
26257     #[inline]
default() -> Self26258     fn default() -> Self {
26259         Self {
26260             s_type: Self::STRUCTURE_TYPE,
26261             p_next: ::std::ptr::null(),
26262             max_inline_uniform_block_bindings: u32::default(),
26263         }
26264     }
26265 }
26266 unsafe impl TaggedStructure for DescriptorPoolInlineUniformBlockCreateInfo {
26267     const STRUCTURE_TYPE: StructureType =
26268         StructureType::DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO;
26269 }
26270 impl DescriptorPoolInlineUniformBlockCreateInfo {
builder<'a>() -> DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a>26271     pub fn builder<'a>() -> DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> {
26272         DescriptorPoolInlineUniformBlockCreateInfoBuilder {
26273             inner: Self::default(),
26274             marker: ::std::marker::PhantomData,
26275         }
26276     }
26277 }
26278 #[repr(transparent)]
26279 pub struct DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> {
26280     inner: DescriptorPoolInlineUniformBlockCreateInfo,
26281     marker: ::std::marker::PhantomData<&'a ()>,
26282 }
26283 unsafe impl ExtendsDescriptorPoolCreateInfo
26284     for DescriptorPoolInlineUniformBlockCreateInfoBuilder<'_>
26285 {
26286 }
26287 unsafe impl ExtendsDescriptorPoolCreateInfo for DescriptorPoolInlineUniformBlockCreateInfo {}
26288 impl<'a> ::std::ops::Deref for DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> {
26289     type Target = DescriptorPoolInlineUniformBlockCreateInfo;
deref(&self) -> &Self::Target26290     fn deref(&self) -> &Self::Target {
26291         &self.inner
26292     }
26293 }
26294 impl<'a> ::std::ops::DerefMut for DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target26295     fn deref_mut(&mut self) -> &mut Self::Target {
26296         &mut self.inner
26297     }
26298 }
26299 impl<'a> DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> {
26300     #[inline]
max_inline_uniform_block_bindings( mut self, max_inline_uniform_block_bindings: u32, ) -> Self26301     pub fn max_inline_uniform_block_bindings(
26302         mut self,
26303         max_inline_uniform_block_bindings: u32,
26304     ) -> Self {
26305         self.inner.max_inline_uniform_block_bindings = max_inline_uniform_block_bindings;
26306         self
26307     }
26308     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26309     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26310     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorPoolInlineUniformBlockCreateInfo26311     pub fn build(self) -> DescriptorPoolInlineUniformBlockCreateInfo {
26312         self.inner
26313     }
26314 }
26315 #[repr(C)]
26316 #[cfg_attr(feature = "debug", derive(Debug))]
26317 #[derive(Copy, Clone)]
26318 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageModulationStateCreateInfoNV.html>"]
26319 pub struct PipelineCoverageModulationStateCreateInfoNV {
26320     pub s_type: StructureType,
26321     pub p_next: *const c_void,
26322     pub flags: PipelineCoverageModulationStateCreateFlagsNV,
26323     pub coverage_modulation_mode: CoverageModulationModeNV,
26324     pub coverage_modulation_table_enable: Bool32,
26325     pub coverage_modulation_table_count: u32,
26326     pub p_coverage_modulation_table: *const f32,
26327 }
26328 impl ::std::default::Default for PipelineCoverageModulationStateCreateInfoNV {
26329     #[inline]
default() -> Self26330     fn default() -> Self {
26331         Self {
26332             s_type: Self::STRUCTURE_TYPE,
26333             p_next: ::std::ptr::null(),
26334             flags: PipelineCoverageModulationStateCreateFlagsNV::default(),
26335             coverage_modulation_mode: CoverageModulationModeNV::default(),
26336             coverage_modulation_table_enable: Bool32::default(),
26337             coverage_modulation_table_count: u32::default(),
26338             p_coverage_modulation_table: ::std::ptr::null(),
26339         }
26340     }
26341 }
26342 unsafe impl TaggedStructure for PipelineCoverageModulationStateCreateInfoNV {
26343     const STRUCTURE_TYPE: StructureType =
26344         StructureType::PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV;
26345 }
26346 impl PipelineCoverageModulationStateCreateInfoNV {
builder<'a>() -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a>26347     pub fn builder<'a>() -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
26348         PipelineCoverageModulationStateCreateInfoNVBuilder {
26349             inner: Self::default(),
26350             marker: ::std::marker::PhantomData,
26351         }
26352     }
26353 }
26354 #[repr(transparent)]
26355 pub struct PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
26356     inner: PipelineCoverageModulationStateCreateInfoNV,
26357     marker: ::std::marker::PhantomData<&'a ()>,
26358 }
26359 unsafe impl ExtendsPipelineMultisampleStateCreateInfo
26360     for PipelineCoverageModulationStateCreateInfoNVBuilder<'_>
26361 {
26362 }
26363 unsafe impl ExtendsPipelineMultisampleStateCreateInfo
26364     for PipelineCoverageModulationStateCreateInfoNV
26365 {
26366 }
26367 impl<'a> ::std::ops::Deref for PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
26368     type Target = PipelineCoverageModulationStateCreateInfoNV;
deref(&self) -> &Self::Target26369     fn deref(&self) -> &Self::Target {
26370         &self.inner
26371     }
26372 }
26373 impl<'a> ::std::ops::DerefMut for PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target26374     fn deref_mut(&mut self) -> &mut Self::Target {
26375         &mut self.inner
26376     }
26377 }
26378 impl<'a> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
26379     #[inline]
flags(mut self, flags: PipelineCoverageModulationStateCreateFlagsNV) -> Self26380     pub fn flags(mut self, flags: PipelineCoverageModulationStateCreateFlagsNV) -> Self {
26381         self.inner.flags = flags;
26382         self
26383     }
26384     #[inline]
coverage_modulation_mode( mut self, coverage_modulation_mode: CoverageModulationModeNV, ) -> Self26385     pub fn coverage_modulation_mode(
26386         mut self,
26387         coverage_modulation_mode: CoverageModulationModeNV,
26388     ) -> Self {
26389         self.inner.coverage_modulation_mode = coverage_modulation_mode;
26390         self
26391     }
26392     #[inline]
coverage_modulation_table_enable( mut self, coverage_modulation_table_enable: bool, ) -> Self26393     pub fn coverage_modulation_table_enable(
26394         mut self,
26395         coverage_modulation_table_enable: bool,
26396     ) -> Self {
26397         self.inner.coverage_modulation_table_enable = coverage_modulation_table_enable.into();
26398         self
26399     }
26400     #[inline]
coverage_modulation_table(mut self, coverage_modulation_table: &'a [f32]) -> Self26401     pub fn coverage_modulation_table(mut self, coverage_modulation_table: &'a [f32]) -> Self {
26402         self.inner.coverage_modulation_table_count = coverage_modulation_table.len() as _;
26403         self.inner.p_coverage_modulation_table = coverage_modulation_table.as_ptr();
26404         self
26405     }
26406     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26407     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26408     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineCoverageModulationStateCreateInfoNV26409     pub fn build(self) -> PipelineCoverageModulationStateCreateInfoNV {
26410         self.inner
26411     }
26412 }
26413 #[repr(C)]
26414 #[cfg_attr(feature = "debug", derive(Debug))]
26415 #[derive(Copy, Clone)]
26416 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageFormatListCreateInfo.html>"]
26417 pub struct ImageFormatListCreateInfo {
26418     pub s_type: StructureType,
26419     pub p_next: *const c_void,
26420     pub view_format_count: u32,
26421     pub p_view_formats: *const Format,
26422 }
26423 impl ::std::default::Default for ImageFormatListCreateInfo {
26424     #[inline]
default() -> Self26425     fn default() -> Self {
26426         Self {
26427             s_type: Self::STRUCTURE_TYPE,
26428             p_next: ::std::ptr::null(),
26429             view_format_count: u32::default(),
26430             p_view_formats: ::std::ptr::null(),
26431         }
26432     }
26433 }
26434 unsafe impl TaggedStructure for ImageFormatListCreateInfo {
26435     const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_FORMAT_LIST_CREATE_INFO;
26436 }
26437 impl ImageFormatListCreateInfo {
builder<'a>() -> ImageFormatListCreateInfoBuilder<'a>26438     pub fn builder<'a>() -> ImageFormatListCreateInfoBuilder<'a> {
26439         ImageFormatListCreateInfoBuilder {
26440             inner: Self::default(),
26441             marker: ::std::marker::PhantomData,
26442         }
26443     }
26444 }
26445 #[repr(transparent)]
26446 pub struct ImageFormatListCreateInfoBuilder<'a> {
26447     inner: ImageFormatListCreateInfo,
26448     marker: ::std::marker::PhantomData<&'a ()>,
26449 }
26450 unsafe impl ExtendsImageCreateInfo for ImageFormatListCreateInfoBuilder<'_> {}
26451 unsafe impl ExtendsImageCreateInfo for ImageFormatListCreateInfo {}
26452 unsafe impl ExtendsSwapchainCreateInfoKHR for ImageFormatListCreateInfoBuilder<'_> {}
26453 unsafe impl ExtendsSwapchainCreateInfoKHR for ImageFormatListCreateInfo {}
26454 unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageFormatListCreateInfoBuilder<'_> {}
26455 unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageFormatListCreateInfo {}
26456 impl<'a> ::std::ops::Deref for ImageFormatListCreateInfoBuilder<'a> {
26457     type Target = ImageFormatListCreateInfo;
deref(&self) -> &Self::Target26458     fn deref(&self) -> &Self::Target {
26459         &self.inner
26460     }
26461 }
26462 impl<'a> ::std::ops::DerefMut for ImageFormatListCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target26463     fn deref_mut(&mut self) -> &mut Self::Target {
26464         &mut self.inner
26465     }
26466 }
26467 impl<'a> ImageFormatListCreateInfoBuilder<'a> {
26468     #[inline]
view_formats(mut self, view_formats: &'a [Format]) -> Self26469     pub fn view_formats(mut self, view_formats: &'a [Format]) -> Self {
26470         self.inner.view_format_count = view_formats.len() as _;
26471         self.inner.p_view_formats = view_formats.as_ptr();
26472         self
26473     }
26474     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26475     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26476     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageFormatListCreateInfo26477     pub fn build(self) -> ImageFormatListCreateInfo {
26478         self.inner
26479     }
26480 }
26481 #[repr(C)]
26482 #[cfg_attr(feature = "debug", derive(Debug))]
26483 #[derive(Copy, Clone)]
26484 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationCacheCreateInfoEXT.html>"]
26485 pub struct ValidationCacheCreateInfoEXT {
26486     pub s_type: StructureType,
26487     pub p_next: *const c_void,
26488     pub flags: ValidationCacheCreateFlagsEXT,
26489     pub initial_data_size: usize,
26490     pub p_initial_data: *const c_void,
26491 }
26492 impl ::std::default::Default for ValidationCacheCreateInfoEXT {
26493     #[inline]
default() -> Self26494     fn default() -> Self {
26495         Self {
26496             s_type: Self::STRUCTURE_TYPE,
26497             p_next: ::std::ptr::null(),
26498             flags: ValidationCacheCreateFlagsEXT::default(),
26499             initial_data_size: usize::default(),
26500             p_initial_data: ::std::ptr::null(),
26501         }
26502     }
26503 }
26504 unsafe impl TaggedStructure for ValidationCacheCreateInfoEXT {
26505     const STRUCTURE_TYPE: StructureType = StructureType::VALIDATION_CACHE_CREATE_INFO_EXT;
26506 }
26507 impl ValidationCacheCreateInfoEXT {
builder<'a>() -> ValidationCacheCreateInfoEXTBuilder<'a>26508     pub fn builder<'a>() -> ValidationCacheCreateInfoEXTBuilder<'a> {
26509         ValidationCacheCreateInfoEXTBuilder {
26510             inner: Self::default(),
26511             marker: ::std::marker::PhantomData,
26512         }
26513     }
26514 }
26515 #[repr(transparent)]
26516 pub struct ValidationCacheCreateInfoEXTBuilder<'a> {
26517     inner: ValidationCacheCreateInfoEXT,
26518     marker: ::std::marker::PhantomData<&'a ()>,
26519 }
26520 impl<'a> ::std::ops::Deref for ValidationCacheCreateInfoEXTBuilder<'a> {
26521     type Target = ValidationCacheCreateInfoEXT;
deref(&self) -> &Self::Target26522     fn deref(&self) -> &Self::Target {
26523         &self.inner
26524     }
26525 }
26526 impl<'a> ::std::ops::DerefMut for ValidationCacheCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target26527     fn deref_mut(&mut self) -> &mut Self::Target {
26528         &mut self.inner
26529     }
26530 }
26531 impl<'a> ValidationCacheCreateInfoEXTBuilder<'a> {
26532     #[inline]
flags(mut self, flags: ValidationCacheCreateFlagsEXT) -> Self26533     pub fn flags(mut self, flags: ValidationCacheCreateFlagsEXT) -> Self {
26534         self.inner.flags = flags;
26535         self
26536     }
26537     #[inline]
initial_data(mut self, initial_data: &'a [u8]) -> Self26538     pub fn initial_data(mut self, initial_data: &'a [u8]) -> Self {
26539         self.inner.initial_data_size = initial_data.len();
26540         self.inner.p_initial_data = initial_data.as_ptr().cast();
26541         self
26542     }
26543     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26544     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26545     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ValidationCacheCreateInfoEXT26546     pub fn build(self) -> ValidationCacheCreateInfoEXT {
26547         self.inner
26548     }
26549 }
26550 #[repr(C)]
26551 #[cfg_attr(feature = "debug", derive(Debug))]
26552 #[derive(Copy, Clone)]
26553 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderModuleValidationCacheCreateInfoEXT.html>"]
26554 pub struct ShaderModuleValidationCacheCreateInfoEXT {
26555     pub s_type: StructureType,
26556     pub p_next: *const c_void,
26557     pub validation_cache: ValidationCacheEXT,
26558 }
26559 impl ::std::default::Default for ShaderModuleValidationCacheCreateInfoEXT {
26560     #[inline]
default() -> Self26561     fn default() -> Self {
26562         Self {
26563             s_type: Self::STRUCTURE_TYPE,
26564             p_next: ::std::ptr::null(),
26565             validation_cache: ValidationCacheEXT::default(),
26566         }
26567     }
26568 }
26569 unsafe impl TaggedStructure for ShaderModuleValidationCacheCreateInfoEXT {
26570     const STRUCTURE_TYPE: StructureType =
26571         StructureType::SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT;
26572 }
26573 impl ShaderModuleValidationCacheCreateInfoEXT {
builder<'a>() -> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a>26574     pub fn builder<'a>() -> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
26575         ShaderModuleValidationCacheCreateInfoEXTBuilder {
26576             inner: Self::default(),
26577             marker: ::std::marker::PhantomData,
26578         }
26579     }
26580 }
26581 #[repr(transparent)]
26582 pub struct ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
26583     inner: ShaderModuleValidationCacheCreateInfoEXT,
26584     marker: ::std::marker::PhantomData<&'a ()>,
26585 }
26586 unsafe impl ExtendsShaderModuleCreateInfo for ShaderModuleValidationCacheCreateInfoEXTBuilder<'_> {}
26587 unsafe impl ExtendsShaderModuleCreateInfo for ShaderModuleValidationCacheCreateInfoEXT {}
26588 unsafe impl ExtendsPipelineShaderStageCreateInfo
26589     for ShaderModuleValidationCacheCreateInfoEXTBuilder<'_>
26590 {
26591 }
26592 unsafe impl ExtendsPipelineShaderStageCreateInfo for ShaderModuleValidationCacheCreateInfoEXT {}
26593 impl<'a> ::std::ops::Deref for ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
26594     type Target = ShaderModuleValidationCacheCreateInfoEXT;
deref(&self) -> &Self::Target26595     fn deref(&self) -> &Self::Target {
26596         &self.inner
26597     }
26598 }
26599 impl<'a> ::std::ops::DerefMut for ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target26600     fn deref_mut(&mut self) -> &mut Self::Target {
26601         &mut self.inner
26602     }
26603 }
26604 impl<'a> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
26605     #[inline]
validation_cache(mut self, validation_cache: ValidationCacheEXT) -> Self26606     pub fn validation_cache(mut self, validation_cache: ValidationCacheEXT) -> Self {
26607         self.inner.validation_cache = validation_cache;
26608         self
26609     }
26610     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26611     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26612     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ShaderModuleValidationCacheCreateInfoEXT26613     pub fn build(self) -> ShaderModuleValidationCacheCreateInfoEXT {
26614         self.inner
26615     }
26616 }
26617 #[repr(C)]
26618 #[cfg_attr(feature = "debug", derive(Debug))]
26619 #[derive(Copy, Clone)]
26620 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMaintenance3Properties.html>"]
26621 pub struct PhysicalDeviceMaintenance3Properties {
26622     pub s_type: StructureType,
26623     pub p_next: *mut c_void,
26624     pub max_per_set_descriptors: u32,
26625     pub max_memory_allocation_size: DeviceSize,
26626 }
26627 impl ::std::default::Default for PhysicalDeviceMaintenance3Properties {
26628     #[inline]
default() -> Self26629     fn default() -> Self {
26630         Self {
26631             s_type: Self::STRUCTURE_TYPE,
26632             p_next: ::std::ptr::null_mut(),
26633             max_per_set_descriptors: u32::default(),
26634             max_memory_allocation_size: DeviceSize::default(),
26635         }
26636     }
26637 }
26638 unsafe impl TaggedStructure for PhysicalDeviceMaintenance3Properties {
26639     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
26640 }
26641 impl PhysicalDeviceMaintenance3Properties {
builder<'a>() -> PhysicalDeviceMaintenance3PropertiesBuilder<'a>26642     pub fn builder<'a>() -> PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
26643         PhysicalDeviceMaintenance3PropertiesBuilder {
26644             inner: Self::default(),
26645             marker: ::std::marker::PhantomData,
26646         }
26647     }
26648 }
26649 #[repr(transparent)]
26650 pub struct PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
26651     inner: PhysicalDeviceMaintenance3Properties,
26652     marker: ::std::marker::PhantomData<&'a ()>,
26653 }
26654 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance3PropertiesBuilder<'_> {}
26655 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance3Properties {}
26656 impl<'a> ::std::ops::Deref for PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
26657     type Target = PhysicalDeviceMaintenance3Properties;
deref(&self) -> &Self::Target26658     fn deref(&self) -> &Self::Target {
26659         &self.inner
26660     }
26661 }
26662 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target26663     fn deref_mut(&mut self) -> &mut Self::Target {
26664         &mut self.inner
26665     }
26666 }
26667 impl<'a> PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
26668     #[inline]
max_per_set_descriptors(mut self, max_per_set_descriptors: u32) -> Self26669     pub fn max_per_set_descriptors(mut self, max_per_set_descriptors: u32) -> Self {
26670         self.inner.max_per_set_descriptors = max_per_set_descriptors;
26671         self
26672     }
26673     #[inline]
max_memory_allocation_size(mut self, max_memory_allocation_size: DeviceSize) -> Self26674     pub fn max_memory_allocation_size(mut self, max_memory_allocation_size: DeviceSize) -> Self {
26675         self.inner.max_memory_allocation_size = max_memory_allocation_size;
26676         self
26677     }
26678     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26679     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26680     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMaintenance3Properties26681     pub fn build(self) -> PhysicalDeviceMaintenance3Properties {
26682         self.inner
26683     }
26684 }
26685 #[repr(C)]
26686 #[cfg_attr(feature = "debug", derive(Debug))]
26687 #[derive(Copy, Clone)]
26688 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMaintenance4Features.html>"]
26689 pub struct PhysicalDeviceMaintenance4Features {
26690     pub s_type: StructureType,
26691     pub p_next: *mut c_void,
26692     pub maintenance4: Bool32,
26693 }
26694 impl ::std::default::Default for PhysicalDeviceMaintenance4Features {
26695     #[inline]
default() -> Self26696     fn default() -> Self {
26697         Self {
26698             s_type: Self::STRUCTURE_TYPE,
26699             p_next: ::std::ptr::null_mut(),
26700             maintenance4: Bool32::default(),
26701         }
26702     }
26703 }
26704 unsafe impl TaggedStructure for PhysicalDeviceMaintenance4Features {
26705     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
26706 }
26707 impl PhysicalDeviceMaintenance4Features {
builder<'a>() -> PhysicalDeviceMaintenance4FeaturesBuilder<'a>26708     pub fn builder<'a>() -> PhysicalDeviceMaintenance4FeaturesBuilder<'a> {
26709         PhysicalDeviceMaintenance4FeaturesBuilder {
26710             inner: Self::default(),
26711             marker: ::std::marker::PhantomData,
26712         }
26713     }
26714 }
26715 #[repr(transparent)]
26716 pub struct PhysicalDeviceMaintenance4FeaturesBuilder<'a> {
26717     inner: PhysicalDeviceMaintenance4Features,
26718     marker: ::std::marker::PhantomData<&'a ()>,
26719 }
26720 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMaintenance4FeaturesBuilder<'_> {}
26721 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMaintenance4Features {}
26722 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMaintenance4FeaturesBuilder<'_> {}
26723 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMaintenance4Features {}
26724 impl<'a> ::std::ops::Deref for PhysicalDeviceMaintenance4FeaturesBuilder<'a> {
26725     type Target = PhysicalDeviceMaintenance4Features;
deref(&self) -> &Self::Target26726     fn deref(&self) -> &Self::Target {
26727         &self.inner
26728     }
26729 }
26730 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMaintenance4FeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target26731     fn deref_mut(&mut self) -> &mut Self::Target {
26732         &mut self.inner
26733     }
26734 }
26735 impl<'a> PhysicalDeviceMaintenance4FeaturesBuilder<'a> {
26736     #[inline]
maintenance4(mut self, maintenance4: bool) -> Self26737     pub fn maintenance4(mut self, maintenance4: bool) -> Self {
26738         self.inner.maintenance4 = maintenance4.into();
26739         self
26740     }
26741     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26742     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26743     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMaintenance4Features26744     pub fn build(self) -> PhysicalDeviceMaintenance4Features {
26745         self.inner
26746     }
26747 }
26748 #[repr(C)]
26749 #[cfg_attr(feature = "debug", derive(Debug))]
26750 #[derive(Copy, Clone)]
26751 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMaintenance4Properties.html>"]
26752 pub struct PhysicalDeviceMaintenance4Properties {
26753     pub s_type: StructureType,
26754     pub p_next: *mut c_void,
26755     pub max_buffer_size: DeviceSize,
26756 }
26757 impl ::std::default::Default for PhysicalDeviceMaintenance4Properties {
26758     #[inline]
default() -> Self26759     fn default() -> Self {
26760         Self {
26761             s_type: Self::STRUCTURE_TYPE,
26762             p_next: ::std::ptr::null_mut(),
26763             max_buffer_size: DeviceSize::default(),
26764         }
26765     }
26766 }
26767 unsafe impl TaggedStructure for PhysicalDeviceMaintenance4Properties {
26768     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
26769 }
26770 impl PhysicalDeviceMaintenance4Properties {
builder<'a>() -> PhysicalDeviceMaintenance4PropertiesBuilder<'a>26771     pub fn builder<'a>() -> PhysicalDeviceMaintenance4PropertiesBuilder<'a> {
26772         PhysicalDeviceMaintenance4PropertiesBuilder {
26773             inner: Self::default(),
26774             marker: ::std::marker::PhantomData,
26775         }
26776     }
26777 }
26778 #[repr(transparent)]
26779 pub struct PhysicalDeviceMaintenance4PropertiesBuilder<'a> {
26780     inner: PhysicalDeviceMaintenance4Properties,
26781     marker: ::std::marker::PhantomData<&'a ()>,
26782 }
26783 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance4PropertiesBuilder<'_> {}
26784 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance4Properties {}
26785 impl<'a> ::std::ops::Deref for PhysicalDeviceMaintenance4PropertiesBuilder<'a> {
26786     type Target = PhysicalDeviceMaintenance4Properties;
deref(&self) -> &Self::Target26787     fn deref(&self) -> &Self::Target {
26788         &self.inner
26789     }
26790 }
26791 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMaintenance4PropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target26792     fn deref_mut(&mut self) -> &mut Self::Target {
26793         &mut self.inner
26794     }
26795 }
26796 impl<'a> PhysicalDeviceMaintenance4PropertiesBuilder<'a> {
26797     #[inline]
max_buffer_size(mut self, max_buffer_size: DeviceSize) -> Self26798     pub fn max_buffer_size(mut self, max_buffer_size: DeviceSize) -> Self {
26799         self.inner.max_buffer_size = max_buffer_size;
26800         self
26801     }
26802     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26803     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26804     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMaintenance4Properties26805     pub fn build(self) -> PhysicalDeviceMaintenance4Properties {
26806         self.inner
26807     }
26808 }
26809 #[repr(C)]
26810 #[cfg_attr(feature = "debug", derive(Debug))]
26811 #[derive(Copy, Clone)]
26812 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutSupport.html>"]
26813 pub struct DescriptorSetLayoutSupport {
26814     pub s_type: StructureType,
26815     pub p_next: *mut c_void,
26816     pub supported: Bool32,
26817 }
26818 impl ::std::default::Default for DescriptorSetLayoutSupport {
26819     #[inline]
default() -> Self26820     fn default() -> Self {
26821         Self {
26822             s_type: Self::STRUCTURE_TYPE,
26823             p_next: ::std::ptr::null_mut(),
26824             supported: Bool32::default(),
26825         }
26826     }
26827 }
26828 unsafe impl TaggedStructure for DescriptorSetLayoutSupport {
26829     const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_SET_LAYOUT_SUPPORT;
26830 }
26831 impl DescriptorSetLayoutSupport {
builder<'a>() -> DescriptorSetLayoutSupportBuilder<'a>26832     pub fn builder<'a>() -> DescriptorSetLayoutSupportBuilder<'a> {
26833         DescriptorSetLayoutSupportBuilder {
26834             inner: Self::default(),
26835             marker: ::std::marker::PhantomData,
26836         }
26837     }
26838 }
26839 #[repr(transparent)]
26840 pub struct DescriptorSetLayoutSupportBuilder<'a> {
26841     inner: DescriptorSetLayoutSupport,
26842     marker: ::std::marker::PhantomData<&'a ()>,
26843 }
26844 pub unsafe trait ExtendsDescriptorSetLayoutSupport {}
26845 impl<'a> ::std::ops::Deref for DescriptorSetLayoutSupportBuilder<'a> {
26846     type Target = DescriptorSetLayoutSupport;
deref(&self) -> &Self::Target26847     fn deref(&self) -> &Self::Target {
26848         &self.inner
26849     }
26850 }
26851 impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutSupportBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target26852     fn deref_mut(&mut self) -> &mut Self::Target {
26853         &mut self.inner
26854     }
26855 }
26856 impl<'a> DescriptorSetLayoutSupportBuilder<'a> {
26857     #[inline]
supported(mut self, supported: bool) -> Self26858     pub fn supported(mut self, supported: bool) -> Self {
26859         self.inner.supported = supported.into();
26860         self
26861     }
26862     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
26863     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
26864     #[doc = r" valid extension structs can be pushed into the chain."]
26865     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
26866     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDescriptorSetLayoutSupport>(mut self, next: &'a mut T) -> Self26867     pub fn push_next<T: ExtendsDescriptorSetLayoutSupport>(mut self, next: &'a mut T) -> Self {
26868         unsafe {
26869             let next_ptr = <*mut T>::cast(next);
26870             let last_next = ptr_chain_iter(next).last().unwrap();
26871             (*last_next).p_next = self.inner.p_next as _;
26872             self.inner.p_next = next_ptr;
26873         }
26874         self
26875     }
26876     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26877     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26878     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorSetLayoutSupport26879     pub fn build(self) -> DescriptorSetLayoutSupport {
26880         self.inner
26881     }
26882 }
26883 #[repr(C)]
26884 #[cfg_attr(feature = "debug", derive(Debug))]
26885 #[derive(Copy, Clone)]
26886 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderDrawParametersFeatures.html>"]
26887 pub struct PhysicalDeviceShaderDrawParametersFeatures {
26888     pub s_type: StructureType,
26889     pub p_next: *mut c_void,
26890     pub shader_draw_parameters: Bool32,
26891 }
26892 impl ::std::default::Default for PhysicalDeviceShaderDrawParametersFeatures {
26893     #[inline]
default() -> Self26894     fn default() -> Self {
26895         Self {
26896             s_type: Self::STRUCTURE_TYPE,
26897             p_next: ::std::ptr::null_mut(),
26898             shader_draw_parameters: Bool32::default(),
26899         }
26900     }
26901 }
26902 unsafe impl TaggedStructure for PhysicalDeviceShaderDrawParametersFeatures {
26903     const STRUCTURE_TYPE: StructureType =
26904         StructureType::PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
26905 }
26906 impl PhysicalDeviceShaderDrawParametersFeatures {
builder<'a>() -> PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a>26907     pub fn builder<'a>() -> PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
26908         PhysicalDeviceShaderDrawParametersFeaturesBuilder {
26909             inner: Self::default(),
26910             marker: ::std::marker::PhantomData,
26911         }
26912     }
26913 }
26914 #[repr(transparent)]
26915 pub struct PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
26916     inner: PhysicalDeviceShaderDrawParametersFeatures,
26917     marker: ::std::marker::PhantomData<&'a ()>,
26918 }
26919 unsafe impl ExtendsPhysicalDeviceFeatures2
26920     for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'_>
26921 {
26922 }
26923 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderDrawParametersFeatures {}
26924 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'_> {}
26925 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDrawParametersFeatures {}
26926 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
26927     type Target = PhysicalDeviceShaderDrawParametersFeatures;
deref(&self) -> &Self::Target26928     fn deref(&self) -> &Self::Target {
26929         &self.inner
26930     }
26931 }
26932 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target26933     fn deref_mut(&mut self) -> &mut Self::Target {
26934         &mut self.inner
26935     }
26936 }
26937 impl<'a> PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
26938     #[inline]
shader_draw_parameters(mut self, shader_draw_parameters: bool) -> Self26939     pub fn shader_draw_parameters(mut self, shader_draw_parameters: bool) -> Self {
26940         self.inner.shader_draw_parameters = shader_draw_parameters.into();
26941         self
26942     }
26943     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26944     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26945     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderDrawParametersFeatures26946     pub fn build(self) -> PhysicalDeviceShaderDrawParametersFeatures {
26947         self.inner
26948     }
26949 }
26950 #[repr(C)]
26951 #[cfg_attr(feature = "debug", derive(Debug))]
26952 #[derive(Copy, Clone)]
26953 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderFloat16Int8Features.html>"]
26954 pub struct PhysicalDeviceShaderFloat16Int8Features {
26955     pub s_type: StructureType,
26956     pub p_next: *mut c_void,
26957     pub shader_float16: Bool32,
26958     pub shader_int8: Bool32,
26959 }
26960 impl ::std::default::Default for PhysicalDeviceShaderFloat16Int8Features {
26961     #[inline]
default() -> Self26962     fn default() -> Self {
26963         Self {
26964             s_type: Self::STRUCTURE_TYPE,
26965             p_next: ::std::ptr::null_mut(),
26966             shader_float16: Bool32::default(),
26967             shader_int8: Bool32::default(),
26968         }
26969     }
26970 }
26971 unsafe impl TaggedStructure for PhysicalDeviceShaderFloat16Int8Features {
26972     const STRUCTURE_TYPE: StructureType =
26973         StructureType::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
26974 }
26975 impl PhysicalDeviceShaderFloat16Int8Features {
builder<'a>() -> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a>26976     pub fn builder<'a>() -> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
26977         PhysicalDeviceShaderFloat16Int8FeaturesBuilder {
26978             inner: Self::default(),
26979             marker: ::std::marker::PhantomData,
26980         }
26981     }
26982 }
26983 #[repr(transparent)]
26984 pub struct PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
26985     inner: PhysicalDeviceShaderFloat16Int8Features,
26986     marker: ::std::marker::PhantomData<&'a ()>,
26987 }
26988 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'_> {}
26989 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderFloat16Int8Features {}
26990 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'_> {}
26991 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderFloat16Int8Features {}
26992 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
26993     type Target = PhysicalDeviceShaderFloat16Int8Features;
deref(&self) -> &Self::Target26994     fn deref(&self) -> &Self::Target {
26995         &self.inner
26996     }
26997 }
26998 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target26999     fn deref_mut(&mut self) -> &mut Self::Target {
27000         &mut self.inner
27001     }
27002 }
27003 impl<'a> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
27004     #[inline]
shader_float16(mut self, shader_float16: bool) -> Self27005     pub fn shader_float16(mut self, shader_float16: bool) -> Self {
27006         self.inner.shader_float16 = shader_float16.into();
27007         self
27008     }
27009     #[inline]
shader_int8(mut self, shader_int8: bool) -> Self27010     pub fn shader_int8(mut self, shader_int8: bool) -> Self {
27011         self.inner.shader_int8 = shader_int8.into();
27012         self
27013     }
27014     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27015     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27016     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderFloat16Int8Features27017     pub fn build(self) -> PhysicalDeviceShaderFloat16Int8Features {
27018         self.inner
27019     }
27020 }
27021 #[repr(C)]
27022 #[cfg_attr(feature = "debug", derive(Debug))]
27023 #[derive(Copy, Clone)]
27024 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFloatControlsProperties.html>"]
27025 pub struct PhysicalDeviceFloatControlsProperties {
27026     pub s_type: StructureType,
27027     pub p_next: *mut c_void,
27028     pub denorm_behavior_independence: ShaderFloatControlsIndependence,
27029     pub rounding_mode_independence: ShaderFloatControlsIndependence,
27030     pub shader_signed_zero_inf_nan_preserve_float16: Bool32,
27031     pub shader_signed_zero_inf_nan_preserve_float32: Bool32,
27032     pub shader_signed_zero_inf_nan_preserve_float64: Bool32,
27033     pub shader_denorm_preserve_float16: Bool32,
27034     pub shader_denorm_preserve_float32: Bool32,
27035     pub shader_denorm_preserve_float64: Bool32,
27036     pub shader_denorm_flush_to_zero_float16: Bool32,
27037     pub shader_denorm_flush_to_zero_float32: Bool32,
27038     pub shader_denorm_flush_to_zero_float64: Bool32,
27039     pub shader_rounding_mode_rte_float16: Bool32,
27040     pub shader_rounding_mode_rte_float32: Bool32,
27041     pub shader_rounding_mode_rte_float64: Bool32,
27042     pub shader_rounding_mode_rtz_float16: Bool32,
27043     pub shader_rounding_mode_rtz_float32: Bool32,
27044     pub shader_rounding_mode_rtz_float64: Bool32,
27045 }
27046 impl ::std::default::Default for PhysicalDeviceFloatControlsProperties {
27047     #[inline]
default() -> Self27048     fn default() -> Self {
27049         Self {
27050             s_type: Self::STRUCTURE_TYPE,
27051             p_next: ::std::ptr::null_mut(),
27052             denorm_behavior_independence: ShaderFloatControlsIndependence::default(),
27053             rounding_mode_independence: ShaderFloatControlsIndependence::default(),
27054             shader_signed_zero_inf_nan_preserve_float16: Bool32::default(),
27055             shader_signed_zero_inf_nan_preserve_float32: Bool32::default(),
27056             shader_signed_zero_inf_nan_preserve_float64: Bool32::default(),
27057             shader_denorm_preserve_float16: Bool32::default(),
27058             shader_denorm_preserve_float32: Bool32::default(),
27059             shader_denorm_preserve_float64: Bool32::default(),
27060             shader_denorm_flush_to_zero_float16: Bool32::default(),
27061             shader_denorm_flush_to_zero_float32: Bool32::default(),
27062             shader_denorm_flush_to_zero_float64: Bool32::default(),
27063             shader_rounding_mode_rte_float16: Bool32::default(),
27064             shader_rounding_mode_rte_float32: Bool32::default(),
27065             shader_rounding_mode_rte_float64: Bool32::default(),
27066             shader_rounding_mode_rtz_float16: Bool32::default(),
27067             shader_rounding_mode_rtz_float32: Bool32::default(),
27068             shader_rounding_mode_rtz_float64: Bool32::default(),
27069         }
27070     }
27071 }
27072 unsafe impl TaggedStructure for PhysicalDeviceFloatControlsProperties {
27073     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
27074 }
27075 impl PhysicalDeviceFloatControlsProperties {
builder<'a>() -> PhysicalDeviceFloatControlsPropertiesBuilder<'a>27076     pub fn builder<'a>() -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
27077         PhysicalDeviceFloatControlsPropertiesBuilder {
27078             inner: Self::default(),
27079             marker: ::std::marker::PhantomData,
27080         }
27081     }
27082 }
27083 #[repr(transparent)]
27084 pub struct PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
27085     inner: PhysicalDeviceFloatControlsProperties,
27086     marker: ::std::marker::PhantomData<&'a ()>,
27087 }
27088 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFloatControlsPropertiesBuilder<'_> {}
27089 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFloatControlsProperties {}
27090 impl<'a> ::std::ops::Deref for PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
27091     type Target = PhysicalDeviceFloatControlsProperties;
deref(&self) -> &Self::Target27092     fn deref(&self) -> &Self::Target {
27093         &self.inner
27094     }
27095 }
27096 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target27097     fn deref_mut(&mut self) -> &mut Self::Target {
27098         &mut self.inner
27099     }
27100 }
27101 impl<'a> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
27102     #[inline]
denorm_behavior_independence( mut self, denorm_behavior_independence: ShaderFloatControlsIndependence, ) -> Self27103     pub fn denorm_behavior_independence(
27104         mut self,
27105         denorm_behavior_independence: ShaderFloatControlsIndependence,
27106     ) -> Self {
27107         self.inner.denorm_behavior_independence = denorm_behavior_independence;
27108         self
27109     }
27110     #[inline]
rounding_mode_independence( mut self, rounding_mode_independence: ShaderFloatControlsIndependence, ) -> Self27111     pub fn rounding_mode_independence(
27112         mut self,
27113         rounding_mode_independence: ShaderFloatControlsIndependence,
27114     ) -> Self {
27115         self.inner.rounding_mode_independence = rounding_mode_independence;
27116         self
27117     }
27118     #[inline]
shader_signed_zero_inf_nan_preserve_float16( mut self, shader_signed_zero_inf_nan_preserve_float16: bool, ) -> Self27119     pub fn shader_signed_zero_inf_nan_preserve_float16(
27120         mut self,
27121         shader_signed_zero_inf_nan_preserve_float16: bool,
27122     ) -> Self {
27123         self.inner.shader_signed_zero_inf_nan_preserve_float16 =
27124             shader_signed_zero_inf_nan_preserve_float16.into();
27125         self
27126     }
27127     #[inline]
shader_signed_zero_inf_nan_preserve_float32( mut self, shader_signed_zero_inf_nan_preserve_float32: bool, ) -> Self27128     pub fn shader_signed_zero_inf_nan_preserve_float32(
27129         mut self,
27130         shader_signed_zero_inf_nan_preserve_float32: bool,
27131     ) -> Self {
27132         self.inner.shader_signed_zero_inf_nan_preserve_float32 =
27133             shader_signed_zero_inf_nan_preserve_float32.into();
27134         self
27135     }
27136     #[inline]
shader_signed_zero_inf_nan_preserve_float64( mut self, shader_signed_zero_inf_nan_preserve_float64: bool, ) -> Self27137     pub fn shader_signed_zero_inf_nan_preserve_float64(
27138         mut self,
27139         shader_signed_zero_inf_nan_preserve_float64: bool,
27140     ) -> Self {
27141         self.inner.shader_signed_zero_inf_nan_preserve_float64 =
27142             shader_signed_zero_inf_nan_preserve_float64.into();
27143         self
27144     }
27145     #[inline]
shader_denorm_preserve_float16(mut self, shader_denorm_preserve_float16: bool) -> Self27146     pub fn shader_denorm_preserve_float16(mut self, shader_denorm_preserve_float16: bool) -> Self {
27147         self.inner.shader_denorm_preserve_float16 = shader_denorm_preserve_float16.into();
27148         self
27149     }
27150     #[inline]
shader_denorm_preserve_float32(mut self, shader_denorm_preserve_float32: bool) -> Self27151     pub fn shader_denorm_preserve_float32(mut self, shader_denorm_preserve_float32: bool) -> Self {
27152         self.inner.shader_denorm_preserve_float32 = shader_denorm_preserve_float32.into();
27153         self
27154     }
27155     #[inline]
shader_denorm_preserve_float64(mut self, shader_denorm_preserve_float64: bool) -> Self27156     pub fn shader_denorm_preserve_float64(mut self, shader_denorm_preserve_float64: bool) -> Self {
27157         self.inner.shader_denorm_preserve_float64 = shader_denorm_preserve_float64.into();
27158         self
27159     }
27160     #[inline]
shader_denorm_flush_to_zero_float16( mut self, shader_denorm_flush_to_zero_float16: bool, ) -> Self27161     pub fn shader_denorm_flush_to_zero_float16(
27162         mut self,
27163         shader_denorm_flush_to_zero_float16: bool,
27164     ) -> Self {
27165         self.inner.shader_denorm_flush_to_zero_float16 = shader_denorm_flush_to_zero_float16.into();
27166         self
27167     }
27168     #[inline]
shader_denorm_flush_to_zero_float32( mut self, shader_denorm_flush_to_zero_float32: bool, ) -> Self27169     pub fn shader_denorm_flush_to_zero_float32(
27170         mut self,
27171         shader_denorm_flush_to_zero_float32: bool,
27172     ) -> Self {
27173         self.inner.shader_denorm_flush_to_zero_float32 = shader_denorm_flush_to_zero_float32.into();
27174         self
27175     }
27176     #[inline]
shader_denorm_flush_to_zero_float64( mut self, shader_denorm_flush_to_zero_float64: bool, ) -> Self27177     pub fn shader_denorm_flush_to_zero_float64(
27178         mut self,
27179         shader_denorm_flush_to_zero_float64: bool,
27180     ) -> Self {
27181         self.inner.shader_denorm_flush_to_zero_float64 = shader_denorm_flush_to_zero_float64.into();
27182         self
27183     }
27184     #[inline]
shader_rounding_mode_rte_float16( mut self, shader_rounding_mode_rte_float16: bool, ) -> Self27185     pub fn shader_rounding_mode_rte_float16(
27186         mut self,
27187         shader_rounding_mode_rte_float16: bool,
27188     ) -> Self {
27189         self.inner.shader_rounding_mode_rte_float16 = shader_rounding_mode_rte_float16.into();
27190         self
27191     }
27192     #[inline]
shader_rounding_mode_rte_float32( mut self, shader_rounding_mode_rte_float32: bool, ) -> Self27193     pub fn shader_rounding_mode_rte_float32(
27194         mut self,
27195         shader_rounding_mode_rte_float32: bool,
27196     ) -> Self {
27197         self.inner.shader_rounding_mode_rte_float32 = shader_rounding_mode_rte_float32.into();
27198         self
27199     }
27200     #[inline]
shader_rounding_mode_rte_float64( mut self, shader_rounding_mode_rte_float64: bool, ) -> Self27201     pub fn shader_rounding_mode_rte_float64(
27202         mut self,
27203         shader_rounding_mode_rte_float64: bool,
27204     ) -> Self {
27205         self.inner.shader_rounding_mode_rte_float64 = shader_rounding_mode_rte_float64.into();
27206         self
27207     }
27208     #[inline]
shader_rounding_mode_rtz_float16( mut self, shader_rounding_mode_rtz_float16: bool, ) -> Self27209     pub fn shader_rounding_mode_rtz_float16(
27210         mut self,
27211         shader_rounding_mode_rtz_float16: bool,
27212     ) -> Self {
27213         self.inner.shader_rounding_mode_rtz_float16 = shader_rounding_mode_rtz_float16.into();
27214         self
27215     }
27216     #[inline]
shader_rounding_mode_rtz_float32( mut self, shader_rounding_mode_rtz_float32: bool, ) -> Self27217     pub fn shader_rounding_mode_rtz_float32(
27218         mut self,
27219         shader_rounding_mode_rtz_float32: bool,
27220     ) -> Self {
27221         self.inner.shader_rounding_mode_rtz_float32 = shader_rounding_mode_rtz_float32.into();
27222         self
27223     }
27224     #[inline]
shader_rounding_mode_rtz_float64( mut self, shader_rounding_mode_rtz_float64: bool, ) -> Self27225     pub fn shader_rounding_mode_rtz_float64(
27226         mut self,
27227         shader_rounding_mode_rtz_float64: bool,
27228     ) -> Self {
27229         self.inner.shader_rounding_mode_rtz_float64 = shader_rounding_mode_rtz_float64.into();
27230         self
27231     }
27232     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27233     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27234     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFloatControlsProperties27235     pub fn build(self) -> PhysicalDeviceFloatControlsProperties {
27236         self.inner
27237     }
27238 }
27239 #[repr(C)]
27240 #[cfg_attr(feature = "debug", derive(Debug))]
27241 #[derive(Copy, Clone)]
27242 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceHostQueryResetFeatures.html>"]
27243 pub struct PhysicalDeviceHostQueryResetFeatures {
27244     pub s_type: StructureType,
27245     pub p_next: *mut c_void,
27246     pub host_query_reset: Bool32,
27247 }
27248 impl ::std::default::Default for PhysicalDeviceHostQueryResetFeatures {
27249     #[inline]
default() -> Self27250     fn default() -> Self {
27251         Self {
27252             s_type: Self::STRUCTURE_TYPE,
27253             p_next: ::std::ptr::null_mut(),
27254             host_query_reset: Bool32::default(),
27255         }
27256     }
27257 }
27258 unsafe impl TaggedStructure for PhysicalDeviceHostQueryResetFeatures {
27259     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
27260 }
27261 impl PhysicalDeviceHostQueryResetFeatures {
builder<'a>() -> PhysicalDeviceHostQueryResetFeaturesBuilder<'a>27262     pub fn builder<'a>() -> PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
27263         PhysicalDeviceHostQueryResetFeaturesBuilder {
27264             inner: Self::default(),
27265             marker: ::std::marker::PhantomData,
27266         }
27267     }
27268 }
27269 #[repr(transparent)]
27270 pub struct PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
27271     inner: PhysicalDeviceHostQueryResetFeatures,
27272     marker: ::std::marker::PhantomData<&'a ()>,
27273 }
27274 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceHostQueryResetFeaturesBuilder<'_> {}
27275 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceHostQueryResetFeatures {}
27276 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceHostQueryResetFeaturesBuilder<'_> {}
27277 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceHostQueryResetFeatures {}
27278 impl<'a> ::std::ops::Deref for PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
27279     type Target = PhysicalDeviceHostQueryResetFeatures;
deref(&self) -> &Self::Target27280     fn deref(&self) -> &Self::Target {
27281         &self.inner
27282     }
27283 }
27284 impl<'a> ::std::ops::DerefMut for PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target27285     fn deref_mut(&mut self) -> &mut Self::Target {
27286         &mut self.inner
27287     }
27288 }
27289 impl<'a> PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
27290     #[inline]
host_query_reset(mut self, host_query_reset: bool) -> Self27291     pub fn host_query_reset(mut self, host_query_reset: bool) -> Self {
27292         self.inner.host_query_reset = host_query_reset.into();
27293         self
27294     }
27295     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27296     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27297     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceHostQueryResetFeatures27298     pub fn build(self) -> PhysicalDeviceHostQueryResetFeatures {
27299         self.inner
27300     }
27301 }
27302 #[repr(C)]
27303 #[cfg_attr(feature = "debug", derive(Debug))]
27304 #[derive(Copy, Clone, Default)]
27305 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkNativeBufferUsage2ANDROID.html>"]
27306 pub struct NativeBufferUsage2ANDROID {
27307     pub consumer: u64,
27308     pub producer: u64,
27309 }
27310 impl NativeBufferUsage2ANDROID {
builder<'a>() -> NativeBufferUsage2ANDROIDBuilder<'a>27311     pub fn builder<'a>() -> NativeBufferUsage2ANDROIDBuilder<'a> {
27312         NativeBufferUsage2ANDROIDBuilder {
27313             inner: Self::default(),
27314             marker: ::std::marker::PhantomData,
27315         }
27316     }
27317 }
27318 #[repr(transparent)]
27319 pub struct NativeBufferUsage2ANDROIDBuilder<'a> {
27320     inner: NativeBufferUsage2ANDROID,
27321     marker: ::std::marker::PhantomData<&'a ()>,
27322 }
27323 impl<'a> ::std::ops::Deref for NativeBufferUsage2ANDROIDBuilder<'a> {
27324     type Target = NativeBufferUsage2ANDROID;
deref(&self) -> &Self::Target27325     fn deref(&self) -> &Self::Target {
27326         &self.inner
27327     }
27328 }
27329 impl<'a> ::std::ops::DerefMut for NativeBufferUsage2ANDROIDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target27330     fn deref_mut(&mut self) -> &mut Self::Target {
27331         &mut self.inner
27332     }
27333 }
27334 impl<'a> NativeBufferUsage2ANDROIDBuilder<'a> {
27335     #[inline]
consumer(mut self, consumer: u64) -> Self27336     pub fn consumer(mut self, consumer: u64) -> Self {
27337         self.inner.consumer = consumer;
27338         self
27339     }
27340     #[inline]
producer(mut self, producer: u64) -> Self27341     pub fn producer(mut self, producer: u64) -> Self {
27342         self.inner.producer = producer;
27343         self
27344     }
27345     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27346     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27347     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> NativeBufferUsage2ANDROID27348     pub fn build(self) -> NativeBufferUsage2ANDROID {
27349         self.inner
27350     }
27351 }
27352 #[repr(C)]
27353 #[cfg_attr(feature = "debug", derive(Debug))]
27354 #[derive(Copy, Clone)]
27355 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkNativeBufferANDROID.html>"]
27356 pub struct NativeBufferANDROID {
27357     pub s_type: StructureType,
27358     pub p_next: *const c_void,
27359     pub handle: *const c_void,
27360     pub stride: c_int,
27361     pub format: c_int,
27362     pub usage: c_int,
27363     pub usage2: NativeBufferUsage2ANDROID,
27364 }
27365 impl ::std::default::Default for NativeBufferANDROID {
27366     #[inline]
default() -> Self27367     fn default() -> Self {
27368         Self {
27369             s_type: Self::STRUCTURE_TYPE,
27370             p_next: ::std::ptr::null(),
27371             handle: ::std::ptr::null(),
27372             stride: c_int::default(),
27373             format: c_int::default(),
27374             usage: c_int::default(),
27375             usage2: NativeBufferUsage2ANDROID::default(),
27376         }
27377     }
27378 }
27379 unsafe impl TaggedStructure for NativeBufferANDROID {
27380     const STRUCTURE_TYPE: StructureType = StructureType::NATIVE_BUFFER_ANDROID;
27381 }
27382 impl NativeBufferANDROID {
builder<'a>() -> NativeBufferANDROIDBuilder<'a>27383     pub fn builder<'a>() -> NativeBufferANDROIDBuilder<'a> {
27384         NativeBufferANDROIDBuilder {
27385             inner: Self::default(),
27386             marker: ::std::marker::PhantomData,
27387         }
27388     }
27389 }
27390 #[repr(transparent)]
27391 pub struct NativeBufferANDROIDBuilder<'a> {
27392     inner: NativeBufferANDROID,
27393     marker: ::std::marker::PhantomData<&'a ()>,
27394 }
27395 impl<'a> ::std::ops::Deref for NativeBufferANDROIDBuilder<'a> {
27396     type Target = NativeBufferANDROID;
deref(&self) -> &Self::Target27397     fn deref(&self) -> &Self::Target {
27398         &self.inner
27399     }
27400 }
27401 impl<'a> ::std::ops::DerefMut for NativeBufferANDROIDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target27402     fn deref_mut(&mut self) -> &mut Self::Target {
27403         &mut self.inner
27404     }
27405 }
27406 impl<'a> NativeBufferANDROIDBuilder<'a> {
27407     #[inline]
handle(mut self, handle: *const c_void) -> Self27408     pub fn handle(mut self, handle: *const c_void) -> Self {
27409         self.inner.handle = handle;
27410         self
27411     }
27412     #[inline]
stride(mut self, stride: c_int) -> Self27413     pub fn stride(mut self, stride: c_int) -> Self {
27414         self.inner.stride = stride;
27415         self
27416     }
27417     #[inline]
format(mut self, format: c_int) -> Self27418     pub fn format(mut self, format: c_int) -> Self {
27419         self.inner.format = format;
27420         self
27421     }
27422     #[inline]
usage(mut self, usage: c_int) -> Self27423     pub fn usage(mut self, usage: c_int) -> Self {
27424         self.inner.usage = usage;
27425         self
27426     }
27427     #[inline]
usage2(mut self, usage2: NativeBufferUsage2ANDROID) -> Self27428     pub fn usage2(mut self, usage2: NativeBufferUsage2ANDROID) -> Self {
27429         self.inner.usage2 = usage2;
27430         self
27431     }
27432     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27433     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27434     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> NativeBufferANDROID27435     pub fn build(self) -> NativeBufferANDROID {
27436         self.inner
27437     }
27438 }
27439 #[repr(C)]
27440 #[cfg_attr(feature = "debug", derive(Debug))]
27441 #[derive(Copy, Clone)]
27442 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainImageCreateInfoANDROID.html>"]
27443 pub struct SwapchainImageCreateInfoANDROID {
27444     pub s_type: StructureType,
27445     pub p_next: *const c_void,
27446     pub usage: SwapchainImageUsageFlagsANDROID,
27447 }
27448 impl ::std::default::Default for SwapchainImageCreateInfoANDROID {
27449     #[inline]
default() -> Self27450     fn default() -> Self {
27451         Self {
27452             s_type: Self::STRUCTURE_TYPE,
27453             p_next: ::std::ptr::null(),
27454             usage: SwapchainImageUsageFlagsANDROID::default(),
27455         }
27456     }
27457 }
27458 unsafe impl TaggedStructure for SwapchainImageCreateInfoANDROID {
27459     const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID;
27460 }
27461 impl SwapchainImageCreateInfoANDROID {
builder<'a>() -> SwapchainImageCreateInfoANDROIDBuilder<'a>27462     pub fn builder<'a>() -> SwapchainImageCreateInfoANDROIDBuilder<'a> {
27463         SwapchainImageCreateInfoANDROIDBuilder {
27464             inner: Self::default(),
27465             marker: ::std::marker::PhantomData,
27466         }
27467     }
27468 }
27469 #[repr(transparent)]
27470 pub struct SwapchainImageCreateInfoANDROIDBuilder<'a> {
27471     inner: SwapchainImageCreateInfoANDROID,
27472     marker: ::std::marker::PhantomData<&'a ()>,
27473 }
27474 impl<'a> ::std::ops::Deref for SwapchainImageCreateInfoANDROIDBuilder<'a> {
27475     type Target = SwapchainImageCreateInfoANDROID;
deref(&self) -> &Self::Target27476     fn deref(&self) -> &Self::Target {
27477         &self.inner
27478     }
27479 }
27480 impl<'a> ::std::ops::DerefMut for SwapchainImageCreateInfoANDROIDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target27481     fn deref_mut(&mut self) -> &mut Self::Target {
27482         &mut self.inner
27483     }
27484 }
27485 impl<'a> SwapchainImageCreateInfoANDROIDBuilder<'a> {
27486     #[inline]
usage(mut self, usage: SwapchainImageUsageFlagsANDROID) -> Self27487     pub fn usage(mut self, usage: SwapchainImageUsageFlagsANDROID) -> Self {
27488         self.inner.usage = usage;
27489         self
27490     }
27491     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27492     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27493     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SwapchainImageCreateInfoANDROID27494     pub fn build(self) -> SwapchainImageCreateInfoANDROID {
27495         self.inner
27496     }
27497 }
27498 #[repr(C)]
27499 #[cfg_attr(feature = "debug", derive(Debug))]
27500 #[derive(Copy, Clone)]
27501 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePresentationPropertiesANDROID.html>"]
27502 pub struct PhysicalDevicePresentationPropertiesANDROID {
27503     pub s_type: StructureType,
27504     pub p_next: *const c_void,
27505     pub shared_image: Bool32,
27506 }
27507 impl ::std::default::Default for PhysicalDevicePresentationPropertiesANDROID {
27508     #[inline]
default() -> Self27509     fn default() -> Self {
27510         Self {
27511             s_type: Self::STRUCTURE_TYPE,
27512             p_next: ::std::ptr::null(),
27513             shared_image: Bool32::default(),
27514         }
27515     }
27516 }
27517 unsafe impl TaggedStructure for PhysicalDevicePresentationPropertiesANDROID {
27518     const STRUCTURE_TYPE: StructureType =
27519         StructureType::PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID;
27520 }
27521 impl PhysicalDevicePresentationPropertiesANDROID {
builder<'a>() -> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a>27522     pub fn builder<'a>() -> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
27523         PhysicalDevicePresentationPropertiesANDROIDBuilder {
27524             inner: Self::default(),
27525             marker: ::std::marker::PhantomData,
27526         }
27527     }
27528 }
27529 #[repr(transparent)]
27530 pub struct PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
27531     inner: PhysicalDevicePresentationPropertiesANDROID,
27532     marker: ::std::marker::PhantomData<&'a ()>,
27533 }
27534 impl<'a> ::std::ops::Deref for PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
27535     type Target = PhysicalDevicePresentationPropertiesANDROID;
deref(&self) -> &Self::Target27536     fn deref(&self) -> &Self::Target {
27537         &self.inner
27538     }
27539 }
27540 impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target27541     fn deref_mut(&mut self) -> &mut Self::Target {
27542         &mut self.inner
27543     }
27544 }
27545 impl<'a> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
27546     #[inline]
shared_image(mut self, shared_image: bool) -> Self27547     pub fn shared_image(mut self, shared_image: bool) -> Self {
27548         self.inner.shared_image = shared_image.into();
27549         self
27550     }
27551     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27552     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27553     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePresentationPropertiesANDROID27554     pub fn build(self) -> PhysicalDevicePresentationPropertiesANDROID {
27555         self.inner
27556     }
27557 }
27558 #[repr(C)]
27559 #[cfg_attr(feature = "debug", derive(Debug))]
27560 #[derive(Copy, Clone, Default)]
27561 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderResourceUsageAMD.html>"]
27562 pub struct ShaderResourceUsageAMD {
27563     pub num_used_vgprs: u32,
27564     pub num_used_sgprs: u32,
27565     pub lds_size_per_local_work_group: u32,
27566     pub lds_usage_size_in_bytes: usize,
27567     pub scratch_mem_usage_in_bytes: usize,
27568 }
27569 impl ShaderResourceUsageAMD {
builder<'a>() -> ShaderResourceUsageAMDBuilder<'a>27570     pub fn builder<'a>() -> ShaderResourceUsageAMDBuilder<'a> {
27571         ShaderResourceUsageAMDBuilder {
27572             inner: Self::default(),
27573             marker: ::std::marker::PhantomData,
27574         }
27575     }
27576 }
27577 #[repr(transparent)]
27578 pub struct ShaderResourceUsageAMDBuilder<'a> {
27579     inner: ShaderResourceUsageAMD,
27580     marker: ::std::marker::PhantomData<&'a ()>,
27581 }
27582 impl<'a> ::std::ops::Deref for ShaderResourceUsageAMDBuilder<'a> {
27583     type Target = ShaderResourceUsageAMD;
deref(&self) -> &Self::Target27584     fn deref(&self) -> &Self::Target {
27585         &self.inner
27586     }
27587 }
27588 impl<'a> ::std::ops::DerefMut for ShaderResourceUsageAMDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target27589     fn deref_mut(&mut self) -> &mut Self::Target {
27590         &mut self.inner
27591     }
27592 }
27593 impl<'a> ShaderResourceUsageAMDBuilder<'a> {
27594     #[inline]
num_used_vgprs(mut self, num_used_vgprs: u32) -> Self27595     pub fn num_used_vgprs(mut self, num_used_vgprs: u32) -> Self {
27596         self.inner.num_used_vgprs = num_used_vgprs;
27597         self
27598     }
27599     #[inline]
num_used_sgprs(mut self, num_used_sgprs: u32) -> Self27600     pub fn num_used_sgprs(mut self, num_used_sgprs: u32) -> Self {
27601         self.inner.num_used_sgprs = num_used_sgprs;
27602         self
27603     }
27604     #[inline]
lds_size_per_local_work_group(mut self, lds_size_per_local_work_group: u32) -> Self27605     pub fn lds_size_per_local_work_group(mut self, lds_size_per_local_work_group: u32) -> Self {
27606         self.inner.lds_size_per_local_work_group = lds_size_per_local_work_group;
27607         self
27608     }
27609     #[inline]
lds_usage_size_in_bytes(mut self, lds_usage_size_in_bytes: usize) -> Self27610     pub fn lds_usage_size_in_bytes(mut self, lds_usage_size_in_bytes: usize) -> Self {
27611         self.inner.lds_usage_size_in_bytes = lds_usage_size_in_bytes;
27612         self
27613     }
27614     #[inline]
scratch_mem_usage_in_bytes(mut self, scratch_mem_usage_in_bytes: usize) -> Self27615     pub fn scratch_mem_usage_in_bytes(mut self, scratch_mem_usage_in_bytes: usize) -> Self {
27616         self.inner.scratch_mem_usage_in_bytes = scratch_mem_usage_in_bytes;
27617         self
27618     }
27619     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27620     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27621     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ShaderResourceUsageAMD27622     pub fn build(self) -> ShaderResourceUsageAMD {
27623         self.inner
27624     }
27625 }
27626 #[repr(C)]
27627 #[cfg_attr(feature = "debug", derive(Debug))]
27628 #[derive(Copy, Clone)]
27629 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderStatisticsInfoAMD.html>"]
27630 pub struct ShaderStatisticsInfoAMD {
27631     pub shader_stage_mask: ShaderStageFlags,
27632     pub resource_usage: ShaderResourceUsageAMD,
27633     pub num_physical_vgprs: u32,
27634     pub num_physical_sgprs: u32,
27635     pub num_available_vgprs: u32,
27636     pub num_available_sgprs: u32,
27637     pub compute_work_group_size: [u32; 3],
27638 }
27639 impl ::std::default::Default for ShaderStatisticsInfoAMD {
27640     #[inline]
default() -> Self27641     fn default() -> Self {
27642         Self {
27643             shader_stage_mask: ShaderStageFlags::default(),
27644             resource_usage: ShaderResourceUsageAMD::default(),
27645             num_physical_vgprs: u32::default(),
27646             num_physical_sgprs: u32::default(),
27647             num_available_vgprs: u32::default(),
27648             num_available_sgprs: u32::default(),
27649             compute_work_group_size: unsafe { ::std::mem::zeroed() },
27650         }
27651     }
27652 }
27653 impl ShaderStatisticsInfoAMD {
builder<'a>() -> ShaderStatisticsInfoAMDBuilder<'a>27654     pub fn builder<'a>() -> ShaderStatisticsInfoAMDBuilder<'a> {
27655         ShaderStatisticsInfoAMDBuilder {
27656             inner: Self::default(),
27657             marker: ::std::marker::PhantomData,
27658         }
27659     }
27660 }
27661 #[repr(transparent)]
27662 pub struct ShaderStatisticsInfoAMDBuilder<'a> {
27663     inner: ShaderStatisticsInfoAMD,
27664     marker: ::std::marker::PhantomData<&'a ()>,
27665 }
27666 impl<'a> ::std::ops::Deref for ShaderStatisticsInfoAMDBuilder<'a> {
27667     type Target = ShaderStatisticsInfoAMD;
deref(&self) -> &Self::Target27668     fn deref(&self) -> &Self::Target {
27669         &self.inner
27670     }
27671 }
27672 impl<'a> ::std::ops::DerefMut for ShaderStatisticsInfoAMDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target27673     fn deref_mut(&mut self) -> &mut Self::Target {
27674         &mut self.inner
27675     }
27676 }
27677 impl<'a> ShaderStatisticsInfoAMDBuilder<'a> {
27678     #[inline]
shader_stage_mask(mut self, shader_stage_mask: ShaderStageFlags) -> Self27679     pub fn shader_stage_mask(mut self, shader_stage_mask: ShaderStageFlags) -> Self {
27680         self.inner.shader_stage_mask = shader_stage_mask;
27681         self
27682     }
27683     #[inline]
resource_usage(mut self, resource_usage: ShaderResourceUsageAMD) -> Self27684     pub fn resource_usage(mut self, resource_usage: ShaderResourceUsageAMD) -> Self {
27685         self.inner.resource_usage = resource_usage;
27686         self
27687     }
27688     #[inline]
num_physical_vgprs(mut self, num_physical_vgprs: u32) -> Self27689     pub fn num_physical_vgprs(mut self, num_physical_vgprs: u32) -> Self {
27690         self.inner.num_physical_vgprs = num_physical_vgprs;
27691         self
27692     }
27693     #[inline]
num_physical_sgprs(mut self, num_physical_sgprs: u32) -> Self27694     pub fn num_physical_sgprs(mut self, num_physical_sgprs: u32) -> Self {
27695         self.inner.num_physical_sgprs = num_physical_sgprs;
27696         self
27697     }
27698     #[inline]
num_available_vgprs(mut self, num_available_vgprs: u32) -> Self27699     pub fn num_available_vgprs(mut self, num_available_vgprs: u32) -> Self {
27700         self.inner.num_available_vgprs = num_available_vgprs;
27701         self
27702     }
27703     #[inline]
num_available_sgprs(mut self, num_available_sgprs: u32) -> Self27704     pub fn num_available_sgprs(mut self, num_available_sgprs: u32) -> Self {
27705         self.inner.num_available_sgprs = num_available_sgprs;
27706         self
27707     }
27708     #[inline]
compute_work_group_size(mut self, compute_work_group_size: [u32; 3]) -> Self27709     pub fn compute_work_group_size(mut self, compute_work_group_size: [u32; 3]) -> Self {
27710         self.inner.compute_work_group_size = compute_work_group_size;
27711         self
27712     }
27713     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27714     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27715     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ShaderStatisticsInfoAMD27716     pub fn build(self) -> ShaderStatisticsInfoAMD {
27717         self.inner
27718     }
27719 }
27720 #[repr(C)]
27721 #[cfg_attr(feature = "debug", derive(Debug))]
27722 #[derive(Copy, Clone)]
27723 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceQueueGlobalPriorityCreateInfoKHR.html>"]
27724 pub struct DeviceQueueGlobalPriorityCreateInfoKHR {
27725     pub s_type: StructureType,
27726     pub p_next: *const c_void,
27727     pub global_priority: QueueGlobalPriorityKHR,
27728 }
27729 impl ::std::default::Default for DeviceQueueGlobalPriorityCreateInfoKHR {
27730     #[inline]
default() -> Self27731     fn default() -> Self {
27732         Self {
27733             s_type: Self::STRUCTURE_TYPE,
27734             p_next: ::std::ptr::null(),
27735             global_priority: QueueGlobalPriorityKHR::default(),
27736         }
27737     }
27738 }
27739 unsafe impl TaggedStructure for DeviceQueueGlobalPriorityCreateInfoKHR {
27740     const STRUCTURE_TYPE: StructureType =
27741         StructureType::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR;
27742 }
27743 impl DeviceQueueGlobalPriorityCreateInfoKHR {
builder<'a>() -> DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a>27744     pub fn builder<'a>() -> DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> {
27745         DeviceQueueGlobalPriorityCreateInfoKHRBuilder {
27746             inner: Self::default(),
27747             marker: ::std::marker::PhantomData,
27748         }
27749     }
27750 }
27751 #[repr(transparent)]
27752 pub struct DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> {
27753     inner: DeviceQueueGlobalPriorityCreateInfoKHR,
27754     marker: ::std::marker::PhantomData<&'a ()>,
27755 }
27756 unsafe impl ExtendsDeviceQueueCreateInfo for DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'_> {}
27757 unsafe impl ExtendsDeviceQueueCreateInfo for DeviceQueueGlobalPriorityCreateInfoKHR {}
27758 impl<'a> ::std::ops::Deref for DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> {
27759     type Target = DeviceQueueGlobalPriorityCreateInfoKHR;
deref(&self) -> &Self::Target27760     fn deref(&self) -> &Self::Target {
27761         &self.inner
27762     }
27763 }
27764 impl<'a> ::std::ops::DerefMut for DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target27765     fn deref_mut(&mut self) -> &mut Self::Target {
27766         &mut self.inner
27767     }
27768 }
27769 impl<'a> DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> {
27770     #[inline]
global_priority(mut self, global_priority: QueueGlobalPriorityKHR) -> Self27771     pub fn global_priority(mut self, global_priority: QueueGlobalPriorityKHR) -> Self {
27772         self.inner.global_priority = global_priority;
27773         self
27774     }
27775     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27776     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27777     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceQueueGlobalPriorityCreateInfoKHR27778     pub fn build(self) -> DeviceQueueGlobalPriorityCreateInfoKHR {
27779         self.inner
27780     }
27781 }
27782 #[repr(C)]
27783 #[cfg_attr(feature = "debug", derive(Debug))]
27784 #[derive(Copy, Clone)]
27785 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR.html>"]
27786 pub struct PhysicalDeviceGlobalPriorityQueryFeaturesKHR {
27787     pub s_type: StructureType,
27788     pub p_next: *mut c_void,
27789     pub global_priority_query: Bool32,
27790 }
27791 impl ::std::default::Default for PhysicalDeviceGlobalPriorityQueryFeaturesKHR {
27792     #[inline]
default() -> Self27793     fn default() -> Self {
27794         Self {
27795             s_type: Self::STRUCTURE_TYPE,
27796             p_next: ::std::ptr::null_mut(),
27797             global_priority_query: Bool32::default(),
27798         }
27799     }
27800 }
27801 unsafe impl TaggedStructure for PhysicalDeviceGlobalPriorityQueryFeaturesKHR {
27802     const STRUCTURE_TYPE: StructureType =
27803         StructureType::PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR;
27804 }
27805 impl PhysicalDeviceGlobalPriorityQueryFeaturesKHR {
builder<'a>() -> PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a>27806     pub fn builder<'a>() -> PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> {
27807         PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder {
27808             inner: Self::default(),
27809             marker: ::std::marker::PhantomData,
27810         }
27811     }
27812 }
27813 #[repr(transparent)]
27814 pub struct PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> {
27815     inner: PhysicalDeviceGlobalPriorityQueryFeaturesKHR,
27816     marker: ::std::marker::PhantomData<&'a ()>,
27817 }
27818 unsafe impl ExtendsPhysicalDeviceFeatures2
27819     for PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'_>
27820 {
27821 }
27822 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceGlobalPriorityQueryFeaturesKHR {}
27823 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'_> {}
27824 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceGlobalPriorityQueryFeaturesKHR {}
27825 impl<'a> ::std::ops::Deref for PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> {
27826     type Target = PhysicalDeviceGlobalPriorityQueryFeaturesKHR;
deref(&self) -> &Self::Target27827     fn deref(&self) -> &Self::Target {
27828         &self.inner
27829     }
27830 }
27831 impl<'a> ::std::ops::DerefMut for PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target27832     fn deref_mut(&mut self) -> &mut Self::Target {
27833         &mut self.inner
27834     }
27835 }
27836 impl<'a> PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> {
27837     #[inline]
global_priority_query(mut self, global_priority_query: bool) -> Self27838     pub fn global_priority_query(mut self, global_priority_query: bool) -> Self {
27839         self.inner.global_priority_query = global_priority_query.into();
27840         self
27841     }
27842     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27843     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27844     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceGlobalPriorityQueryFeaturesKHR27845     pub fn build(self) -> PhysicalDeviceGlobalPriorityQueryFeaturesKHR {
27846         self.inner
27847     }
27848 }
27849 #[repr(C)]
27850 #[cfg_attr(feature = "debug", derive(Debug))]
27851 #[derive(Copy, Clone)]
27852 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyGlobalPriorityPropertiesKHR.html>"]
27853 pub struct QueueFamilyGlobalPriorityPropertiesKHR {
27854     pub s_type: StructureType,
27855     pub p_next: *mut c_void,
27856     pub priority_count: u32,
27857     pub priorities: [QueueGlobalPriorityKHR; MAX_GLOBAL_PRIORITY_SIZE_KHR],
27858 }
27859 impl ::std::default::Default for QueueFamilyGlobalPriorityPropertiesKHR {
27860     #[inline]
default() -> Self27861     fn default() -> Self {
27862         Self {
27863             s_type: Self::STRUCTURE_TYPE,
27864             p_next: ::std::ptr::null_mut(),
27865             priority_count: u32::default(),
27866             priorities: unsafe { ::std::mem::zeroed() },
27867         }
27868     }
27869 }
27870 unsafe impl TaggedStructure for QueueFamilyGlobalPriorityPropertiesKHR {
27871     const STRUCTURE_TYPE: StructureType =
27872         StructureType::QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR;
27873 }
27874 impl QueueFamilyGlobalPriorityPropertiesKHR {
builder<'a>() -> QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a>27875     pub fn builder<'a>() -> QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> {
27876         QueueFamilyGlobalPriorityPropertiesKHRBuilder {
27877             inner: Self::default(),
27878             marker: ::std::marker::PhantomData,
27879         }
27880     }
27881 }
27882 #[repr(transparent)]
27883 pub struct QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> {
27884     inner: QueueFamilyGlobalPriorityPropertiesKHR,
27885     marker: ::std::marker::PhantomData<&'a ()>,
27886 }
27887 unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyGlobalPriorityPropertiesKHRBuilder<'_> {}
27888 unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyGlobalPriorityPropertiesKHR {}
27889 impl<'a> ::std::ops::Deref for QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> {
27890     type Target = QueueFamilyGlobalPriorityPropertiesKHR;
deref(&self) -> &Self::Target27891     fn deref(&self) -> &Self::Target {
27892         &self.inner
27893     }
27894 }
27895 impl<'a> ::std::ops::DerefMut for QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target27896     fn deref_mut(&mut self) -> &mut Self::Target {
27897         &mut self.inner
27898     }
27899 }
27900 impl<'a> QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> {
27901     #[inline]
priority_count(mut self, priority_count: u32) -> Self27902     pub fn priority_count(mut self, priority_count: u32) -> Self {
27903         self.inner.priority_count = priority_count;
27904         self
27905     }
27906     #[inline]
priorities( mut self, priorities: [QueueGlobalPriorityKHR; MAX_GLOBAL_PRIORITY_SIZE_KHR], ) -> Self27907     pub fn priorities(
27908         mut self,
27909         priorities: [QueueGlobalPriorityKHR; MAX_GLOBAL_PRIORITY_SIZE_KHR],
27910     ) -> Self {
27911         self.inner.priorities = priorities;
27912         self
27913     }
27914     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27915     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27916     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> QueueFamilyGlobalPriorityPropertiesKHR27917     pub fn build(self) -> QueueFamilyGlobalPriorityPropertiesKHR {
27918         self.inner
27919     }
27920 }
27921 #[repr(C)]
27922 #[cfg_attr(feature = "debug", derive(Debug))]
27923 #[derive(Copy, Clone)]
27924 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsObjectNameInfoEXT.html>"]
27925 pub struct DebugUtilsObjectNameInfoEXT {
27926     pub s_type: StructureType,
27927     pub p_next: *const c_void,
27928     pub object_type: ObjectType,
27929     pub object_handle: u64,
27930     pub p_object_name: *const c_char,
27931 }
27932 impl ::std::default::Default for DebugUtilsObjectNameInfoEXT {
27933     #[inline]
default() -> Self27934     fn default() -> Self {
27935         Self {
27936             s_type: Self::STRUCTURE_TYPE,
27937             p_next: ::std::ptr::null(),
27938             object_type: ObjectType::default(),
27939             object_handle: u64::default(),
27940             p_object_name: ::std::ptr::null(),
27941         }
27942     }
27943 }
27944 unsafe impl TaggedStructure for DebugUtilsObjectNameInfoEXT {
27945     const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
27946 }
27947 impl DebugUtilsObjectNameInfoEXT {
builder<'a>() -> DebugUtilsObjectNameInfoEXTBuilder<'a>27948     pub fn builder<'a>() -> DebugUtilsObjectNameInfoEXTBuilder<'a> {
27949         DebugUtilsObjectNameInfoEXTBuilder {
27950             inner: Self::default(),
27951             marker: ::std::marker::PhantomData,
27952         }
27953     }
27954 }
27955 #[repr(transparent)]
27956 pub struct DebugUtilsObjectNameInfoEXTBuilder<'a> {
27957     inner: DebugUtilsObjectNameInfoEXT,
27958     marker: ::std::marker::PhantomData<&'a ()>,
27959 }
27960 unsafe impl ExtendsPipelineShaderStageCreateInfo for DebugUtilsObjectNameInfoEXTBuilder<'_> {}
27961 unsafe impl ExtendsPipelineShaderStageCreateInfo for DebugUtilsObjectNameInfoEXT {}
27962 impl<'a> ::std::ops::Deref for DebugUtilsObjectNameInfoEXTBuilder<'a> {
27963     type Target = DebugUtilsObjectNameInfoEXT;
deref(&self) -> &Self::Target27964     fn deref(&self) -> &Self::Target {
27965         &self.inner
27966     }
27967 }
27968 impl<'a> ::std::ops::DerefMut for DebugUtilsObjectNameInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target27969     fn deref_mut(&mut self) -> &mut Self::Target {
27970         &mut self.inner
27971     }
27972 }
27973 impl<'a> DebugUtilsObjectNameInfoEXTBuilder<'a> {
27974     #[inline]
object_type(mut self, object_type: ObjectType) -> Self27975     pub fn object_type(mut self, object_type: ObjectType) -> Self {
27976         self.inner.object_type = object_type;
27977         self
27978     }
27979     #[inline]
object_handle(mut self, object_handle: u64) -> Self27980     pub fn object_handle(mut self, object_handle: u64) -> Self {
27981         self.inner.object_handle = object_handle;
27982         self
27983     }
27984     #[inline]
object_name(mut self, object_name: &'a ::std::ffi::CStr) -> Self27985     pub fn object_name(mut self, object_name: &'a ::std::ffi::CStr) -> Self {
27986         self.inner.p_object_name = object_name.as_ptr();
27987         self
27988     }
27989     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27990     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27991     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DebugUtilsObjectNameInfoEXT27992     pub fn build(self) -> DebugUtilsObjectNameInfoEXT {
27993         self.inner
27994     }
27995 }
27996 #[repr(C)]
27997 #[cfg_attr(feature = "debug", derive(Debug))]
27998 #[derive(Copy, Clone)]
27999 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsObjectTagInfoEXT.html>"]
28000 pub struct DebugUtilsObjectTagInfoEXT {
28001     pub s_type: StructureType,
28002     pub p_next: *const c_void,
28003     pub object_type: ObjectType,
28004     pub object_handle: u64,
28005     pub tag_name: u64,
28006     pub tag_size: usize,
28007     pub p_tag: *const c_void,
28008 }
28009 impl ::std::default::Default for DebugUtilsObjectTagInfoEXT {
28010     #[inline]
default() -> Self28011     fn default() -> Self {
28012         Self {
28013             s_type: Self::STRUCTURE_TYPE,
28014             p_next: ::std::ptr::null(),
28015             object_type: ObjectType::default(),
28016             object_handle: u64::default(),
28017             tag_name: u64::default(),
28018             tag_size: usize::default(),
28019             p_tag: ::std::ptr::null(),
28020         }
28021     }
28022 }
28023 unsafe impl TaggedStructure for DebugUtilsObjectTagInfoEXT {
28024     const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_UTILS_OBJECT_TAG_INFO_EXT;
28025 }
28026 impl DebugUtilsObjectTagInfoEXT {
builder<'a>() -> DebugUtilsObjectTagInfoEXTBuilder<'a>28027     pub fn builder<'a>() -> DebugUtilsObjectTagInfoEXTBuilder<'a> {
28028         DebugUtilsObjectTagInfoEXTBuilder {
28029             inner: Self::default(),
28030             marker: ::std::marker::PhantomData,
28031         }
28032     }
28033 }
28034 #[repr(transparent)]
28035 pub struct DebugUtilsObjectTagInfoEXTBuilder<'a> {
28036     inner: DebugUtilsObjectTagInfoEXT,
28037     marker: ::std::marker::PhantomData<&'a ()>,
28038 }
28039 impl<'a> ::std::ops::Deref for DebugUtilsObjectTagInfoEXTBuilder<'a> {
28040     type Target = DebugUtilsObjectTagInfoEXT;
deref(&self) -> &Self::Target28041     fn deref(&self) -> &Self::Target {
28042         &self.inner
28043     }
28044 }
28045 impl<'a> ::std::ops::DerefMut for DebugUtilsObjectTagInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target28046     fn deref_mut(&mut self) -> &mut Self::Target {
28047         &mut self.inner
28048     }
28049 }
28050 impl<'a> DebugUtilsObjectTagInfoEXTBuilder<'a> {
28051     #[inline]
object_type(mut self, object_type: ObjectType) -> Self28052     pub fn object_type(mut self, object_type: ObjectType) -> Self {
28053         self.inner.object_type = object_type;
28054         self
28055     }
28056     #[inline]
object_handle(mut self, object_handle: u64) -> Self28057     pub fn object_handle(mut self, object_handle: u64) -> Self {
28058         self.inner.object_handle = object_handle;
28059         self
28060     }
28061     #[inline]
tag_name(mut self, tag_name: u64) -> Self28062     pub fn tag_name(mut self, tag_name: u64) -> Self {
28063         self.inner.tag_name = tag_name;
28064         self
28065     }
28066     #[inline]
tag(mut self, tag: &'a [u8]) -> Self28067     pub fn tag(mut self, tag: &'a [u8]) -> Self {
28068         self.inner.tag_size = tag.len();
28069         self.inner.p_tag = tag.as_ptr().cast();
28070         self
28071     }
28072     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28073     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28074     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DebugUtilsObjectTagInfoEXT28075     pub fn build(self) -> DebugUtilsObjectTagInfoEXT {
28076         self.inner
28077     }
28078 }
28079 #[repr(C)]
28080 #[cfg_attr(feature = "debug", derive(Debug))]
28081 #[derive(Copy, Clone)]
28082 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsLabelEXT.html>"]
28083 pub struct DebugUtilsLabelEXT {
28084     pub s_type: StructureType,
28085     pub p_next: *const c_void,
28086     pub p_label_name: *const c_char,
28087     pub color: [f32; 4],
28088 }
28089 impl ::std::default::Default for DebugUtilsLabelEXT {
28090     #[inline]
default() -> Self28091     fn default() -> Self {
28092         Self {
28093             s_type: Self::STRUCTURE_TYPE,
28094             p_next: ::std::ptr::null(),
28095             p_label_name: ::std::ptr::null(),
28096             color: unsafe { ::std::mem::zeroed() },
28097         }
28098     }
28099 }
28100 unsafe impl TaggedStructure for DebugUtilsLabelEXT {
28101     const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_UTILS_LABEL_EXT;
28102 }
28103 impl DebugUtilsLabelEXT {
builder<'a>() -> DebugUtilsLabelEXTBuilder<'a>28104     pub fn builder<'a>() -> DebugUtilsLabelEXTBuilder<'a> {
28105         DebugUtilsLabelEXTBuilder {
28106             inner: Self::default(),
28107             marker: ::std::marker::PhantomData,
28108         }
28109     }
28110 }
28111 #[repr(transparent)]
28112 pub struct DebugUtilsLabelEXTBuilder<'a> {
28113     inner: DebugUtilsLabelEXT,
28114     marker: ::std::marker::PhantomData<&'a ()>,
28115 }
28116 impl<'a> ::std::ops::Deref for DebugUtilsLabelEXTBuilder<'a> {
28117     type Target = DebugUtilsLabelEXT;
deref(&self) -> &Self::Target28118     fn deref(&self) -> &Self::Target {
28119         &self.inner
28120     }
28121 }
28122 impl<'a> ::std::ops::DerefMut for DebugUtilsLabelEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target28123     fn deref_mut(&mut self) -> &mut Self::Target {
28124         &mut self.inner
28125     }
28126 }
28127 impl<'a> DebugUtilsLabelEXTBuilder<'a> {
28128     #[inline]
label_name(mut self, label_name: &'a ::std::ffi::CStr) -> Self28129     pub fn label_name(mut self, label_name: &'a ::std::ffi::CStr) -> Self {
28130         self.inner.p_label_name = label_name.as_ptr();
28131         self
28132     }
28133     #[inline]
color(mut self, color: [f32; 4]) -> Self28134     pub fn color(mut self, color: [f32; 4]) -> Self {
28135         self.inner.color = color;
28136         self
28137     }
28138     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28139     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28140     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DebugUtilsLabelEXT28141     pub fn build(self) -> DebugUtilsLabelEXT {
28142         self.inner
28143     }
28144 }
28145 #[repr(C)]
28146 #[derive(Copy, Clone)]
28147 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessengerCreateInfoEXT.html>"]
28148 pub struct DebugUtilsMessengerCreateInfoEXT {
28149     pub s_type: StructureType,
28150     pub p_next: *const c_void,
28151     pub flags: DebugUtilsMessengerCreateFlagsEXT,
28152     pub message_severity: DebugUtilsMessageSeverityFlagsEXT,
28153     pub message_type: DebugUtilsMessageTypeFlagsEXT,
28154     pub pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT,
28155     pub p_user_data: *mut c_void,
28156 }
28157 #[cfg(feature = "debug")]
28158 impl fmt::Debug for DebugUtilsMessengerCreateInfoEXT {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result28159     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
28160         fmt.debug_struct("DebugUtilsMessengerCreateInfoEXT")
28161             .field("s_type", &self.s_type)
28162             .field("p_next", &self.p_next)
28163             .field("flags", &self.flags)
28164             .field("message_severity", &self.message_severity)
28165             .field("message_type", &self.message_type)
28166             .field(
28167                 "pfn_user_callback",
28168                 &(self.pfn_user_callback.map(|x| x as *const ())),
28169             )
28170             .field("p_user_data", &self.p_user_data)
28171             .finish()
28172     }
28173 }
28174 impl ::std::default::Default for DebugUtilsMessengerCreateInfoEXT {
28175     #[inline]
default() -> Self28176     fn default() -> Self {
28177         Self {
28178             s_type: Self::STRUCTURE_TYPE,
28179             p_next: ::std::ptr::null(),
28180             flags: DebugUtilsMessengerCreateFlagsEXT::default(),
28181             message_severity: DebugUtilsMessageSeverityFlagsEXT::default(),
28182             message_type: DebugUtilsMessageTypeFlagsEXT::default(),
28183             pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT::default(),
28184             p_user_data: ::std::ptr::null_mut(),
28185         }
28186     }
28187 }
28188 unsafe impl TaggedStructure for DebugUtilsMessengerCreateInfoEXT {
28189     const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
28190 }
28191 impl DebugUtilsMessengerCreateInfoEXT {
builder<'a>() -> DebugUtilsMessengerCreateInfoEXTBuilder<'a>28192     pub fn builder<'a>() -> DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
28193         DebugUtilsMessengerCreateInfoEXTBuilder {
28194             inner: Self::default(),
28195             marker: ::std::marker::PhantomData,
28196         }
28197     }
28198 }
28199 #[repr(transparent)]
28200 pub struct DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
28201     inner: DebugUtilsMessengerCreateInfoEXT,
28202     marker: ::std::marker::PhantomData<&'a ()>,
28203 }
28204 unsafe impl ExtendsInstanceCreateInfo for DebugUtilsMessengerCreateInfoEXTBuilder<'_> {}
28205 unsafe impl ExtendsInstanceCreateInfo for DebugUtilsMessengerCreateInfoEXT {}
28206 impl<'a> ::std::ops::Deref for DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
28207     type Target = DebugUtilsMessengerCreateInfoEXT;
deref(&self) -> &Self::Target28208     fn deref(&self) -> &Self::Target {
28209         &self.inner
28210     }
28211 }
28212 impl<'a> ::std::ops::DerefMut for DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target28213     fn deref_mut(&mut self) -> &mut Self::Target {
28214         &mut self.inner
28215     }
28216 }
28217 impl<'a> DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
28218     #[inline]
flags(mut self, flags: DebugUtilsMessengerCreateFlagsEXT) -> Self28219     pub fn flags(mut self, flags: DebugUtilsMessengerCreateFlagsEXT) -> Self {
28220         self.inner.flags = flags;
28221         self
28222     }
28223     #[inline]
message_severity(mut self, message_severity: DebugUtilsMessageSeverityFlagsEXT) -> Self28224     pub fn message_severity(mut self, message_severity: DebugUtilsMessageSeverityFlagsEXT) -> Self {
28225         self.inner.message_severity = message_severity;
28226         self
28227     }
28228     #[inline]
message_type(mut self, message_type: DebugUtilsMessageTypeFlagsEXT) -> Self28229     pub fn message_type(mut self, message_type: DebugUtilsMessageTypeFlagsEXT) -> Self {
28230         self.inner.message_type = message_type;
28231         self
28232     }
28233     #[inline]
pfn_user_callback( mut self, pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT, ) -> Self28234     pub fn pfn_user_callback(
28235         mut self,
28236         pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT,
28237     ) -> Self {
28238         self.inner.pfn_user_callback = pfn_user_callback;
28239         self
28240     }
28241     #[inline]
user_data(mut self, user_data: *mut c_void) -> Self28242     pub fn user_data(mut self, user_data: *mut c_void) -> Self {
28243         self.inner.p_user_data = user_data;
28244         self
28245     }
28246     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28247     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28248     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DebugUtilsMessengerCreateInfoEXT28249     pub fn build(self) -> DebugUtilsMessengerCreateInfoEXT {
28250         self.inner
28251     }
28252 }
28253 #[repr(C)]
28254 #[cfg_attr(feature = "debug", derive(Debug))]
28255 #[derive(Copy, Clone)]
28256 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessengerCallbackDataEXT.html>"]
28257 pub struct DebugUtilsMessengerCallbackDataEXT {
28258     pub s_type: StructureType,
28259     pub p_next: *const c_void,
28260     pub flags: DebugUtilsMessengerCallbackDataFlagsEXT,
28261     pub p_message_id_name: *const c_char,
28262     pub message_id_number: i32,
28263     pub p_message: *const c_char,
28264     pub queue_label_count: u32,
28265     pub p_queue_labels: *const DebugUtilsLabelEXT,
28266     pub cmd_buf_label_count: u32,
28267     pub p_cmd_buf_labels: *const DebugUtilsLabelEXT,
28268     pub object_count: u32,
28269     pub p_objects: *const DebugUtilsObjectNameInfoEXT,
28270 }
28271 impl ::std::default::Default for DebugUtilsMessengerCallbackDataEXT {
28272     #[inline]
default() -> Self28273     fn default() -> Self {
28274         Self {
28275             s_type: Self::STRUCTURE_TYPE,
28276             p_next: ::std::ptr::null(),
28277             flags: DebugUtilsMessengerCallbackDataFlagsEXT::default(),
28278             p_message_id_name: ::std::ptr::null(),
28279             message_id_number: i32::default(),
28280             p_message: ::std::ptr::null(),
28281             queue_label_count: u32::default(),
28282             p_queue_labels: ::std::ptr::null(),
28283             cmd_buf_label_count: u32::default(),
28284             p_cmd_buf_labels: ::std::ptr::null(),
28285             object_count: u32::default(),
28286             p_objects: ::std::ptr::null(),
28287         }
28288     }
28289 }
28290 unsafe impl TaggedStructure for DebugUtilsMessengerCallbackDataEXT {
28291     const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT;
28292 }
28293 impl DebugUtilsMessengerCallbackDataEXT {
builder<'a>() -> DebugUtilsMessengerCallbackDataEXTBuilder<'a>28294     pub fn builder<'a>() -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
28295         DebugUtilsMessengerCallbackDataEXTBuilder {
28296             inner: Self::default(),
28297             marker: ::std::marker::PhantomData,
28298         }
28299     }
28300 }
28301 #[repr(transparent)]
28302 pub struct DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
28303     inner: DebugUtilsMessengerCallbackDataEXT,
28304     marker: ::std::marker::PhantomData<&'a ()>,
28305 }
28306 pub unsafe trait ExtendsDebugUtilsMessengerCallbackDataEXT {}
28307 impl<'a> ::std::ops::Deref for DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
28308     type Target = DebugUtilsMessengerCallbackDataEXT;
deref(&self) -> &Self::Target28309     fn deref(&self) -> &Self::Target {
28310         &self.inner
28311     }
28312 }
28313 impl<'a> ::std::ops::DerefMut for DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target28314     fn deref_mut(&mut self) -> &mut Self::Target {
28315         &mut self.inner
28316     }
28317 }
28318 impl<'a> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
28319     #[inline]
flags(mut self, flags: DebugUtilsMessengerCallbackDataFlagsEXT) -> Self28320     pub fn flags(mut self, flags: DebugUtilsMessengerCallbackDataFlagsEXT) -> Self {
28321         self.inner.flags = flags;
28322         self
28323     }
28324     #[inline]
message_id_name(mut self, message_id_name: &'a ::std::ffi::CStr) -> Self28325     pub fn message_id_name(mut self, message_id_name: &'a ::std::ffi::CStr) -> Self {
28326         self.inner.p_message_id_name = message_id_name.as_ptr();
28327         self
28328     }
28329     #[inline]
message_id_number(mut self, message_id_number: i32) -> Self28330     pub fn message_id_number(mut self, message_id_number: i32) -> Self {
28331         self.inner.message_id_number = message_id_number;
28332         self
28333     }
28334     #[inline]
message(mut self, message: &'a ::std::ffi::CStr) -> Self28335     pub fn message(mut self, message: &'a ::std::ffi::CStr) -> Self {
28336         self.inner.p_message = message.as_ptr();
28337         self
28338     }
28339     #[inline]
queue_labels(mut self, queue_labels: &'a [DebugUtilsLabelEXT]) -> Self28340     pub fn queue_labels(mut self, queue_labels: &'a [DebugUtilsLabelEXT]) -> Self {
28341         self.inner.queue_label_count = queue_labels.len() as _;
28342         self.inner.p_queue_labels = queue_labels.as_ptr();
28343         self
28344     }
28345     #[inline]
cmd_buf_labels(mut self, cmd_buf_labels: &'a [DebugUtilsLabelEXT]) -> Self28346     pub fn cmd_buf_labels(mut self, cmd_buf_labels: &'a [DebugUtilsLabelEXT]) -> Self {
28347         self.inner.cmd_buf_label_count = cmd_buf_labels.len() as _;
28348         self.inner.p_cmd_buf_labels = cmd_buf_labels.as_ptr();
28349         self
28350     }
28351     #[inline]
objects(mut self, objects: &'a [DebugUtilsObjectNameInfoEXT]) -> Self28352     pub fn objects(mut self, objects: &'a [DebugUtilsObjectNameInfoEXT]) -> Self {
28353         self.inner.object_count = objects.len() as _;
28354         self.inner.p_objects = objects.as_ptr();
28355         self
28356     }
28357     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
28358     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
28359     #[doc = r" valid extension structs can be pushed into the chain."]
28360     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
28361     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDebugUtilsMessengerCallbackDataEXT>( mut self, next: &'a mut T, ) -> Self28362     pub fn push_next<T: ExtendsDebugUtilsMessengerCallbackDataEXT>(
28363         mut self,
28364         next: &'a mut T,
28365     ) -> Self {
28366         unsafe {
28367             let next_ptr = <*const T>::cast(next);
28368             let last_next = ptr_chain_iter(next).last().unwrap();
28369             (*last_next).p_next = self.inner.p_next as _;
28370             self.inner.p_next = next_ptr;
28371         }
28372         self
28373     }
28374     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28375     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28376     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DebugUtilsMessengerCallbackDataEXT28377     pub fn build(self) -> DebugUtilsMessengerCallbackDataEXT {
28378         self.inner
28379     }
28380 }
28381 #[repr(C)]
28382 #[cfg_attr(feature = "debug", derive(Debug))]
28383 #[derive(Copy, Clone)]
28384 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDeviceMemoryReportFeaturesEXT.html>"]
28385 pub struct PhysicalDeviceDeviceMemoryReportFeaturesEXT {
28386     pub s_type: StructureType,
28387     pub p_next: *mut c_void,
28388     pub device_memory_report: Bool32,
28389 }
28390 impl ::std::default::Default for PhysicalDeviceDeviceMemoryReportFeaturesEXT {
28391     #[inline]
default() -> Self28392     fn default() -> Self {
28393         Self {
28394             s_type: Self::STRUCTURE_TYPE,
28395             p_next: ::std::ptr::null_mut(),
28396             device_memory_report: Bool32::default(),
28397         }
28398     }
28399 }
28400 unsafe impl TaggedStructure for PhysicalDeviceDeviceMemoryReportFeaturesEXT {
28401     const STRUCTURE_TYPE: StructureType =
28402         StructureType::PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT;
28403 }
28404 impl PhysicalDeviceDeviceMemoryReportFeaturesEXT {
builder<'a>() -> PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a>28405     pub fn builder<'a>() -> PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> {
28406         PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder {
28407             inner: Self::default(),
28408             marker: ::std::marker::PhantomData,
28409         }
28410     }
28411 }
28412 #[repr(transparent)]
28413 pub struct PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> {
28414     inner: PhysicalDeviceDeviceMemoryReportFeaturesEXT,
28415     marker: ::std::marker::PhantomData<&'a ()>,
28416 }
28417 unsafe impl ExtendsPhysicalDeviceFeatures2
28418     for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'_>
28419 {
28420 }
28421 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDeviceMemoryReportFeaturesEXT {}
28422 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'_> {}
28423 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceMemoryReportFeaturesEXT {}
28424 impl<'a> ::std::ops::Deref for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> {
28425     type Target = PhysicalDeviceDeviceMemoryReportFeaturesEXT;
deref(&self) -> &Self::Target28426     fn deref(&self) -> &Self::Target {
28427         &self.inner
28428     }
28429 }
28430 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target28431     fn deref_mut(&mut self) -> &mut Self::Target {
28432         &mut self.inner
28433     }
28434 }
28435 impl<'a> PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> {
28436     #[inline]
device_memory_report(mut self, device_memory_report: bool) -> Self28437     pub fn device_memory_report(mut self, device_memory_report: bool) -> Self {
28438         self.inner.device_memory_report = device_memory_report.into();
28439         self
28440     }
28441     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28442     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28443     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDeviceMemoryReportFeaturesEXT28444     pub fn build(self) -> PhysicalDeviceDeviceMemoryReportFeaturesEXT {
28445         self.inner
28446     }
28447 }
28448 #[repr(C)]
28449 #[derive(Copy, Clone)]
28450 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceDeviceMemoryReportCreateInfoEXT.html>"]
28451 pub struct DeviceDeviceMemoryReportCreateInfoEXT {
28452     pub s_type: StructureType,
28453     pub p_next: *const c_void,
28454     pub flags: DeviceMemoryReportFlagsEXT,
28455     pub pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT,
28456     pub p_user_data: *mut c_void,
28457 }
28458 #[cfg(feature = "debug")]
28459 impl fmt::Debug for DeviceDeviceMemoryReportCreateInfoEXT {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result28460     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
28461         fmt.debug_struct("DeviceDeviceMemoryReportCreateInfoEXT")
28462             .field("s_type", &self.s_type)
28463             .field("p_next", &self.p_next)
28464             .field("flags", &self.flags)
28465             .field(
28466                 "pfn_user_callback",
28467                 &(self.pfn_user_callback.map(|x| x as *const ())),
28468             )
28469             .field("p_user_data", &self.p_user_data)
28470             .finish()
28471     }
28472 }
28473 impl ::std::default::Default for DeviceDeviceMemoryReportCreateInfoEXT {
28474     #[inline]
default() -> Self28475     fn default() -> Self {
28476         Self {
28477             s_type: Self::STRUCTURE_TYPE,
28478             p_next: ::std::ptr::null(),
28479             flags: DeviceMemoryReportFlagsEXT::default(),
28480             pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT::default(),
28481             p_user_data: ::std::ptr::null_mut(),
28482         }
28483     }
28484 }
28485 unsafe impl TaggedStructure for DeviceDeviceMemoryReportCreateInfoEXT {
28486     const STRUCTURE_TYPE: StructureType =
28487         StructureType::DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT;
28488 }
28489 impl DeviceDeviceMemoryReportCreateInfoEXT {
builder<'a>() -> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a>28490     pub fn builder<'a>() -> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
28491         DeviceDeviceMemoryReportCreateInfoEXTBuilder {
28492             inner: Self::default(),
28493             marker: ::std::marker::PhantomData,
28494         }
28495     }
28496 }
28497 #[repr(transparent)]
28498 pub struct DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
28499     inner: DeviceDeviceMemoryReportCreateInfoEXT,
28500     marker: ::std::marker::PhantomData<&'a ()>,
28501 }
28502 unsafe impl ExtendsDeviceCreateInfo for DeviceDeviceMemoryReportCreateInfoEXTBuilder<'_> {}
28503 unsafe impl ExtendsDeviceCreateInfo for DeviceDeviceMemoryReportCreateInfoEXT {}
28504 impl<'a> ::std::ops::Deref for DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
28505     type Target = DeviceDeviceMemoryReportCreateInfoEXT;
deref(&self) -> &Self::Target28506     fn deref(&self) -> &Self::Target {
28507         &self.inner
28508     }
28509 }
28510 impl<'a> ::std::ops::DerefMut for DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target28511     fn deref_mut(&mut self) -> &mut Self::Target {
28512         &mut self.inner
28513     }
28514 }
28515 impl<'a> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
28516     #[inline]
flags(mut self, flags: DeviceMemoryReportFlagsEXT) -> Self28517     pub fn flags(mut self, flags: DeviceMemoryReportFlagsEXT) -> Self {
28518         self.inner.flags = flags;
28519         self
28520     }
28521     #[inline]
pfn_user_callback( mut self, pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT, ) -> Self28522     pub fn pfn_user_callback(
28523         mut self,
28524         pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT,
28525     ) -> Self {
28526         self.inner.pfn_user_callback = pfn_user_callback;
28527         self
28528     }
28529     #[inline]
user_data(mut self, user_data: *mut c_void) -> Self28530     pub fn user_data(mut self, user_data: *mut c_void) -> Self {
28531         self.inner.p_user_data = user_data;
28532         self
28533     }
28534     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28535     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28536     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceDeviceMemoryReportCreateInfoEXT28537     pub fn build(self) -> DeviceDeviceMemoryReportCreateInfoEXT {
28538         self.inner
28539     }
28540 }
28541 #[repr(C)]
28542 #[cfg_attr(feature = "debug", derive(Debug))]
28543 #[derive(Copy, Clone)]
28544 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceMemoryReportCallbackDataEXT.html>"]
28545 pub struct DeviceMemoryReportCallbackDataEXT {
28546     pub s_type: StructureType,
28547     pub p_next: *mut c_void,
28548     pub flags: DeviceMemoryReportFlagsEXT,
28549     pub ty: DeviceMemoryReportEventTypeEXT,
28550     pub memory_object_id: u64,
28551     pub size: DeviceSize,
28552     pub object_type: ObjectType,
28553     pub object_handle: u64,
28554     pub heap_index: u32,
28555 }
28556 impl ::std::default::Default for DeviceMemoryReportCallbackDataEXT {
28557     #[inline]
default() -> Self28558     fn default() -> Self {
28559         Self {
28560             s_type: Self::STRUCTURE_TYPE,
28561             p_next: ::std::ptr::null_mut(),
28562             flags: DeviceMemoryReportFlagsEXT::default(),
28563             ty: DeviceMemoryReportEventTypeEXT::default(),
28564             memory_object_id: u64::default(),
28565             size: DeviceSize::default(),
28566             object_type: ObjectType::default(),
28567             object_handle: u64::default(),
28568             heap_index: u32::default(),
28569         }
28570     }
28571 }
28572 unsafe impl TaggedStructure for DeviceMemoryReportCallbackDataEXT {
28573     const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT;
28574 }
28575 impl DeviceMemoryReportCallbackDataEXT {
builder<'a>() -> DeviceMemoryReportCallbackDataEXTBuilder<'a>28576     pub fn builder<'a>() -> DeviceMemoryReportCallbackDataEXTBuilder<'a> {
28577         DeviceMemoryReportCallbackDataEXTBuilder {
28578             inner: Self::default(),
28579             marker: ::std::marker::PhantomData,
28580         }
28581     }
28582 }
28583 #[repr(transparent)]
28584 pub struct DeviceMemoryReportCallbackDataEXTBuilder<'a> {
28585     inner: DeviceMemoryReportCallbackDataEXT,
28586     marker: ::std::marker::PhantomData<&'a ()>,
28587 }
28588 impl<'a> ::std::ops::Deref for DeviceMemoryReportCallbackDataEXTBuilder<'a> {
28589     type Target = DeviceMemoryReportCallbackDataEXT;
deref(&self) -> &Self::Target28590     fn deref(&self) -> &Self::Target {
28591         &self.inner
28592     }
28593 }
28594 impl<'a> ::std::ops::DerefMut for DeviceMemoryReportCallbackDataEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target28595     fn deref_mut(&mut self) -> &mut Self::Target {
28596         &mut self.inner
28597     }
28598 }
28599 impl<'a> DeviceMemoryReportCallbackDataEXTBuilder<'a> {
28600     #[inline]
flags(mut self, flags: DeviceMemoryReportFlagsEXT) -> Self28601     pub fn flags(mut self, flags: DeviceMemoryReportFlagsEXT) -> Self {
28602         self.inner.flags = flags;
28603         self
28604     }
28605     #[inline]
ty(mut self, ty: DeviceMemoryReportEventTypeEXT) -> Self28606     pub fn ty(mut self, ty: DeviceMemoryReportEventTypeEXT) -> Self {
28607         self.inner.ty = ty;
28608         self
28609     }
28610     #[inline]
memory_object_id(mut self, memory_object_id: u64) -> Self28611     pub fn memory_object_id(mut self, memory_object_id: u64) -> Self {
28612         self.inner.memory_object_id = memory_object_id;
28613         self
28614     }
28615     #[inline]
size(mut self, size: DeviceSize) -> Self28616     pub fn size(mut self, size: DeviceSize) -> Self {
28617         self.inner.size = size;
28618         self
28619     }
28620     #[inline]
object_type(mut self, object_type: ObjectType) -> Self28621     pub fn object_type(mut self, object_type: ObjectType) -> Self {
28622         self.inner.object_type = object_type;
28623         self
28624     }
28625     #[inline]
object_handle(mut self, object_handle: u64) -> Self28626     pub fn object_handle(mut self, object_handle: u64) -> Self {
28627         self.inner.object_handle = object_handle;
28628         self
28629     }
28630     #[inline]
heap_index(mut self, heap_index: u32) -> Self28631     pub fn heap_index(mut self, heap_index: u32) -> Self {
28632         self.inner.heap_index = heap_index;
28633         self
28634     }
28635     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28636     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28637     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceMemoryReportCallbackDataEXT28638     pub fn build(self) -> DeviceMemoryReportCallbackDataEXT {
28639         self.inner
28640     }
28641 }
28642 #[repr(C)]
28643 #[cfg_attr(feature = "debug", derive(Debug))]
28644 #[derive(Copy, Clone)]
28645 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMemoryHostPointerInfoEXT.html>"]
28646 pub struct ImportMemoryHostPointerInfoEXT {
28647     pub s_type: StructureType,
28648     pub p_next: *const c_void,
28649     pub handle_type: ExternalMemoryHandleTypeFlags,
28650     pub p_host_pointer: *mut c_void,
28651 }
28652 impl ::std::default::Default for ImportMemoryHostPointerInfoEXT {
28653     #[inline]
default() -> Self28654     fn default() -> Self {
28655         Self {
28656             s_type: Self::STRUCTURE_TYPE,
28657             p_next: ::std::ptr::null(),
28658             handle_type: ExternalMemoryHandleTypeFlags::default(),
28659             p_host_pointer: ::std::ptr::null_mut(),
28660         }
28661     }
28662 }
28663 unsafe impl TaggedStructure for ImportMemoryHostPointerInfoEXT {
28664     const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_MEMORY_HOST_POINTER_INFO_EXT;
28665 }
28666 impl ImportMemoryHostPointerInfoEXT {
builder<'a>() -> ImportMemoryHostPointerInfoEXTBuilder<'a>28667     pub fn builder<'a>() -> ImportMemoryHostPointerInfoEXTBuilder<'a> {
28668         ImportMemoryHostPointerInfoEXTBuilder {
28669             inner: Self::default(),
28670             marker: ::std::marker::PhantomData,
28671         }
28672     }
28673 }
28674 #[repr(transparent)]
28675 pub struct ImportMemoryHostPointerInfoEXTBuilder<'a> {
28676     inner: ImportMemoryHostPointerInfoEXT,
28677     marker: ::std::marker::PhantomData<&'a ()>,
28678 }
28679 unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryHostPointerInfoEXTBuilder<'_> {}
28680 unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryHostPointerInfoEXT {}
28681 impl<'a> ::std::ops::Deref for ImportMemoryHostPointerInfoEXTBuilder<'a> {
28682     type Target = ImportMemoryHostPointerInfoEXT;
deref(&self) -> &Self::Target28683     fn deref(&self) -> &Self::Target {
28684         &self.inner
28685     }
28686 }
28687 impl<'a> ::std::ops::DerefMut for ImportMemoryHostPointerInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target28688     fn deref_mut(&mut self) -> &mut Self::Target {
28689         &mut self.inner
28690     }
28691 }
28692 impl<'a> ImportMemoryHostPointerInfoEXTBuilder<'a> {
28693     #[inline]
handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self28694     pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
28695         self.inner.handle_type = handle_type;
28696         self
28697     }
28698     #[inline]
host_pointer(mut self, host_pointer: *mut c_void) -> Self28699     pub fn host_pointer(mut self, host_pointer: *mut c_void) -> Self {
28700         self.inner.p_host_pointer = host_pointer;
28701         self
28702     }
28703     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28704     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28705     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImportMemoryHostPointerInfoEXT28706     pub fn build(self) -> ImportMemoryHostPointerInfoEXT {
28707         self.inner
28708     }
28709 }
28710 #[repr(C)]
28711 #[cfg_attr(feature = "debug", derive(Debug))]
28712 #[derive(Copy, Clone)]
28713 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryHostPointerPropertiesEXT.html>"]
28714 pub struct MemoryHostPointerPropertiesEXT {
28715     pub s_type: StructureType,
28716     pub p_next: *mut c_void,
28717     pub memory_type_bits: u32,
28718 }
28719 impl ::std::default::Default for MemoryHostPointerPropertiesEXT {
28720     #[inline]
default() -> Self28721     fn default() -> Self {
28722         Self {
28723             s_type: Self::STRUCTURE_TYPE,
28724             p_next: ::std::ptr::null_mut(),
28725             memory_type_bits: u32::default(),
28726         }
28727     }
28728 }
28729 unsafe impl TaggedStructure for MemoryHostPointerPropertiesEXT {
28730     const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_HOST_POINTER_PROPERTIES_EXT;
28731 }
28732 impl MemoryHostPointerPropertiesEXT {
builder<'a>() -> MemoryHostPointerPropertiesEXTBuilder<'a>28733     pub fn builder<'a>() -> MemoryHostPointerPropertiesEXTBuilder<'a> {
28734         MemoryHostPointerPropertiesEXTBuilder {
28735             inner: Self::default(),
28736             marker: ::std::marker::PhantomData,
28737         }
28738     }
28739 }
28740 #[repr(transparent)]
28741 pub struct MemoryHostPointerPropertiesEXTBuilder<'a> {
28742     inner: MemoryHostPointerPropertiesEXT,
28743     marker: ::std::marker::PhantomData<&'a ()>,
28744 }
28745 impl<'a> ::std::ops::Deref for MemoryHostPointerPropertiesEXTBuilder<'a> {
28746     type Target = MemoryHostPointerPropertiesEXT;
deref(&self) -> &Self::Target28747     fn deref(&self) -> &Self::Target {
28748         &self.inner
28749     }
28750 }
28751 impl<'a> ::std::ops::DerefMut for MemoryHostPointerPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target28752     fn deref_mut(&mut self) -> &mut Self::Target {
28753         &mut self.inner
28754     }
28755 }
28756 impl<'a> MemoryHostPointerPropertiesEXTBuilder<'a> {
28757     #[inline]
memory_type_bits(mut self, memory_type_bits: u32) -> Self28758     pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self {
28759         self.inner.memory_type_bits = memory_type_bits;
28760         self
28761     }
28762     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28763     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28764     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryHostPointerPropertiesEXT28765     pub fn build(self) -> MemoryHostPointerPropertiesEXT {
28766         self.inner
28767     }
28768 }
28769 #[repr(C)]
28770 #[cfg_attr(feature = "debug", derive(Debug))]
28771 #[derive(Copy, Clone)]
28772 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalMemoryHostPropertiesEXT.html>"]
28773 pub struct PhysicalDeviceExternalMemoryHostPropertiesEXT {
28774     pub s_type: StructureType,
28775     pub p_next: *mut c_void,
28776     pub min_imported_host_pointer_alignment: DeviceSize,
28777 }
28778 impl ::std::default::Default for PhysicalDeviceExternalMemoryHostPropertiesEXT {
28779     #[inline]
default() -> Self28780     fn default() -> Self {
28781         Self {
28782             s_type: Self::STRUCTURE_TYPE,
28783             p_next: ::std::ptr::null_mut(),
28784             min_imported_host_pointer_alignment: DeviceSize::default(),
28785         }
28786     }
28787 }
28788 unsafe impl TaggedStructure for PhysicalDeviceExternalMemoryHostPropertiesEXT {
28789     const STRUCTURE_TYPE: StructureType =
28790         StructureType::PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT;
28791 }
28792 impl PhysicalDeviceExternalMemoryHostPropertiesEXT {
builder<'a>() -> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a>28793     pub fn builder<'a>() -> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
28794         PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder {
28795             inner: Self::default(),
28796             marker: ::std::marker::PhantomData,
28797         }
28798     }
28799 }
28800 #[repr(transparent)]
28801 pub struct PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
28802     inner: PhysicalDeviceExternalMemoryHostPropertiesEXT,
28803     marker: ::std::marker::PhantomData<&'a ()>,
28804 }
28805 unsafe impl ExtendsPhysicalDeviceProperties2
28806     for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'_>
28807 {
28808 }
28809 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceExternalMemoryHostPropertiesEXT {}
28810 impl<'a> ::std::ops::Deref for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
28811     type Target = PhysicalDeviceExternalMemoryHostPropertiesEXT;
deref(&self) -> &Self::Target28812     fn deref(&self) -> &Self::Target {
28813         &self.inner
28814     }
28815 }
28816 impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target28817     fn deref_mut(&mut self) -> &mut Self::Target {
28818         &mut self.inner
28819     }
28820 }
28821 impl<'a> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
28822     #[inline]
min_imported_host_pointer_alignment( mut self, min_imported_host_pointer_alignment: DeviceSize, ) -> Self28823     pub fn min_imported_host_pointer_alignment(
28824         mut self,
28825         min_imported_host_pointer_alignment: DeviceSize,
28826     ) -> Self {
28827         self.inner.min_imported_host_pointer_alignment = min_imported_host_pointer_alignment;
28828         self
28829     }
28830     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28831     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28832     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceExternalMemoryHostPropertiesEXT28833     pub fn build(self) -> PhysicalDeviceExternalMemoryHostPropertiesEXT {
28834         self.inner
28835     }
28836 }
28837 #[repr(C)]
28838 #[cfg_attr(feature = "debug", derive(Debug))]
28839 #[derive(Copy, Clone)]
28840 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceConservativeRasterizationPropertiesEXT.html>"]
28841 pub struct PhysicalDeviceConservativeRasterizationPropertiesEXT {
28842     pub s_type: StructureType,
28843     pub p_next: *mut c_void,
28844     pub primitive_overestimation_size: f32,
28845     pub max_extra_primitive_overestimation_size: f32,
28846     pub extra_primitive_overestimation_size_granularity: f32,
28847     pub primitive_underestimation: Bool32,
28848     pub conservative_point_and_line_rasterization: Bool32,
28849     pub degenerate_triangles_rasterized: Bool32,
28850     pub degenerate_lines_rasterized: Bool32,
28851     pub fully_covered_fragment_shader_input_variable: Bool32,
28852     pub conservative_rasterization_post_depth_coverage: Bool32,
28853 }
28854 impl ::std::default::Default for PhysicalDeviceConservativeRasterizationPropertiesEXT {
28855     #[inline]
default() -> Self28856     fn default() -> Self {
28857         Self {
28858             s_type: Self::STRUCTURE_TYPE,
28859             p_next: ::std::ptr::null_mut(),
28860             primitive_overestimation_size: f32::default(),
28861             max_extra_primitive_overestimation_size: f32::default(),
28862             extra_primitive_overestimation_size_granularity: f32::default(),
28863             primitive_underestimation: Bool32::default(),
28864             conservative_point_and_line_rasterization: Bool32::default(),
28865             degenerate_triangles_rasterized: Bool32::default(),
28866             degenerate_lines_rasterized: Bool32::default(),
28867             fully_covered_fragment_shader_input_variable: Bool32::default(),
28868             conservative_rasterization_post_depth_coverage: Bool32::default(),
28869         }
28870     }
28871 }
28872 unsafe impl TaggedStructure for PhysicalDeviceConservativeRasterizationPropertiesEXT {
28873     const STRUCTURE_TYPE: StructureType =
28874         StructureType::PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT;
28875 }
28876 impl PhysicalDeviceConservativeRasterizationPropertiesEXT {
builder<'a>() -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a>28877     pub fn builder<'a>() -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
28878         PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder {
28879             inner: Self::default(),
28880             marker: ::std::marker::PhantomData,
28881         }
28882     }
28883 }
28884 #[repr(transparent)]
28885 pub struct PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
28886     inner: PhysicalDeviceConservativeRasterizationPropertiesEXT,
28887     marker: ::std::marker::PhantomData<&'a ()>,
28888 }
28889 unsafe impl ExtendsPhysicalDeviceProperties2
28890     for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'_>
28891 {
28892 }
28893 unsafe impl ExtendsPhysicalDeviceProperties2
28894     for PhysicalDeviceConservativeRasterizationPropertiesEXT
28895 {
28896 }
28897 impl<'a> ::std::ops::Deref for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
28898     type Target = PhysicalDeviceConservativeRasterizationPropertiesEXT;
deref(&self) -> &Self::Target28899     fn deref(&self) -> &Self::Target {
28900         &self.inner
28901     }
28902 }
28903 impl<'a> ::std::ops::DerefMut for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target28904     fn deref_mut(&mut self) -> &mut Self::Target {
28905         &mut self.inner
28906     }
28907 }
28908 impl<'a> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
28909     #[inline]
primitive_overestimation_size(mut self, primitive_overestimation_size: f32) -> Self28910     pub fn primitive_overestimation_size(mut self, primitive_overestimation_size: f32) -> Self {
28911         self.inner.primitive_overestimation_size = primitive_overestimation_size;
28912         self
28913     }
28914     #[inline]
max_extra_primitive_overestimation_size( mut self, max_extra_primitive_overestimation_size: f32, ) -> Self28915     pub fn max_extra_primitive_overestimation_size(
28916         mut self,
28917         max_extra_primitive_overestimation_size: f32,
28918     ) -> Self {
28919         self.inner.max_extra_primitive_overestimation_size =
28920             max_extra_primitive_overestimation_size;
28921         self
28922     }
28923     #[inline]
extra_primitive_overestimation_size_granularity( mut self, extra_primitive_overestimation_size_granularity: f32, ) -> Self28924     pub fn extra_primitive_overestimation_size_granularity(
28925         mut self,
28926         extra_primitive_overestimation_size_granularity: f32,
28927     ) -> Self {
28928         self.inner.extra_primitive_overestimation_size_granularity =
28929             extra_primitive_overestimation_size_granularity;
28930         self
28931     }
28932     #[inline]
primitive_underestimation(mut self, primitive_underestimation: bool) -> Self28933     pub fn primitive_underestimation(mut self, primitive_underestimation: bool) -> Self {
28934         self.inner.primitive_underestimation = primitive_underestimation.into();
28935         self
28936     }
28937     #[inline]
conservative_point_and_line_rasterization( mut self, conservative_point_and_line_rasterization: bool, ) -> Self28938     pub fn conservative_point_and_line_rasterization(
28939         mut self,
28940         conservative_point_and_line_rasterization: bool,
28941     ) -> Self {
28942         self.inner.conservative_point_and_line_rasterization =
28943             conservative_point_and_line_rasterization.into();
28944         self
28945     }
28946     #[inline]
degenerate_triangles_rasterized( mut self, degenerate_triangles_rasterized: bool, ) -> Self28947     pub fn degenerate_triangles_rasterized(
28948         mut self,
28949         degenerate_triangles_rasterized: bool,
28950     ) -> Self {
28951         self.inner.degenerate_triangles_rasterized = degenerate_triangles_rasterized.into();
28952         self
28953     }
28954     #[inline]
degenerate_lines_rasterized(mut self, degenerate_lines_rasterized: bool) -> Self28955     pub fn degenerate_lines_rasterized(mut self, degenerate_lines_rasterized: bool) -> Self {
28956         self.inner.degenerate_lines_rasterized = degenerate_lines_rasterized.into();
28957         self
28958     }
28959     #[inline]
fully_covered_fragment_shader_input_variable( mut self, fully_covered_fragment_shader_input_variable: bool, ) -> Self28960     pub fn fully_covered_fragment_shader_input_variable(
28961         mut self,
28962         fully_covered_fragment_shader_input_variable: bool,
28963     ) -> Self {
28964         self.inner.fully_covered_fragment_shader_input_variable =
28965             fully_covered_fragment_shader_input_variable.into();
28966         self
28967     }
28968     #[inline]
conservative_rasterization_post_depth_coverage( mut self, conservative_rasterization_post_depth_coverage: bool, ) -> Self28969     pub fn conservative_rasterization_post_depth_coverage(
28970         mut self,
28971         conservative_rasterization_post_depth_coverage: bool,
28972     ) -> Self {
28973         self.inner.conservative_rasterization_post_depth_coverage =
28974             conservative_rasterization_post_depth_coverage.into();
28975         self
28976     }
28977     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28978     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28979     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceConservativeRasterizationPropertiesEXT28980     pub fn build(self) -> PhysicalDeviceConservativeRasterizationPropertiesEXT {
28981         self.inner
28982     }
28983 }
28984 #[repr(C)]
28985 #[cfg_attr(feature = "debug", derive(Debug))]
28986 #[derive(Copy, Clone)]
28987 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCalibratedTimestampInfoEXT.html>"]
28988 pub struct CalibratedTimestampInfoEXT {
28989     pub s_type: StructureType,
28990     pub p_next: *const c_void,
28991     pub time_domain: TimeDomainEXT,
28992 }
28993 impl ::std::default::Default for CalibratedTimestampInfoEXT {
28994     #[inline]
default() -> Self28995     fn default() -> Self {
28996         Self {
28997             s_type: Self::STRUCTURE_TYPE,
28998             p_next: ::std::ptr::null(),
28999             time_domain: TimeDomainEXT::default(),
29000         }
29001     }
29002 }
29003 unsafe impl TaggedStructure for CalibratedTimestampInfoEXT {
29004     const STRUCTURE_TYPE: StructureType = StructureType::CALIBRATED_TIMESTAMP_INFO_EXT;
29005 }
29006 impl CalibratedTimestampInfoEXT {
builder<'a>() -> CalibratedTimestampInfoEXTBuilder<'a>29007     pub fn builder<'a>() -> CalibratedTimestampInfoEXTBuilder<'a> {
29008         CalibratedTimestampInfoEXTBuilder {
29009             inner: Self::default(),
29010             marker: ::std::marker::PhantomData,
29011         }
29012     }
29013 }
29014 #[repr(transparent)]
29015 pub struct CalibratedTimestampInfoEXTBuilder<'a> {
29016     inner: CalibratedTimestampInfoEXT,
29017     marker: ::std::marker::PhantomData<&'a ()>,
29018 }
29019 impl<'a> ::std::ops::Deref for CalibratedTimestampInfoEXTBuilder<'a> {
29020     type Target = CalibratedTimestampInfoEXT;
deref(&self) -> &Self::Target29021     fn deref(&self) -> &Self::Target {
29022         &self.inner
29023     }
29024 }
29025 impl<'a> ::std::ops::DerefMut for CalibratedTimestampInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target29026     fn deref_mut(&mut self) -> &mut Self::Target {
29027         &mut self.inner
29028     }
29029 }
29030 impl<'a> CalibratedTimestampInfoEXTBuilder<'a> {
29031     #[inline]
time_domain(mut self, time_domain: TimeDomainEXT) -> Self29032     pub fn time_domain(mut self, time_domain: TimeDomainEXT) -> Self {
29033         self.inner.time_domain = time_domain;
29034         self
29035     }
29036     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29037     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29038     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CalibratedTimestampInfoEXT29039     pub fn build(self) -> CalibratedTimestampInfoEXT {
29040         self.inner
29041     }
29042 }
29043 #[repr(C)]
29044 #[cfg_attr(feature = "debug", derive(Debug))]
29045 #[derive(Copy, Clone)]
29046 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderCorePropertiesAMD.html>"]
29047 pub struct PhysicalDeviceShaderCorePropertiesAMD {
29048     pub s_type: StructureType,
29049     pub p_next: *mut c_void,
29050     pub shader_engine_count: u32,
29051     pub shader_arrays_per_engine_count: u32,
29052     pub compute_units_per_shader_array: u32,
29053     pub simd_per_compute_unit: u32,
29054     pub wavefronts_per_simd: u32,
29055     pub wavefront_size: u32,
29056     pub sgprs_per_simd: u32,
29057     pub min_sgpr_allocation: u32,
29058     pub max_sgpr_allocation: u32,
29059     pub sgpr_allocation_granularity: u32,
29060     pub vgprs_per_simd: u32,
29061     pub min_vgpr_allocation: u32,
29062     pub max_vgpr_allocation: u32,
29063     pub vgpr_allocation_granularity: u32,
29064 }
29065 impl ::std::default::Default for PhysicalDeviceShaderCorePropertiesAMD {
29066     #[inline]
default() -> Self29067     fn default() -> Self {
29068         Self {
29069             s_type: Self::STRUCTURE_TYPE,
29070             p_next: ::std::ptr::null_mut(),
29071             shader_engine_count: u32::default(),
29072             shader_arrays_per_engine_count: u32::default(),
29073             compute_units_per_shader_array: u32::default(),
29074             simd_per_compute_unit: u32::default(),
29075             wavefronts_per_simd: u32::default(),
29076             wavefront_size: u32::default(),
29077             sgprs_per_simd: u32::default(),
29078             min_sgpr_allocation: u32::default(),
29079             max_sgpr_allocation: u32::default(),
29080             sgpr_allocation_granularity: u32::default(),
29081             vgprs_per_simd: u32::default(),
29082             min_vgpr_allocation: u32::default(),
29083             max_vgpr_allocation: u32::default(),
29084             vgpr_allocation_granularity: u32::default(),
29085         }
29086     }
29087 }
29088 unsafe impl TaggedStructure for PhysicalDeviceShaderCorePropertiesAMD {
29089     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD;
29090 }
29091 impl PhysicalDeviceShaderCorePropertiesAMD {
builder<'a>() -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a>29092     pub fn builder<'a>() -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
29093         PhysicalDeviceShaderCorePropertiesAMDBuilder {
29094             inner: Self::default(),
29095             marker: ::std::marker::PhantomData,
29096         }
29097     }
29098 }
29099 #[repr(transparent)]
29100 pub struct PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
29101     inner: PhysicalDeviceShaderCorePropertiesAMD,
29102     marker: ::std::marker::PhantomData<&'a ()>,
29103 }
29104 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesAMDBuilder<'_> {}
29105 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesAMD {}
29106 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
29107     type Target = PhysicalDeviceShaderCorePropertiesAMD;
deref(&self) -> &Self::Target29108     fn deref(&self) -> &Self::Target {
29109         &self.inner
29110     }
29111 }
29112 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target29113     fn deref_mut(&mut self) -> &mut Self::Target {
29114         &mut self.inner
29115     }
29116 }
29117 impl<'a> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
29118     #[inline]
shader_engine_count(mut self, shader_engine_count: u32) -> Self29119     pub fn shader_engine_count(mut self, shader_engine_count: u32) -> Self {
29120         self.inner.shader_engine_count = shader_engine_count;
29121         self
29122     }
29123     #[inline]
shader_arrays_per_engine_count(mut self, shader_arrays_per_engine_count: u32) -> Self29124     pub fn shader_arrays_per_engine_count(mut self, shader_arrays_per_engine_count: u32) -> Self {
29125         self.inner.shader_arrays_per_engine_count = shader_arrays_per_engine_count;
29126         self
29127     }
29128     #[inline]
compute_units_per_shader_array(mut self, compute_units_per_shader_array: u32) -> Self29129     pub fn compute_units_per_shader_array(mut self, compute_units_per_shader_array: u32) -> Self {
29130         self.inner.compute_units_per_shader_array = compute_units_per_shader_array;
29131         self
29132     }
29133     #[inline]
simd_per_compute_unit(mut self, simd_per_compute_unit: u32) -> Self29134     pub fn simd_per_compute_unit(mut self, simd_per_compute_unit: u32) -> Self {
29135         self.inner.simd_per_compute_unit = simd_per_compute_unit;
29136         self
29137     }
29138     #[inline]
wavefronts_per_simd(mut self, wavefronts_per_simd: u32) -> Self29139     pub fn wavefronts_per_simd(mut self, wavefronts_per_simd: u32) -> Self {
29140         self.inner.wavefronts_per_simd = wavefronts_per_simd;
29141         self
29142     }
29143     #[inline]
wavefront_size(mut self, wavefront_size: u32) -> Self29144     pub fn wavefront_size(mut self, wavefront_size: u32) -> Self {
29145         self.inner.wavefront_size = wavefront_size;
29146         self
29147     }
29148     #[inline]
sgprs_per_simd(mut self, sgprs_per_simd: u32) -> Self29149     pub fn sgprs_per_simd(mut self, sgprs_per_simd: u32) -> Self {
29150         self.inner.sgprs_per_simd = sgprs_per_simd;
29151         self
29152     }
29153     #[inline]
min_sgpr_allocation(mut self, min_sgpr_allocation: u32) -> Self29154     pub fn min_sgpr_allocation(mut self, min_sgpr_allocation: u32) -> Self {
29155         self.inner.min_sgpr_allocation = min_sgpr_allocation;
29156         self
29157     }
29158     #[inline]
max_sgpr_allocation(mut self, max_sgpr_allocation: u32) -> Self29159     pub fn max_sgpr_allocation(mut self, max_sgpr_allocation: u32) -> Self {
29160         self.inner.max_sgpr_allocation = max_sgpr_allocation;
29161         self
29162     }
29163     #[inline]
sgpr_allocation_granularity(mut self, sgpr_allocation_granularity: u32) -> Self29164     pub fn sgpr_allocation_granularity(mut self, sgpr_allocation_granularity: u32) -> Self {
29165         self.inner.sgpr_allocation_granularity = sgpr_allocation_granularity;
29166         self
29167     }
29168     #[inline]
vgprs_per_simd(mut self, vgprs_per_simd: u32) -> Self29169     pub fn vgprs_per_simd(mut self, vgprs_per_simd: u32) -> Self {
29170         self.inner.vgprs_per_simd = vgprs_per_simd;
29171         self
29172     }
29173     #[inline]
min_vgpr_allocation(mut self, min_vgpr_allocation: u32) -> Self29174     pub fn min_vgpr_allocation(mut self, min_vgpr_allocation: u32) -> Self {
29175         self.inner.min_vgpr_allocation = min_vgpr_allocation;
29176         self
29177     }
29178     #[inline]
max_vgpr_allocation(mut self, max_vgpr_allocation: u32) -> Self29179     pub fn max_vgpr_allocation(mut self, max_vgpr_allocation: u32) -> Self {
29180         self.inner.max_vgpr_allocation = max_vgpr_allocation;
29181         self
29182     }
29183     #[inline]
vgpr_allocation_granularity(mut self, vgpr_allocation_granularity: u32) -> Self29184     pub fn vgpr_allocation_granularity(mut self, vgpr_allocation_granularity: u32) -> Self {
29185         self.inner.vgpr_allocation_granularity = vgpr_allocation_granularity;
29186         self
29187     }
29188     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29189     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29190     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderCorePropertiesAMD29191     pub fn build(self) -> PhysicalDeviceShaderCorePropertiesAMD {
29192         self.inner
29193     }
29194 }
29195 #[repr(C)]
29196 #[cfg_attr(feature = "debug", derive(Debug))]
29197 #[derive(Copy, Clone)]
29198 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderCoreProperties2AMD.html>"]
29199 pub struct PhysicalDeviceShaderCoreProperties2AMD {
29200     pub s_type: StructureType,
29201     pub p_next: *mut c_void,
29202     pub shader_core_features: ShaderCorePropertiesFlagsAMD,
29203     pub active_compute_unit_count: u32,
29204 }
29205 impl ::std::default::Default for PhysicalDeviceShaderCoreProperties2AMD {
29206     #[inline]
default() -> Self29207     fn default() -> Self {
29208         Self {
29209             s_type: Self::STRUCTURE_TYPE,
29210             p_next: ::std::ptr::null_mut(),
29211             shader_core_features: ShaderCorePropertiesFlagsAMD::default(),
29212             active_compute_unit_count: u32::default(),
29213         }
29214     }
29215 }
29216 unsafe impl TaggedStructure for PhysicalDeviceShaderCoreProperties2AMD {
29217     const STRUCTURE_TYPE: StructureType =
29218         StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD;
29219 }
29220 impl PhysicalDeviceShaderCoreProperties2AMD {
builder<'a>() -> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a>29221     pub fn builder<'a>() -> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
29222         PhysicalDeviceShaderCoreProperties2AMDBuilder {
29223             inner: Self::default(),
29224             marker: ::std::marker::PhantomData,
29225         }
29226     }
29227 }
29228 #[repr(transparent)]
29229 pub struct PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
29230     inner: PhysicalDeviceShaderCoreProperties2AMD,
29231     marker: ::std::marker::PhantomData<&'a ()>,
29232 }
29233 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCoreProperties2AMDBuilder<'_> {}
29234 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCoreProperties2AMD {}
29235 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
29236     type Target = PhysicalDeviceShaderCoreProperties2AMD;
deref(&self) -> &Self::Target29237     fn deref(&self) -> &Self::Target {
29238         &self.inner
29239     }
29240 }
29241 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target29242     fn deref_mut(&mut self) -> &mut Self::Target {
29243         &mut self.inner
29244     }
29245 }
29246 impl<'a> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
29247     #[inline]
shader_core_features( mut self, shader_core_features: ShaderCorePropertiesFlagsAMD, ) -> Self29248     pub fn shader_core_features(
29249         mut self,
29250         shader_core_features: ShaderCorePropertiesFlagsAMD,
29251     ) -> Self {
29252         self.inner.shader_core_features = shader_core_features;
29253         self
29254     }
29255     #[inline]
active_compute_unit_count(mut self, active_compute_unit_count: u32) -> Self29256     pub fn active_compute_unit_count(mut self, active_compute_unit_count: u32) -> Self {
29257         self.inner.active_compute_unit_count = active_compute_unit_count;
29258         self
29259     }
29260     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29261     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29262     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderCoreProperties2AMD29263     pub fn build(self) -> PhysicalDeviceShaderCoreProperties2AMD {
29264         self.inner
29265     }
29266 }
29267 #[repr(C)]
29268 #[cfg_attr(feature = "debug", derive(Debug))]
29269 #[derive(Copy, Clone)]
29270 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationConservativeStateCreateInfoEXT.html>"]
29271 pub struct PipelineRasterizationConservativeStateCreateInfoEXT {
29272     pub s_type: StructureType,
29273     pub p_next: *const c_void,
29274     pub flags: PipelineRasterizationConservativeStateCreateFlagsEXT,
29275     pub conservative_rasterization_mode: ConservativeRasterizationModeEXT,
29276     pub extra_primitive_overestimation_size: f32,
29277 }
29278 impl ::std::default::Default for PipelineRasterizationConservativeStateCreateInfoEXT {
29279     #[inline]
default() -> Self29280     fn default() -> Self {
29281         Self {
29282             s_type: Self::STRUCTURE_TYPE,
29283             p_next: ::std::ptr::null(),
29284             flags: PipelineRasterizationConservativeStateCreateFlagsEXT::default(),
29285             conservative_rasterization_mode: ConservativeRasterizationModeEXT::default(),
29286             extra_primitive_overestimation_size: f32::default(),
29287         }
29288     }
29289 }
29290 unsafe impl TaggedStructure for PipelineRasterizationConservativeStateCreateInfoEXT {
29291     const STRUCTURE_TYPE: StructureType =
29292         StructureType::PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT;
29293 }
29294 impl PipelineRasterizationConservativeStateCreateInfoEXT {
builder<'a>() -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a>29295     pub fn builder<'a>() -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
29296         PipelineRasterizationConservativeStateCreateInfoEXTBuilder {
29297             inner: Self::default(),
29298             marker: ::std::marker::PhantomData,
29299         }
29300     }
29301 }
29302 #[repr(transparent)]
29303 pub struct PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
29304     inner: PipelineRasterizationConservativeStateCreateInfoEXT,
29305     marker: ::std::marker::PhantomData<&'a ()>,
29306 }
29307 unsafe impl ExtendsPipelineRasterizationStateCreateInfo
29308     for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'_>
29309 {
29310 }
29311 unsafe impl ExtendsPipelineRasterizationStateCreateInfo
29312     for PipelineRasterizationConservativeStateCreateInfoEXT
29313 {
29314 }
29315 impl<'a> ::std::ops::Deref for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
29316     type Target = PipelineRasterizationConservativeStateCreateInfoEXT;
deref(&self) -> &Self::Target29317     fn deref(&self) -> &Self::Target {
29318         &self.inner
29319     }
29320 }
29321 impl<'a> ::std::ops::DerefMut for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target29322     fn deref_mut(&mut self) -> &mut Self::Target {
29323         &mut self.inner
29324     }
29325 }
29326 impl<'a> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
29327     #[inline]
flags(mut self, flags: PipelineRasterizationConservativeStateCreateFlagsEXT) -> Self29328     pub fn flags(mut self, flags: PipelineRasterizationConservativeStateCreateFlagsEXT) -> Self {
29329         self.inner.flags = flags;
29330         self
29331     }
29332     #[inline]
conservative_rasterization_mode( mut self, conservative_rasterization_mode: ConservativeRasterizationModeEXT, ) -> Self29333     pub fn conservative_rasterization_mode(
29334         mut self,
29335         conservative_rasterization_mode: ConservativeRasterizationModeEXT,
29336     ) -> Self {
29337         self.inner.conservative_rasterization_mode = conservative_rasterization_mode;
29338         self
29339     }
29340     #[inline]
extra_primitive_overestimation_size( mut self, extra_primitive_overestimation_size: f32, ) -> Self29341     pub fn extra_primitive_overestimation_size(
29342         mut self,
29343         extra_primitive_overestimation_size: f32,
29344     ) -> Self {
29345         self.inner.extra_primitive_overestimation_size = extra_primitive_overestimation_size;
29346         self
29347     }
29348     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29349     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29350     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineRasterizationConservativeStateCreateInfoEXT29351     pub fn build(self) -> PipelineRasterizationConservativeStateCreateInfoEXT {
29352         self.inner
29353     }
29354 }
29355 #[repr(C)]
29356 #[cfg_attr(feature = "debug", derive(Debug))]
29357 #[derive(Copy, Clone)]
29358 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDescriptorIndexingFeatures.html>"]
29359 pub struct PhysicalDeviceDescriptorIndexingFeatures {
29360     pub s_type: StructureType,
29361     pub p_next: *mut c_void,
29362     pub shader_input_attachment_array_dynamic_indexing: Bool32,
29363     pub shader_uniform_texel_buffer_array_dynamic_indexing: Bool32,
29364     pub shader_storage_texel_buffer_array_dynamic_indexing: Bool32,
29365     pub shader_uniform_buffer_array_non_uniform_indexing: Bool32,
29366     pub shader_sampled_image_array_non_uniform_indexing: Bool32,
29367     pub shader_storage_buffer_array_non_uniform_indexing: Bool32,
29368     pub shader_storage_image_array_non_uniform_indexing: Bool32,
29369     pub shader_input_attachment_array_non_uniform_indexing: Bool32,
29370     pub shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32,
29371     pub shader_storage_texel_buffer_array_non_uniform_indexing: Bool32,
29372     pub descriptor_binding_uniform_buffer_update_after_bind: Bool32,
29373     pub descriptor_binding_sampled_image_update_after_bind: Bool32,
29374     pub descriptor_binding_storage_image_update_after_bind: Bool32,
29375     pub descriptor_binding_storage_buffer_update_after_bind: Bool32,
29376     pub descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32,
29377     pub descriptor_binding_storage_texel_buffer_update_after_bind: Bool32,
29378     pub descriptor_binding_update_unused_while_pending: Bool32,
29379     pub descriptor_binding_partially_bound: Bool32,
29380     pub descriptor_binding_variable_descriptor_count: Bool32,
29381     pub runtime_descriptor_array: Bool32,
29382 }
29383 impl ::std::default::Default for PhysicalDeviceDescriptorIndexingFeatures {
29384     #[inline]
default() -> Self29385     fn default() -> Self {
29386         Self {
29387             s_type: Self::STRUCTURE_TYPE,
29388             p_next: ::std::ptr::null_mut(),
29389             shader_input_attachment_array_dynamic_indexing: Bool32::default(),
29390             shader_uniform_texel_buffer_array_dynamic_indexing: Bool32::default(),
29391             shader_storage_texel_buffer_array_dynamic_indexing: Bool32::default(),
29392             shader_uniform_buffer_array_non_uniform_indexing: Bool32::default(),
29393             shader_sampled_image_array_non_uniform_indexing: Bool32::default(),
29394             shader_storage_buffer_array_non_uniform_indexing: Bool32::default(),
29395             shader_storage_image_array_non_uniform_indexing: Bool32::default(),
29396             shader_input_attachment_array_non_uniform_indexing: Bool32::default(),
29397             shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32::default(),
29398             shader_storage_texel_buffer_array_non_uniform_indexing: Bool32::default(),
29399             descriptor_binding_uniform_buffer_update_after_bind: Bool32::default(),
29400             descriptor_binding_sampled_image_update_after_bind: Bool32::default(),
29401             descriptor_binding_storage_image_update_after_bind: Bool32::default(),
29402             descriptor_binding_storage_buffer_update_after_bind: Bool32::default(),
29403             descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32::default(),
29404             descriptor_binding_storage_texel_buffer_update_after_bind: Bool32::default(),
29405             descriptor_binding_update_unused_while_pending: Bool32::default(),
29406             descriptor_binding_partially_bound: Bool32::default(),
29407             descriptor_binding_variable_descriptor_count: Bool32::default(),
29408             runtime_descriptor_array: Bool32::default(),
29409         }
29410     }
29411 }
29412 unsafe impl TaggedStructure for PhysicalDeviceDescriptorIndexingFeatures {
29413     const STRUCTURE_TYPE: StructureType =
29414         StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
29415 }
29416 impl PhysicalDeviceDescriptorIndexingFeatures {
builder<'a>() -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a>29417     pub fn builder<'a>() -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
29418         PhysicalDeviceDescriptorIndexingFeaturesBuilder {
29419             inner: Self::default(),
29420             marker: ::std::marker::PhantomData,
29421         }
29422     }
29423 }
29424 #[repr(transparent)]
29425 pub struct PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
29426     inner: PhysicalDeviceDescriptorIndexingFeatures,
29427     marker: ::std::marker::PhantomData<&'a ()>,
29428 }
29429 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'_> {}
29430 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorIndexingFeatures {}
29431 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'_> {}
29432 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorIndexingFeatures {}
29433 impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
29434     type Target = PhysicalDeviceDescriptorIndexingFeatures;
deref(&self) -> &Self::Target29435     fn deref(&self) -> &Self::Target {
29436         &self.inner
29437     }
29438 }
29439 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target29440     fn deref_mut(&mut self) -> &mut Self::Target {
29441         &mut self.inner
29442     }
29443 }
29444 impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
29445     #[inline]
shader_input_attachment_array_dynamic_indexing( mut self, shader_input_attachment_array_dynamic_indexing: bool, ) -> Self29446     pub fn shader_input_attachment_array_dynamic_indexing(
29447         mut self,
29448         shader_input_attachment_array_dynamic_indexing: bool,
29449     ) -> Self {
29450         self.inner.shader_input_attachment_array_dynamic_indexing =
29451             shader_input_attachment_array_dynamic_indexing.into();
29452         self
29453     }
29454     #[inline]
shader_uniform_texel_buffer_array_dynamic_indexing( mut self, shader_uniform_texel_buffer_array_dynamic_indexing: bool, ) -> Self29455     pub fn shader_uniform_texel_buffer_array_dynamic_indexing(
29456         mut self,
29457         shader_uniform_texel_buffer_array_dynamic_indexing: bool,
29458     ) -> Self {
29459         self.inner
29460             .shader_uniform_texel_buffer_array_dynamic_indexing =
29461             shader_uniform_texel_buffer_array_dynamic_indexing.into();
29462         self
29463     }
29464     #[inline]
shader_storage_texel_buffer_array_dynamic_indexing( mut self, shader_storage_texel_buffer_array_dynamic_indexing: bool, ) -> Self29465     pub fn shader_storage_texel_buffer_array_dynamic_indexing(
29466         mut self,
29467         shader_storage_texel_buffer_array_dynamic_indexing: bool,
29468     ) -> Self {
29469         self.inner
29470             .shader_storage_texel_buffer_array_dynamic_indexing =
29471             shader_storage_texel_buffer_array_dynamic_indexing.into();
29472         self
29473     }
29474     #[inline]
shader_uniform_buffer_array_non_uniform_indexing( mut self, shader_uniform_buffer_array_non_uniform_indexing: bool, ) -> Self29475     pub fn shader_uniform_buffer_array_non_uniform_indexing(
29476         mut self,
29477         shader_uniform_buffer_array_non_uniform_indexing: bool,
29478     ) -> Self {
29479         self.inner.shader_uniform_buffer_array_non_uniform_indexing =
29480             shader_uniform_buffer_array_non_uniform_indexing.into();
29481         self
29482     }
29483     #[inline]
shader_sampled_image_array_non_uniform_indexing( mut self, shader_sampled_image_array_non_uniform_indexing: bool, ) -> Self29484     pub fn shader_sampled_image_array_non_uniform_indexing(
29485         mut self,
29486         shader_sampled_image_array_non_uniform_indexing: bool,
29487     ) -> Self {
29488         self.inner.shader_sampled_image_array_non_uniform_indexing =
29489             shader_sampled_image_array_non_uniform_indexing.into();
29490         self
29491     }
29492     #[inline]
shader_storage_buffer_array_non_uniform_indexing( mut self, shader_storage_buffer_array_non_uniform_indexing: bool, ) -> Self29493     pub fn shader_storage_buffer_array_non_uniform_indexing(
29494         mut self,
29495         shader_storage_buffer_array_non_uniform_indexing: bool,
29496     ) -> Self {
29497         self.inner.shader_storage_buffer_array_non_uniform_indexing =
29498             shader_storage_buffer_array_non_uniform_indexing.into();
29499         self
29500     }
29501     #[inline]
shader_storage_image_array_non_uniform_indexing( mut self, shader_storage_image_array_non_uniform_indexing: bool, ) -> Self29502     pub fn shader_storage_image_array_non_uniform_indexing(
29503         mut self,
29504         shader_storage_image_array_non_uniform_indexing: bool,
29505     ) -> Self {
29506         self.inner.shader_storage_image_array_non_uniform_indexing =
29507             shader_storage_image_array_non_uniform_indexing.into();
29508         self
29509     }
29510     #[inline]
shader_input_attachment_array_non_uniform_indexing( mut self, shader_input_attachment_array_non_uniform_indexing: bool, ) -> Self29511     pub fn shader_input_attachment_array_non_uniform_indexing(
29512         mut self,
29513         shader_input_attachment_array_non_uniform_indexing: bool,
29514     ) -> Self {
29515         self.inner
29516             .shader_input_attachment_array_non_uniform_indexing =
29517             shader_input_attachment_array_non_uniform_indexing.into();
29518         self
29519     }
29520     #[inline]
shader_uniform_texel_buffer_array_non_uniform_indexing( mut self, shader_uniform_texel_buffer_array_non_uniform_indexing: bool, ) -> Self29521     pub fn shader_uniform_texel_buffer_array_non_uniform_indexing(
29522         mut self,
29523         shader_uniform_texel_buffer_array_non_uniform_indexing: bool,
29524     ) -> Self {
29525         self.inner
29526             .shader_uniform_texel_buffer_array_non_uniform_indexing =
29527             shader_uniform_texel_buffer_array_non_uniform_indexing.into();
29528         self
29529     }
29530     #[inline]
shader_storage_texel_buffer_array_non_uniform_indexing( mut self, shader_storage_texel_buffer_array_non_uniform_indexing: bool, ) -> Self29531     pub fn shader_storage_texel_buffer_array_non_uniform_indexing(
29532         mut self,
29533         shader_storage_texel_buffer_array_non_uniform_indexing: bool,
29534     ) -> Self {
29535         self.inner
29536             .shader_storage_texel_buffer_array_non_uniform_indexing =
29537             shader_storage_texel_buffer_array_non_uniform_indexing.into();
29538         self
29539     }
29540     #[inline]
descriptor_binding_uniform_buffer_update_after_bind( mut self, descriptor_binding_uniform_buffer_update_after_bind: bool, ) -> Self29541     pub fn descriptor_binding_uniform_buffer_update_after_bind(
29542         mut self,
29543         descriptor_binding_uniform_buffer_update_after_bind: bool,
29544     ) -> Self {
29545         self.inner
29546             .descriptor_binding_uniform_buffer_update_after_bind =
29547             descriptor_binding_uniform_buffer_update_after_bind.into();
29548         self
29549     }
29550     #[inline]
descriptor_binding_sampled_image_update_after_bind( mut self, descriptor_binding_sampled_image_update_after_bind: bool, ) -> Self29551     pub fn descriptor_binding_sampled_image_update_after_bind(
29552         mut self,
29553         descriptor_binding_sampled_image_update_after_bind: bool,
29554     ) -> Self {
29555         self.inner
29556             .descriptor_binding_sampled_image_update_after_bind =
29557             descriptor_binding_sampled_image_update_after_bind.into();
29558         self
29559     }
29560     #[inline]
descriptor_binding_storage_image_update_after_bind( mut self, descriptor_binding_storage_image_update_after_bind: bool, ) -> Self29561     pub fn descriptor_binding_storage_image_update_after_bind(
29562         mut self,
29563         descriptor_binding_storage_image_update_after_bind: bool,
29564     ) -> Self {
29565         self.inner
29566             .descriptor_binding_storage_image_update_after_bind =
29567             descriptor_binding_storage_image_update_after_bind.into();
29568         self
29569     }
29570     #[inline]
descriptor_binding_storage_buffer_update_after_bind( mut self, descriptor_binding_storage_buffer_update_after_bind: bool, ) -> Self29571     pub fn descriptor_binding_storage_buffer_update_after_bind(
29572         mut self,
29573         descriptor_binding_storage_buffer_update_after_bind: bool,
29574     ) -> Self {
29575         self.inner
29576             .descriptor_binding_storage_buffer_update_after_bind =
29577             descriptor_binding_storage_buffer_update_after_bind.into();
29578         self
29579     }
29580     #[inline]
descriptor_binding_uniform_texel_buffer_update_after_bind( mut self, descriptor_binding_uniform_texel_buffer_update_after_bind: bool, ) -> Self29581     pub fn descriptor_binding_uniform_texel_buffer_update_after_bind(
29582         mut self,
29583         descriptor_binding_uniform_texel_buffer_update_after_bind: bool,
29584     ) -> Self {
29585         self.inner
29586             .descriptor_binding_uniform_texel_buffer_update_after_bind =
29587             descriptor_binding_uniform_texel_buffer_update_after_bind.into();
29588         self
29589     }
29590     #[inline]
descriptor_binding_storage_texel_buffer_update_after_bind( mut self, descriptor_binding_storage_texel_buffer_update_after_bind: bool, ) -> Self29591     pub fn descriptor_binding_storage_texel_buffer_update_after_bind(
29592         mut self,
29593         descriptor_binding_storage_texel_buffer_update_after_bind: bool,
29594     ) -> Self {
29595         self.inner
29596             .descriptor_binding_storage_texel_buffer_update_after_bind =
29597             descriptor_binding_storage_texel_buffer_update_after_bind.into();
29598         self
29599     }
29600     #[inline]
descriptor_binding_update_unused_while_pending( mut self, descriptor_binding_update_unused_while_pending: bool, ) -> Self29601     pub fn descriptor_binding_update_unused_while_pending(
29602         mut self,
29603         descriptor_binding_update_unused_while_pending: bool,
29604     ) -> Self {
29605         self.inner.descriptor_binding_update_unused_while_pending =
29606             descriptor_binding_update_unused_while_pending.into();
29607         self
29608     }
29609     #[inline]
descriptor_binding_partially_bound( mut self, descriptor_binding_partially_bound: bool, ) -> Self29610     pub fn descriptor_binding_partially_bound(
29611         mut self,
29612         descriptor_binding_partially_bound: bool,
29613     ) -> Self {
29614         self.inner.descriptor_binding_partially_bound = descriptor_binding_partially_bound.into();
29615         self
29616     }
29617     #[inline]
descriptor_binding_variable_descriptor_count( mut self, descriptor_binding_variable_descriptor_count: bool, ) -> Self29618     pub fn descriptor_binding_variable_descriptor_count(
29619         mut self,
29620         descriptor_binding_variable_descriptor_count: bool,
29621     ) -> Self {
29622         self.inner.descriptor_binding_variable_descriptor_count =
29623             descriptor_binding_variable_descriptor_count.into();
29624         self
29625     }
29626     #[inline]
runtime_descriptor_array(mut self, runtime_descriptor_array: bool) -> Self29627     pub fn runtime_descriptor_array(mut self, runtime_descriptor_array: bool) -> Self {
29628         self.inner.runtime_descriptor_array = runtime_descriptor_array.into();
29629         self
29630     }
29631     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29632     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29633     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDescriptorIndexingFeatures29634     pub fn build(self) -> PhysicalDeviceDescriptorIndexingFeatures {
29635         self.inner
29636     }
29637 }
29638 #[repr(C)]
29639 #[cfg_attr(feature = "debug", derive(Debug))]
29640 #[derive(Copy, Clone)]
29641 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDescriptorIndexingProperties.html>"]
29642 pub struct PhysicalDeviceDescriptorIndexingProperties {
29643     pub s_type: StructureType,
29644     pub p_next: *mut c_void,
29645     pub max_update_after_bind_descriptors_in_all_pools: u32,
29646     pub shader_uniform_buffer_array_non_uniform_indexing_native: Bool32,
29647     pub shader_sampled_image_array_non_uniform_indexing_native: Bool32,
29648     pub shader_storage_buffer_array_non_uniform_indexing_native: Bool32,
29649     pub shader_storage_image_array_non_uniform_indexing_native: Bool32,
29650     pub shader_input_attachment_array_non_uniform_indexing_native: Bool32,
29651     pub robust_buffer_access_update_after_bind: Bool32,
29652     pub quad_divergent_implicit_lod: Bool32,
29653     pub max_per_stage_descriptor_update_after_bind_samplers: u32,
29654     pub max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
29655     pub max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
29656     pub max_per_stage_descriptor_update_after_bind_sampled_images: u32,
29657     pub max_per_stage_descriptor_update_after_bind_storage_images: u32,
29658     pub max_per_stage_descriptor_update_after_bind_input_attachments: u32,
29659     pub max_per_stage_update_after_bind_resources: u32,
29660     pub max_descriptor_set_update_after_bind_samplers: u32,
29661     pub max_descriptor_set_update_after_bind_uniform_buffers: u32,
29662     pub max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
29663     pub max_descriptor_set_update_after_bind_storage_buffers: u32,
29664     pub max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
29665     pub max_descriptor_set_update_after_bind_sampled_images: u32,
29666     pub max_descriptor_set_update_after_bind_storage_images: u32,
29667     pub max_descriptor_set_update_after_bind_input_attachments: u32,
29668 }
29669 impl ::std::default::Default for PhysicalDeviceDescriptorIndexingProperties {
29670     #[inline]
default() -> Self29671     fn default() -> Self {
29672         Self {
29673             s_type: Self::STRUCTURE_TYPE,
29674             p_next: ::std::ptr::null_mut(),
29675             max_update_after_bind_descriptors_in_all_pools: u32::default(),
29676             shader_uniform_buffer_array_non_uniform_indexing_native: Bool32::default(),
29677             shader_sampled_image_array_non_uniform_indexing_native: Bool32::default(),
29678             shader_storage_buffer_array_non_uniform_indexing_native: Bool32::default(),
29679             shader_storage_image_array_non_uniform_indexing_native: Bool32::default(),
29680             shader_input_attachment_array_non_uniform_indexing_native: Bool32::default(),
29681             robust_buffer_access_update_after_bind: Bool32::default(),
29682             quad_divergent_implicit_lod: Bool32::default(),
29683             max_per_stage_descriptor_update_after_bind_samplers: u32::default(),
29684             max_per_stage_descriptor_update_after_bind_uniform_buffers: u32::default(),
29685             max_per_stage_descriptor_update_after_bind_storage_buffers: u32::default(),
29686             max_per_stage_descriptor_update_after_bind_sampled_images: u32::default(),
29687             max_per_stage_descriptor_update_after_bind_storage_images: u32::default(),
29688             max_per_stage_descriptor_update_after_bind_input_attachments: u32::default(),
29689             max_per_stage_update_after_bind_resources: u32::default(),
29690             max_descriptor_set_update_after_bind_samplers: u32::default(),
29691             max_descriptor_set_update_after_bind_uniform_buffers: u32::default(),
29692             max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32::default(),
29693             max_descriptor_set_update_after_bind_storage_buffers: u32::default(),
29694             max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32::default(),
29695             max_descriptor_set_update_after_bind_sampled_images: u32::default(),
29696             max_descriptor_set_update_after_bind_storage_images: u32::default(),
29697             max_descriptor_set_update_after_bind_input_attachments: u32::default(),
29698         }
29699     }
29700 }
29701 unsafe impl TaggedStructure for PhysicalDeviceDescriptorIndexingProperties {
29702     const STRUCTURE_TYPE: StructureType =
29703         StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
29704 }
29705 impl PhysicalDeviceDescriptorIndexingProperties {
builder<'a>() -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a>29706     pub fn builder<'a>() -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
29707         PhysicalDeviceDescriptorIndexingPropertiesBuilder {
29708             inner: Self::default(),
29709             marker: ::std::marker::PhantomData,
29710         }
29711     }
29712 }
29713 #[repr(transparent)]
29714 pub struct PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
29715     inner: PhysicalDeviceDescriptorIndexingProperties,
29716     marker: ::std::marker::PhantomData<&'a ()>,
29717 }
29718 unsafe impl ExtendsPhysicalDeviceProperties2
29719     for PhysicalDeviceDescriptorIndexingPropertiesBuilder<'_>
29720 {
29721 }
29722 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDescriptorIndexingProperties {}
29723 impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
29724     type Target = PhysicalDeviceDescriptorIndexingProperties;
deref(&self) -> &Self::Target29725     fn deref(&self) -> &Self::Target {
29726         &self.inner
29727     }
29728 }
29729 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target29730     fn deref_mut(&mut self) -> &mut Self::Target {
29731         &mut self.inner
29732     }
29733 }
29734 impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
29735     #[inline]
max_update_after_bind_descriptors_in_all_pools( mut self, max_update_after_bind_descriptors_in_all_pools: u32, ) -> Self29736     pub fn max_update_after_bind_descriptors_in_all_pools(
29737         mut self,
29738         max_update_after_bind_descriptors_in_all_pools: u32,
29739     ) -> Self {
29740         self.inner.max_update_after_bind_descriptors_in_all_pools =
29741             max_update_after_bind_descriptors_in_all_pools;
29742         self
29743     }
29744     #[inline]
shader_uniform_buffer_array_non_uniform_indexing_native( mut self, shader_uniform_buffer_array_non_uniform_indexing_native: bool, ) -> Self29745     pub fn shader_uniform_buffer_array_non_uniform_indexing_native(
29746         mut self,
29747         shader_uniform_buffer_array_non_uniform_indexing_native: bool,
29748     ) -> Self {
29749         self.inner
29750             .shader_uniform_buffer_array_non_uniform_indexing_native =
29751             shader_uniform_buffer_array_non_uniform_indexing_native.into();
29752         self
29753     }
29754     #[inline]
shader_sampled_image_array_non_uniform_indexing_native( mut self, shader_sampled_image_array_non_uniform_indexing_native: bool, ) -> Self29755     pub fn shader_sampled_image_array_non_uniform_indexing_native(
29756         mut self,
29757         shader_sampled_image_array_non_uniform_indexing_native: bool,
29758     ) -> Self {
29759         self.inner
29760             .shader_sampled_image_array_non_uniform_indexing_native =
29761             shader_sampled_image_array_non_uniform_indexing_native.into();
29762         self
29763     }
29764     #[inline]
shader_storage_buffer_array_non_uniform_indexing_native( mut self, shader_storage_buffer_array_non_uniform_indexing_native: bool, ) -> Self29765     pub fn shader_storage_buffer_array_non_uniform_indexing_native(
29766         mut self,
29767         shader_storage_buffer_array_non_uniform_indexing_native: bool,
29768     ) -> Self {
29769         self.inner
29770             .shader_storage_buffer_array_non_uniform_indexing_native =
29771             shader_storage_buffer_array_non_uniform_indexing_native.into();
29772         self
29773     }
29774     #[inline]
shader_storage_image_array_non_uniform_indexing_native( mut self, shader_storage_image_array_non_uniform_indexing_native: bool, ) -> Self29775     pub fn shader_storage_image_array_non_uniform_indexing_native(
29776         mut self,
29777         shader_storage_image_array_non_uniform_indexing_native: bool,
29778     ) -> Self {
29779         self.inner
29780             .shader_storage_image_array_non_uniform_indexing_native =
29781             shader_storage_image_array_non_uniform_indexing_native.into();
29782         self
29783     }
29784     #[inline]
shader_input_attachment_array_non_uniform_indexing_native( mut self, shader_input_attachment_array_non_uniform_indexing_native: bool, ) -> Self29785     pub fn shader_input_attachment_array_non_uniform_indexing_native(
29786         mut self,
29787         shader_input_attachment_array_non_uniform_indexing_native: bool,
29788     ) -> Self {
29789         self.inner
29790             .shader_input_attachment_array_non_uniform_indexing_native =
29791             shader_input_attachment_array_non_uniform_indexing_native.into();
29792         self
29793     }
29794     #[inline]
robust_buffer_access_update_after_bind( mut self, robust_buffer_access_update_after_bind: bool, ) -> Self29795     pub fn robust_buffer_access_update_after_bind(
29796         mut self,
29797         robust_buffer_access_update_after_bind: bool,
29798     ) -> Self {
29799         self.inner.robust_buffer_access_update_after_bind =
29800             robust_buffer_access_update_after_bind.into();
29801         self
29802     }
29803     #[inline]
quad_divergent_implicit_lod(mut self, quad_divergent_implicit_lod: bool) -> Self29804     pub fn quad_divergent_implicit_lod(mut self, quad_divergent_implicit_lod: bool) -> Self {
29805         self.inner.quad_divergent_implicit_lod = quad_divergent_implicit_lod.into();
29806         self
29807     }
29808     #[inline]
max_per_stage_descriptor_update_after_bind_samplers( mut self, max_per_stage_descriptor_update_after_bind_samplers: u32, ) -> Self29809     pub fn max_per_stage_descriptor_update_after_bind_samplers(
29810         mut self,
29811         max_per_stage_descriptor_update_after_bind_samplers: u32,
29812     ) -> Self {
29813         self.inner
29814             .max_per_stage_descriptor_update_after_bind_samplers =
29815             max_per_stage_descriptor_update_after_bind_samplers;
29816         self
29817     }
29818     #[inline]
max_per_stage_descriptor_update_after_bind_uniform_buffers( mut self, max_per_stage_descriptor_update_after_bind_uniform_buffers: u32, ) -> Self29819     pub fn max_per_stage_descriptor_update_after_bind_uniform_buffers(
29820         mut self,
29821         max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
29822     ) -> Self {
29823         self.inner
29824             .max_per_stage_descriptor_update_after_bind_uniform_buffers =
29825             max_per_stage_descriptor_update_after_bind_uniform_buffers;
29826         self
29827     }
29828     #[inline]
max_per_stage_descriptor_update_after_bind_storage_buffers( mut self, max_per_stage_descriptor_update_after_bind_storage_buffers: u32, ) -> Self29829     pub fn max_per_stage_descriptor_update_after_bind_storage_buffers(
29830         mut self,
29831         max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
29832     ) -> Self {
29833         self.inner
29834             .max_per_stage_descriptor_update_after_bind_storage_buffers =
29835             max_per_stage_descriptor_update_after_bind_storage_buffers;
29836         self
29837     }
29838     #[inline]
max_per_stage_descriptor_update_after_bind_sampled_images( mut self, max_per_stage_descriptor_update_after_bind_sampled_images: u32, ) -> Self29839     pub fn max_per_stage_descriptor_update_after_bind_sampled_images(
29840         mut self,
29841         max_per_stage_descriptor_update_after_bind_sampled_images: u32,
29842     ) -> Self {
29843         self.inner
29844             .max_per_stage_descriptor_update_after_bind_sampled_images =
29845             max_per_stage_descriptor_update_after_bind_sampled_images;
29846         self
29847     }
29848     #[inline]
max_per_stage_descriptor_update_after_bind_storage_images( mut self, max_per_stage_descriptor_update_after_bind_storage_images: u32, ) -> Self29849     pub fn max_per_stage_descriptor_update_after_bind_storage_images(
29850         mut self,
29851         max_per_stage_descriptor_update_after_bind_storage_images: u32,
29852     ) -> Self {
29853         self.inner
29854             .max_per_stage_descriptor_update_after_bind_storage_images =
29855             max_per_stage_descriptor_update_after_bind_storage_images;
29856         self
29857     }
29858     #[inline]
max_per_stage_descriptor_update_after_bind_input_attachments( mut self, max_per_stage_descriptor_update_after_bind_input_attachments: u32, ) -> Self29859     pub fn max_per_stage_descriptor_update_after_bind_input_attachments(
29860         mut self,
29861         max_per_stage_descriptor_update_after_bind_input_attachments: u32,
29862     ) -> Self {
29863         self.inner
29864             .max_per_stage_descriptor_update_after_bind_input_attachments =
29865             max_per_stage_descriptor_update_after_bind_input_attachments;
29866         self
29867     }
29868     #[inline]
max_per_stage_update_after_bind_resources( mut self, max_per_stage_update_after_bind_resources: u32, ) -> Self29869     pub fn max_per_stage_update_after_bind_resources(
29870         mut self,
29871         max_per_stage_update_after_bind_resources: u32,
29872     ) -> Self {
29873         self.inner.max_per_stage_update_after_bind_resources =
29874             max_per_stage_update_after_bind_resources;
29875         self
29876     }
29877     #[inline]
max_descriptor_set_update_after_bind_samplers( mut self, max_descriptor_set_update_after_bind_samplers: u32, ) -> Self29878     pub fn max_descriptor_set_update_after_bind_samplers(
29879         mut self,
29880         max_descriptor_set_update_after_bind_samplers: u32,
29881     ) -> Self {
29882         self.inner.max_descriptor_set_update_after_bind_samplers =
29883             max_descriptor_set_update_after_bind_samplers;
29884         self
29885     }
29886     #[inline]
max_descriptor_set_update_after_bind_uniform_buffers( mut self, max_descriptor_set_update_after_bind_uniform_buffers: u32, ) -> Self29887     pub fn max_descriptor_set_update_after_bind_uniform_buffers(
29888         mut self,
29889         max_descriptor_set_update_after_bind_uniform_buffers: u32,
29890     ) -> Self {
29891         self.inner
29892             .max_descriptor_set_update_after_bind_uniform_buffers =
29893             max_descriptor_set_update_after_bind_uniform_buffers;
29894         self
29895     }
29896     #[inline]
max_descriptor_set_update_after_bind_uniform_buffers_dynamic( mut self, max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32, ) -> Self29897     pub fn max_descriptor_set_update_after_bind_uniform_buffers_dynamic(
29898         mut self,
29899         max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
29900     ) -> Self {
29901         self.inner
29902             .max_descriptor_set_update_after_bind_uniform_buffers_dynamic =
29903             max_descriptor_set_update_after_bind_uniform_buffers_dynamic;
29904         self
29905     }
29906     #[inline]
max_descriptor_set_update_after_bind_storage_buffers( mut self, max_descriptor_set_update_after_bind_storage_buffers: u32, ) -> Self29907     pub fn max_descriptor_set_update_after_bind_storage_buffers(
29908         mut self,
29909         max_descriptor_set_update_after_bind_storage_buffers: u32,
29910     ) -> Self {
29911         self.inner
29912             .max_descriptor_set_update_after_bind_storage_buffers =
29913             max_descriptor_set_update_after_bind_storage_buffers;
29914         self
29915     }
29916     #[inline]
max_descriptor_set_update_after_bind_storage_buffers_dynamic( mut self, max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32, ) -> Self29917     pub fn max_descriptor_set_update_after_bind_storage_buffers_dynamic(
29918         mut self,
29919         max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
29920     ) -> Self {
29921         self.inner
29922             .max_descriptor_set_update_after_bind_storage_buffers_dynamic =
29923             max_descriptor_set_update_after_bind_storage_buffers_dynamic;
29924         self
29925     }
29926     #[inline]
max_descriptor_set_update_after_bind_sampled_images( mut self, max_descriptor_set_update_after_bind_sampled_images: u32, ) -> Self29927     pub fn max_descriptor_set_update_after_bind_sampled_images(
29928         mut self,
29929         max_descriptor_set_update_after_bind_sampled_images: u32,
29930     ) -> Self {
29931         self.inner
29932             .max_descriptor_set_update_after_bind_sampled_images =
29933             max_descriptor_set_update_after_bind_sampled_images;
29934         self
29935     }
29936     #[inline]
max_descriptor_set_update_after_bind_storage_images( mut self, max_descriptor_set_update_after_bind_storage_images: u32, ) -> Self29937     pub fn max_descriptor_set_update_after_bind_storage_images(
29938         mut self,
29939         max_descriptor_set_update_after_bind_storage_images: u32,
29940     ) -> Self {
29941         self.inner
29942             .max_descriptor_set_update_after_bind_storage_images =
29943             max_descriptor_set_update_after_bind_storage_images;
29944         self
29945     }
29946     #[inline]
max_descriptor_set_update_after_bind_input_attachments( mut self, max_descriptor_set_update_after_bind_input_attachments: u32, ) -> Self29947     pub fn max_descriptor_set_update_after_bind_input_attachments(
29948         mut self,
29949         max_descriptor_set_update_after_bind_input_attachments: u32,
29950     ) -> Self {
29951         self.inner
29952             .max_descriptor_set_update_after_bind_input_attachments =
29953             max_descriptor_set_update_after_bind_input_attachments;
29954         self
29955     }
29956     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29957     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29958     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDescriptorIndexingProperties29959     pub fn build(self) -> PhysicalDeviceDescriptorIndexingProperties {
29960         self.inner
29961     }
29962 }
29963 #[repr(C)]
29964 #[cfg_attr(feature = "debug", derive(Debug))]
29965 #[derive(Copy, Clone)]
29966 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutBindingFlagsCreateInfo.html>"]
29967 pub struct DescriptorSetLayoutBindingFlagsCreateInfo {
29968     pub s_type: StructureType,
29969     pub p_next: *const c_void,
29970     pub binding_count: u32,
29971     pub p_binding_flags: *const DescriptorBindingFlags,
29972 }
29973 impl ::std::default::Default for DescriptorSetLayoutBindingFlagsCreateInfo {
29974     #[inline]
default() -> Self29975     fn default() -> Self {
29976         Self {
29977             s_type: Self::STRUCTURE_TYPE,
29978             p_next: ::std::ptr::null(),
29979             binding_count: u32::default(),
29980             p_binding_flags: ::std::ptr::null(),
29981         }
29982     }
29983 }
29984 unsafe impl TaggedStructure for DescriptorSetLayoutBindingFlagsCreateInfo {
29985     const STRUCTURE_TYPE: StructureType =
29986         StructureType::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO;
29987 }
29988 impl DescriptorSetLayoutBindingFlagsCreateInfo {
builder<'a>() -> DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a>29989     pub fn builder<'a>() -> DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
29990         DescriptorSetLayoutBindingFlagsCreateInfoBuilder {
29991             inner: Self::default(),
29992             marker: ::std::marker::PhantomData,
29993         }
29994     }
29995 }
29996 #[repr(transparent)]
29997 pub struct DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
29998     inner: DescriptorSetLayoutBindingFlagsCreateInfo,
29999     marker: ::std::marker::PhantomData<&'a ()>,
30000 }
30001 unsafe impl ExtendsDescriptorSetLayoutCreateInfo
30002     for DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'_>
30003 {
30004 }
30005 unsafe impl ExtendsDescriptorSetLayoutCreateInfo for DescriptorSetLayoutBindingFlagsCreateInfo {}
30006 impl<'a> ::std::ops::Deref for DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
30007     type Target = DescriptorSetLayoutBindingFlagsCreateInfo;
deref(&self) -> &Self::Target30008     fn deref(&self) -> &Self::Target {
30009         &self.inner
30010     }
30011 }
30012 impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target30013     fn deref_mut(&mut self) -> &mut Self::Target {
30014         &mut self.inner
30015     }
30016 }
30017 impl<'a> DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
30018     #[inline]
binding_flags(mut self, binding_flags: &'a [DescriptorBindingFlags]) -> Self30019     pub fn binding_flags(mut self, binding_flags: &'a [DescriptorBindingFlags]) -> Self {
30020         self.inner.binding_count = binding_flags.len() as _;
30021         self.inner.p_binding_flags = binding_flags.as_ptr();
30022         self
30023     }
30024     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30025     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30026     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorSetLayoutBindingFlagsCreateInfo30027     pub fn build(self) -> DescriptorSetLayoutBindingFlagsCreateInfo {
30028         self.inner
30029     }
30030 }
30031 #[repr(C)]
30032 #[cfg_attr(feature = "debug", derive(Debug))]
30033 #[derive(Copy, Clone)]
30034 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetVariableDescriptorCountAllocateInfo.html>"]
30035 pub struct DescriptorSetVariableDescriptorCountAllocateInfo {
30036     pub s_type: StructureType,
30037     pub p_next: *const c_void,
30038     pub descriptor_set_count: u32,
30039     pub p_descriptor_counts: *const u32,
30040 }
30041 impl ::std::default::Default for DescriptorSetVariableDescriptorCountAllocateInfo {
30042     #[inline]
default() -> Self30043     fn default() -> Self {
30044         Self {
30045             s_type: Self::STRUCTURE_TYPE,
30046             p_next: ::std::ptr::null(),
30047             descriptor_set_count: u32::default(),
30048             p_descriptor_counts: ::std::ptr::null(),
30049         }
30050     }
30051 }
30052 unsafe impl TaggedStructure for DescriptorSetVariableDescriptorCountAllocateInfo {
30053     const STRUCTURE_TYPE: StructureType =
30054         StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO;
30055 }
30056 impl DescriptorSetVariableDescriptorCountAllocateInfo {
builder<'a>() -> DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a>30057     pub fn builder<'a>() -> DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
30058         DescriptorSetVariableDescriptorCountAllocateInfoBuilder {
30059             inner: Self::default(),
30060             marker: ::std::marker::PhantomData,
30061         }
30062     }
30063 }
30064 #[repr(transparent)]
30065 pub struct DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
30066     inner: DescriptorSetVariableDescriptorCountAllocateInfo,
30067     marker: ::std::marker::PhantomData<&'a ()>,
30068 }
30069 unsafe impl ExtendsDescriptorSetAllocateInfo
30070     for DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'_>
30071 {
30072 }
30073 unsafe impl ExtendsDescriptorSetAllocateInfo for DescriptorSetVariableDescriptorCountAllocateInfo {}
30074 impl<'a> ::std::ops::Deref for DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
30075     type Target = DescriptorSetVariableDescriptorCountAllocateInfo;
deref(&self) -> &Self::Target30076     fn deref(&self) -> &Self::Target {
30077         &self.inner
30078     }
30079 }
30080 impl<'a> ::std::ops::DerefMut for DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target30081     fn deref_mut(&mut self) -> &mut Self::Target {
30082         &mut self.inner
30083     }
30084 }
30085 impl<'a> DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
30086     #[inline]
descriptor_counts(mut self, descriptor_counts: &'a [u32]) -> Self30087     pub fn descriptor_counts(mut self, descriptor_counts: &'a [u32]) -> Self {
30088         self.inner.descriptor_set_count = descriptor_counts.len() as _;
30089         self.inner.p_descriptor_counts = descriptor_counts.as_ptr();
30090         self
30091     }
30092     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30093     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30094     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorSetVariableDescriptorCountAllocateInfo30095     pub fn build(self) -> DescriptorSetVariableDescriptorCountAllocateInfo {
30096         self.inner
30097     }
30098 }
30099 #[repr(C)]
30100 #[cfg_attr(feature = "debug", derive(Debug))]
30101 #[derive(Copy, Clone)]
30102 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetVariableDescriptorCountLayoutSupport.html>"]
30103 pub struct DescriptorSetVariableDescriptorCountLayoutSupport {
30104     pub s_type: StructureType,
30105     pub p_next: *mut c_void,
30106     pub max_variable_descriptor_count: u32,
30107 }
30108 impl ::std::default::Default for DescriptorSetVariableDescriptorCountLayoutSupport {
30109     #[inline]
default() -> Self30110     fn default() -> Self {
30111         Self {
30112             s_type: Self::STRUCTURE_TYPE,
30113             p_next: ::std::ptr::null_mut(),
30114             max_variable_descriptor_count: u32::default(),
30115         }
30116     }
30117 }
30118 unsafe impl TaggedStructure for DescriptorSetVariableDescriptorCountLayoutSupport {
30119     const STRUCTURE_TYPE: StructureType =
30120         StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT;
30121 }
30122 impl DescriptorSetVariableDescriptorCountLayoutSupport {
builder<'a>() -> DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a>30123     pub fn builder<'a>() -> DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
30124         DescriptorSetVariableDescriptorCountLayoutSupportBuilder {
30125             inner: Self::default(),
30126             marker: ::std::marker::PhantomData,
30127         }
30128     }
30129 }
30130 #[repr(transparent)]
30131 pub struct DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
30132     inner: DescriptorSetVariableDescriptorCountLayoutSupport,
30133     marker: ::std::marker::PhantomData<&'a ()>,
30134 }
30135 unsafe impl ExtendsDescriptorSetLayoutSupport
30136     for DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'_>
30137 {
30138 }
30139 unsafe impl ExtendsDescriptorSetLayoutSupport
30140     for DescriptorSetVariableDescriptorCountLayoutSupport
30141 {
30142 }
30143 impl<'a> ::std::ops::Deref for DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
30144     type Target = DescriptorSetVariableDescriptorCountLayoutSupport;
deref(&self) -> &Self::Target30145     fn deref(&self) -> &Self::Target {
30146         &self.inner
30147     }
30148 }
30149 impl<'a> ::std::ops::DerefMut for DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target30150     fn deref_mut(&mut self) -> &mut Self::Target {
30151         &mut self.inner
30152     }
30153 }
30154 impl<'a> DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
30155     #[inline]
max_variable_descriptor_count(mut self, max_variable_descriptor_count: u32) -> Self30156     pub fn max_variable_descriptor_count(mut self, max_variable_descriptor_count: u32) -> Self {
30157         self.inner.max_variable_descriptor_count = max_variable_descriptor_count;
30158         self
30159     }
30160     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30161     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30162     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorSetVariableDescriptorCountLayoutSupport30163     pub fn build(self) -> DescriptorSetVariableDescriptorCountLayoutSupport {
30164         self.inner
30165     }
30166 }
30167 #[repr(C)]
30168 #[cfg_attr(feature = "debug", derive(Debug))]
30169 #[derive(Copy, Clone)]
30170 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentDescription2.html>"]
30171 pub struct AttachmentDescription2 {
30172     pub s_type: StructureType,
30173     pub p_next: *const c_void,
30174     pub flags: AttachmentDescriptionFlags,
30175     pub format: Format,
30176     pub samples: SampleCountFlags,
30177     pub load_op: AttachmentLoadOp,
30178     pub store_op: AttachmentStoreOp,
30179     pub stencil_load_op: AttachmentLoadOp,
30180     pub stencil_store_op: AttachmentStoreOp,
30181     pub initial_layout: ImageLayout,
30182     pub final_layout: ImageLayout,
30183 }
30184 impl ::std::default::Default for AttachmentDescription2 {
30185     #[inline]
default() -> Self30186     fn default() -> Self {
30187         Self {
30188             s_type: Self::STRUCTURE_TYPE,
30189             p_next: ::std::ptr::null(),
30190             flags: AttachmentDescriptionFlags::default(),
30191             format: Format::default(),
30192             samples: SampleCountFlags::default(),
30193             load_op: AttachmentLoadOp::default(),
30194             store_op: AttachmentStoreOp::default(),
30195             stencil_load_op: AttachmentLoadOp::default(),
30196             stencil_store_op: AttachmentStoreOp::default(),
30197             initial_layout: ImageLayout::default(),
30198             final_layout: ImageLayout::default(),
30199         }
30200     }
30201 }
30202 unsafe impl TaggedStructure for AttachmentDescription2 {
30203     const STRUCTURE_TYPE: StructureType = StructureType::ATTACHMENT_DESCRIPTION_2;
30204 }
30205 impl AttachmentDescription2 {
builder<'a>() -> AttachmentDescription2Builder<'a>30206     pub fn builder<'a>() -> AttachmentDescription2Builder<'a> {
30207         AttachmentDescription2Builder {
30208             inner: Self::default(),
30209             marker: ::std::marker::PhantomData,
30210         }
30211     }
30212 }
30213 #[repr(transparent)]
30214 pub struct AttachmentDescription2Builder<'a> {
30215     inner: AttachmentDescription2,
30216     marker: ::std::marker::PhantomData<&'a ()>,
30217 }
30218 pub unsafe trait ExtendsAttachmentDescription2 {}
30219 impl<'a> ::std::ops::Deref for AttachmentDescription2Builder<'a> {
30220     type Target = AttachmentDescription2;
deref(&self) -> &Self::Target30221     fn deref(&self) -> &Self::Target {
30222         &self.inner
30223     }
30224 }
30225 impl<'a> ::std::ops::DerefMut for AttachmentDescription2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target30226     fn deref_mut(&mut self) -> &mut Self::Target {
30227         &mut self.inner
30228     }
30229 }
30230 impl<'a> AttachmentDescription2Builder<'a> {
30231     #[inline]
flags(mut self, flags: AttachmentDescriptionFlags) -> Self30232     pub fn flags(mut self, flags: AttachmentDescriptionFlags) -> Self {
30233         self.inner.flags = flags;
30234         self
30235     }
30236     #[inline]
format(mut self, format: Format) -> Self30237     pub fn format(mut self, format: Format) -> Self {
30238         self.inner.format = format;
30239         self
30240     }
30241     #[inline]
samples(mut self, samples: SampleCountFlags) -> Self30242     pub fn samples(mut self, samples: SampleCountFlags) -> Self {
30243         self.inner.samples = samples;
30244         self
30245     }
30246     #[inline]
load_op(mut self, load_op: AttachmentLoadOp) -> Self30247     pub fn load_op(mut self, load_op: AttachmentLoadOp) -> Self {
30248         self.inner.load_op = load_op;
30249         self
30250     }
30251     #[inline]
store_op(mut self, store_op: AttachmentStoreOp) -> Self30252     pub fn store_op(mut self, store_op: AttachmentStoreOp) -> Self {
30253         self.inner.store_op = store_op;
30254         self
30255     }
30256     #[inline]
stencil_load_op(mut self, stencil_load_op: AttachmentLoadOp) -> Self30257     pub fn stencil_load_op(mut self, stencil_load_op: AttachmentLoadOp) -> Self {
30258         self.inner.stencil_load_op = stencil_load_op;
30259         self
30260     }
30261     #[inline]
stencil_store_op(mut self, stencil_store_op: AttachmentStoreOp) -> Self30262     pub fn stencil_store_op(mut self, stencil_store_op: AttachmentStoreOp) -> Self {
30263         self.inner.stencil_store_op = stencil_store_op;
30264         self
30265     }
30266     #[inline]
initial_layout(mut self, initial_layout: ImageLayout) -> Self30267     pub fn initial_layout(mut self, initial_layout: ImageLayout) -> Self {
30268         self.inner.initial_layout = initial_layout;
30269         self
30270     }
30271     #[inline]
final_layout(mut self, final_layout: ImageLayout) -> Self30272     pub fn final_layout(mut self, final_layout: ImageLayout) -> Self {
30273         self.inner.final_layout = final_layout;
30274         self
30275     }
30276     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
30277     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
30278     #[doc = r" valid extension structs can be pushed into the chain."]
30279     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
30280     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsAttachmentDescription2>(mut self, next: &'a mut T) -> Self30281     pub fn push_next<T: ExtendsAttachmentDescription2>(mut self, next: &'a mut T) -> Self {
30282         unsafe {
30283             let next_ptr = <*const T>::cast(next);
30284             let last_next = ptr_chain_iter(next).last().unwrap();
30285             (*last_next).p_next = self.inner.p_next as _;
30286             self.inner.p_next = next_ptr;
30287         }
30288         self
30289     }
30290     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30291     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30292     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AttachmentDescription230293     pub fn build(self) -> AttachmentDescription2 {
30294         self.inner
30295     }
30296 }
30297 #[repr(C)]
30298 #[cfg_attr(feature = "debug", derive(Debug))]
30299 #[derive(Copy, Clone)]
30300 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentReference2.html>"]
30301 pub struct AttachmentReference2 {
30302     pub s_type: StructureType,
30303     pub p_next: *const c_void,
30304     pub attachment: u32,
30305     pub layout: ImageLayout,
30306     pub aspect_mask: ImageAspectFlags,
30307 }
30308 impl ::std::default::Default for AttachmentReference2 {
30309     #[inline]
default() -> Self30310     fn default() -> Self {
30311         Self {
30312             s_type: Self::STRUCTURE_TYPE,
30313             p_next: ::std::ptr::null(),
30314             attachment: u32::default(),
30315             layout: ImageLayout::default(),
30316             aspect_mask: ImageAspectFlags::default(),
30317         }
30318     }
30319 }
30320 unsafe impl TaggedStructure for AttachmentReference2 {
30321     const STRUCTURE_TYPE: StructureType = StructureType::ATTACHMENT_REFERENCE_2;
30322 }
30323 impl AttachmentReference2 {
builder<'a>() -> AttachmentReference2Builder<'a>30324     pub fn builder<'a>() -> AttachmentReference2Builder<'a> {
30325         AttachmentReference2Builder {
30326             inner: Self::default(),
30327             marker: ::std::marker::PhantomData,
30328         }
30329     }
30330 }
30331 #[repr(transparent)]
30332 pub struct AttachmentReference2Builder<'a> {
30333     inner: AttachmentReference2,
30334     marker: ::std::marker::PhantomData<&'a ()>,
30335 }
30336 pub unsafe trait ExtendsAttachmentReference2 {}
30337 impl<'a> ::std::ops::Deref for AttachmentReference2Builder<'a> {
30338     type Target = AttachmentReference2;
deref(&self) -> &Self::Target30339     fn deref(&self) -> &Self::Target {
30340         &self.inner
30341     }
30342 }
30343 impl<'a> ::std::ops::DerefMut for AttachmentReference2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target30344     fn deref_mut(&mut self) -> &mut Self::Target {
30345         &mut self.inner
30346     }
30347 }
30348 impl<'a> AttachmentReference2Builder<'a> {
30349     #[inline]
attachment(mut self, attachment: u32) -> Self30350     pub fn attachment(mut self, attachment: u32) -> Self {
30351         self.inner.attachment = attachment;
30352         self
30353     }
30354     #[inline]
layout(mut self, layout: ImageLayout) -> Self30355     pub fn layout(mut self, layout: ImageLayout) -> Self {
30356         self.inner.layout = layout;
30357         self
30358     }
30359     #[inline]
aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self30360     pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self {
30361         self.inner.aspect_mask = aspect_mask;
30362         self
30363     }
30364     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
30365     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
30366     #[doc = r" valid extension structs can be pushed into the chain."]
30367     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
30368     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsAttachmentReference2>(mut self, next: &'a mut T) -> Self30369     pub fn push_next<T: ExtendsAttachmentReference2>(mut self, next: &'a mut T) -> Self {
30370         unsafe {
30371             let next_ptr = <*const T>::cast(next);
30372             let last_next = ptr_chain_iter(next).last().unwrap();
30373             (*last_next).p_next = self.inner.p_next as _;
30374             self.inner.p_next = next_ptr;
30375         }
30376         self
30377     }
30378     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30379     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30380     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AttachmentReference230381     pub fn build(self) -> AttachmentReference2 {
30382         self.inner
30383     }
30384 }
30385 #[repr(C)]
30386 #[cfg_attr(feature = "debug", derive(Debug))]
30387 #[derive(Copy, Clone)]
30388 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDescription2.html>"]
30389 pub struct SubpassDescription2 {
30390     pub s_type: StructureType,
30391     pub p_next: *const c_void,
30392     pub flags: SubpassDescriptionFlags,
30393     pub pipeline_bind_point: PipelineBindPoint,
30394     pub view_mask: u32,
30395     pub input_attachment_count: u32,
30396     pub p_input_attachments: *const AttachmentReference2,
30397     pub color_attachment_count: u32,
30398     pub p_color_attachments: *const AttachmentReference2,
30399     pub p_resolve_attachments: *const AttachmentReference2,
30400     pub p_depth_stencil_attachment: *const AttachmentReference2,
30401     pub preserve_attachment_count: u32,
30402     pub p_preserve_attachments: *const u32,
30403 }
30404 impl ::std::default::Default for SubpassDescription2 {
30405     #[inline]
default() -> Self30406     fn default() -> Self {
30407         Self {
30408             s_type: Self::STRUCTURE_TYPE,
30409             p_next: ::std::ptr::null(),
30410             flags: SubpassDescriptionFlags::default(),
30411             pipeline_bind_point: PipelineBindPoint::default(),
30412             view_mask: u32::default(),
30413             input_attachment_count: u32::default(),
30414             p_input_attachments: ::std::ptr::null(),
30415             color_attachment_count: u32::default(),
30416             p_color_attachments: ::std::ptr::null(),
30417             p_resolve_attachments: ::std::ptr::null(),
30418             p_depth_stencil_attachment: ::std::ptr::null(),
30419             preserve_attachment_count: u32::default(),
30420             p_preserve_attachments: ::std::ptr::null(),
30421         }
30422     }
30423 }
30424 unsafe impl TaggedStructure for SubpassDescription2 {
30425     const STRUCTURE_TYPE: StructureType = StructureType::SUBPASS_DESCRIPTION_2;
30426 }
30427 impl SubpassDescription2 {
builder<'a>() -> SubpassDescription2Builder<'a>30428     pub fn builder<'a>() -> SubpassDescription2Builder<'a> {
30429         SubpassDescription2Builder {
30430             inner: Self::default(),
30431             marker: ::std::marker::PhantomData,
30432         }
30433     }
30434 }
30435 #[repr(transparent)]
30436 pub struct SubpassDescription2Builder<'a> {
30437     inner: SubpassDescription2,
30438     marker: ::std::marker::PhantomData<&'a ()>,
30439 }
30440 pub unsafe trait ExtendsSubpassDescription2 {}
30441 impl<'a> ::std::ops::Deref for SubpassDescription2Builder<'a> {
30442     type Target = SubpassDescription2;
deref(&self) -> &Self::Target30443     fn deref(&self) -> &Self::Target {
30444         &self.inner
30445     }
30446 }
30447 impl<'a> ::std::ops::DerefMut for SubpassDescription2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target30448     fn deref_mut(&mut self) -> &mut Self::Target {
30449         &mut self.inner
30450     }
30451 }
30452 impl<'a> SubpassDescription2Builder<'a> {
30453     #[inline]
flags(mut self, flags: SubpassDescriptionFlags) -> Self30454     pub fn flags(mut self, flags: SubpassDescriptionFlags) -> Self {
30455         self.inner.flags = flags;
30456         self
30457     }
30458     #[inline]
pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self30459     pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self {
30460         self.inner.pipeline_bind_point = pipeline_bind_point;
30461         self
30462     }
30463     #[inline]
view_mask(mut self, view_mask: u32) -> Self30464     pub fn view_mask(mut self, view_mask: u32) -> Self {
30465         self.inner.view_mask = view_mask;
30466         self
30467     }
30468     #[inline]
input_attachments(mut self, input_attachments: &'a [AttachmentReference2]) -> Self30469     pub fn input_attachments(mut self, input_attachments: &'a [AttachmentReference2]) -> Self {
30470         self.inner.input_attachment_count = input_attachments.len() as _;
30471         self.inner.p_input_attachments = input_attachments.as_ptr();
30472         self
30473     }
30474     #[inline]
color_attachments(mut self, color_attachments: &'a [AttachmentReference2]) -> Self30475     pub fn color_attachments(mut self, color_attachments: &'a [AttachmentReference2]) -> Self {
30476         self.inner.color_attachment_count = color_attachments.len() as _;
30477         self.inner.p_color_attachments = color_attachments.as_ptr();
30478         self
30479     }
30480     #[inline]
resolve_attachments(mut self, resolve_attachments: &'a [AttachmentReference2]) -> Self30481     pub fn resolve_attachments(mut self, resolve_attachments: &'a [AttachmentReference2]) -> Self {
30482         self.inner.color_attachment_count = resolve_attachments.len() as _;
30483         self.inner.p_resolve_attachments = resolve_attachments.as_ptr();
30484         self
30485     }
30486     #[inline]
depth_stencil_attachment( mut self, depth_stencil_attachment: &'a AttachmentReference2, ) -> Self30487     pub fn depth_stencil_attachment(
30488         mut self,
30489         depth_stencil_attachment: &'a AttachmentReference2,
30490     ) -> Self {
30491         self.inner.p_depth_stencil_attachment = depth_stencil_attachment;
30492         self
30493     }
30494     #[inline]
preserve_attachments(mut self, preserve_attachments: &'a [u32]) -> Self30495     pub fn preserve_attachments(mut self, preserve_attachments: &'a [u32]) -> Self {
30496         self.inner.preserve_attachment_count = preserve_attachments.len() as _;
30497         self.inner.p_preserve_attachments = preserve_attachments.as_ptr();
30498         self
30499     }
30500     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
30501     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
30502     #[doc = r" valid extension structs can be pushed into the chain."]
30503     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
30504     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSubpassDescription2>(mut self, next: &'a mut T) -> Self30505     pub fn push_next<T: ExtendsSubpassDescription2>(mut self, next: &'a mut T) -> Self {
30506         unsafe {
30507             let next_ptr = <*const T>::cast(next);
30508             let last_next = ptr_chain_iter(next).last().unwrap();
30509             (*last_next).p_next = self.inner.p_next as _;
30510             self.inner.p_next = next_ptr;
30511         }
30512         self
30513     }
30514     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30515     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30516     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SubpassDescription230517     pub fn build(self) -> SubpassDescription2 {
30518         self.inner
30519     }
30520 }
30521 #[repr(C)]
30522 #[cfg_attr(feature = "debug", derive(Debug))]
30523 #[derive(Copy, Clone)]
30524 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDependency2.html>"]
30525 pub struct SubpassDependency2 {
30526     pub s_type: StructureType,
30527     pub p_next: *const c_void,
30528     pub src_subpass: u32,
30529     pub dst_subpass: u32,
30530     pub src_stage_mask: PipelineStageFlags,
30531     pub dst_stage_mask: PipelineStageFlags,
30532     pub src_access_mask: AccessFlags,
30533     pub dst_access_mask: AccessFlags,
30534     pub dependency_flags: DependencyFlags,
30535     pub view_offset: i32,
30536 }
30537 impl ::std::default::Default for SubpassDependency2 {
30538     #[inline]
default() -> Self30539     fn default() -> Self {
30540         Self {
30541             s_type: Self::STRUCTURE_TYPE,
30542             p_next: ::std::ptr::null(),
30543             src_subpass: u32::default(),
30544             dst_subpass: u32::default(),
30545             src_stage_mask: PipelineStageFlags::default(),
30546             dst_stage_mask: PipelineStageFlags::default(),
30547             src_access_mask: AccessFlags::default(),
30548             dst_access_mask: AccessFlags::default(),
30549             dependency_flags: DependencyFlags::default(),
30550             view_offset: i32::default(),
30551         }
30552     }
30553 }
30554 unsafe impl TaggedStructure for SubpassDependency2 {
30555     const STRUCTURE_TYPE: StructureType = StructureType::SUBPASS_DEPENDENCY_2;
30556 }
30557 impl SubpassDependency2 {
builder<'a>() -> SubpassDependency2Builder<'a>30558     pub fn builder<'a>() -> SubpassDependency2Builder<'a> {
30559         SubpassDependency2Builder {
30560             inner: Self::default(),
30561             marker: ::std::marker::PhantomData,
30562         }
30563     }
30564 }
30565 #[repr(transparent)]
30566 pub struct SubpassDependency2Builder<'a> {
30567     inner: SubpassDependency2,
30568     marker: ::std::marker::PhantomData<&'a ()>,
30569 }
30570 pub unsafe trait ExtendsSubpassDependency2 {}
30571 impl<'a> ::std::ops::Deref for SubpassDependency2Builder<'a> {
30572     type Target = SubpassDependency2;
deref(&self) -> &Self::Target30573     fn deref(&self) -> &Self::Target {
30574         &self.inner
30575     }
30576 }
30577 impl<'a> ::std::ops::DerefMut for SubpassDependency2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target30578     fn deref_mut(&mut self) -> &mut Self::Target {
30579         &mut self.inner
30580     }
30581 }
30582 impl<'a> SubpassDependency2Builder<'a> {
30583     #[inline]
src_subpass(mut self, src_subpass: u32) -> Self30584     pub fn src_subpass(mut self, src_subpass: u32) -> Self {
30585         self.inner.src_subpass = src_subpass;
30586         self
30587     }
30588     #[inline]
dst_subpass(mut self, dst_subpass: u32) -> Self30589     pub fn dst_subpass(mut self, dst_subpass: u32) -> Self {
30590         self.inner.dst_subpass = dst_subpass;
30591         self
30592     }
30593     #[inline]
src_stage_mask(mut self, src_stage_mask: PipelineStageFlags) -> Self30594     pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags) -> Self {
30595         self.inner.src_stage_mask = src_stage_mask;
30596         self
30597     }
30598     #[inline]
dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags) -> Self30599     pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags) -> Self {
30600         self.inner.dst_stage_mask = dst_stage_mask;
30601         self
30602     }
30603     #[inline]
src_access_mask(mut self, src_access_mask: AccessFlags) -> Self30604     pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self {
30605         self.inner.src_access_mask = src_access_mask;
30606         self
30607     }
30608     #[inline]
dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self30609     pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self {
30610         self.inner.dst_access_mask = dst_access_mask;
30611         self
30612     }
30613     #[inline]
dependency_flags(mut self, dependency_flags: DependencyFlags) -> Self30614     pub fn dependency_flags(mut self, dependency_flags: DependencyFlags) -> Self {
30615         self.inner.dependency_flags = dependency_flags;
30616         self
30617     }
30618     #[inline]
view_offset(mut self, view_offset: i32) -> Self30619     pub fn view_offset(mut self, view_offset: i32) -> Self {
30620         self.inner.view_offset = view_offset;
30621         self
30622     }
30623     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
30624     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
30625     #[doc = r" valid extension structs can be pushed into the chain."]
30626     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
30627     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSubpassDependency2>(mut self, next: &'a mut T) -> Self30628     pub fn push_next<T: ExtendsSubpassDependency2>(mut self, next: &'a mut T) -> Self {
30629         unsafe {
30630             let next_ptr = <*const T>::cast(next);
30631             let last_next = ptr_chain_iter(next).last().unwrap();
30632             (*last_next).p_next = self.inner.p_next as _;
30633             self.inner.p_next = next_ptr;
30634         }
30635         self
30636     }
30637     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30638     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30639     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SubpassDependency230640     pub fn build(self) -> SubpassDependency2 {
30641         self.inner
30642     }
30643 }
30644 #[repr(C)]
30645 #[cfg_attr(feature = "debug", derive(Debug))]
30646 #[derive(Copy, Clone)]
30647 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassCreateInfo2.html>"]
30648 pub struct RenderPassCreateInfo2 {
30649     pub s_type: StructureType,
30650     pub p_next: *const c_void,
30651     pub flags: RenderPassCreateFlags,
30652     pub attachment_count: u32,
30653     pub p_attachments: *const AttachmentDescription2,
30654     pub subpass_count: u32,
30655     pub p_subpasses: *const SubpassDescription2,
30656     pub dependency_count: u32,
30657     pub p_dependencies: *const SubpassDependency2,
30658     pub correlated_view_mask_count: u32,
30659     pub p_correlated_view_masks: *const u32,
30660 }
30661 impl ::std::default::Default for RenderPassCreateInfo2 {
30662     #[inline]
default() -> Self30663     fn default() -> Self {
30664         Self {
30665             s_type: Self::STRUCTURE_TYPE,
30666             p_next: ::std::ptr::null(),
30667             flags: RenderPassCreateFlags::default(),
30668             attachment_count: u32::default(),
30669             p_attachments: ::std::ptr::null(),
30670             subpass_count: u32::default(),
30671             p_subpasses: ::std::ptr::null(),
30672             dependency_count: u32::default(),
30673             p_dependencies: ::std::ptr::null(),
30674             correlated_view_mask_count: u32::default(),
30675             p_correlated_view_masks: ::std::ptr::null(),
30676         }
30677     }
30678 }
30679 unsafe impl TaggedStructure for RenderPassCreateInfo2 {
30680     const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_CREATE_INFO_2;
30681 }
30682 impl RenderPassCreateInfo2 {
builder<'a>() -> RenderPassCreateInfo2Builder<'a>30683     pub fn builder<'a>() -> RenderPassCreateInfo2Builder<'a> {
30684         RenderPassCreateInfo2Builder {
30685             inner: Self::default(),
30686             marker: ::std::marker::PhantomData,
30687         }
30688     }
30689 }
30690 #[repr(transparent)]
30691 pub struct RenderPassCreateInfo2Builder<'a> {
30692     inner: RenderPassCreateInfo2,
30693     marker: ::std::marker::PhantomData<&'a ()>,
30694 }
30695 pub unsafe trait ExtendsRenderPassCreateInfo2 {}
30696 impl<'a> ::std::ops::Deref for RenderPassCreateInfo2Builder<'a> {
30697     type Target = RenderPassCreateInfo2;
deref(&self) -> &Self::Target30698     fn deref(&self) -> &Self::Target {
30699         &self.inner
30700     }
30701 }
30702 impl<'a> ::std::ops::DerefMut for RenderPassCreateInfo2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target30703     fn deref_mut(&mut self) -> &mut Self::Target {
30704         &mut self.inner
30705     }
30706 }
30707 impl<'a> RenderPassCreateInfo2Builder<'a> {
30708     #[inline]
flags(mut self, flags: RenderPassCreateFlags) -> Self30709     pub fn flags(mut self, flags: RenderPassCreateFlags) -> Self {
30710         self.inner.flags = flags;
30711         self
30712     }
30713     #[inline]
attachments(mut self, attachments: &'a [AttachmentDescription2]) -> Self30714     pub fn attachments(mut self, attachments: &'a [AttachmentDescription2]) -> Self {
30715         self.inner.attachment_count = attachments.len() as _;
30716         self.inner.p_attachments = attachments.as_ptr();
30717         self
30718     }
30719     #[inline]
subpasses(mut self, subpasses: &'a [SubpassDescription2]) -> Self30720     pub fn subpasses(mut self, subpasses: &'a [SubpassDescription2]) -> Self {
30721         self.inner.subpass_count = subpasses.len() as _;
30722         self.inner.p_subpasses = subpasses.as_ptr();
30723         self
30724     }
30725     #[inline]
dependencies(mut self, dependencies: &'a [SubpassDependency2]) -> Self30726     pub fn dependencies(mut self, dependencies: &'a [SubpassDependency2]) -> Self {
30727         self.inner.dependency_count = dependencies.len() as _;
30728         self.inner.p_dependencies = dependencies.as_ptr();
30729         self
30730     }
30731     #[inline]
correlated_view_masks(mut self, correlated_view_masks: &'a [u32]) -> Self30732     pub fn correlated_view_masks(mut self, correlated_view_masks: &'a [u32]) -> Self {
30733         self.inner.correlated_view_mask_count = correlated_view_masks.len() as _;
30734         self.inner.p_correlated_view_masks = correlated_view_masks.as_ptr();
30735         self
30736     }
30737     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
30738     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
30739     #[doc = r" valid extension structs can be pushed into the chain."]
30740     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
30741     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsRenderPassCreateInfo2>(mut self, next: &'a mut T) -> Self30742     pub fn push_next<T: ExtendsRenderPassCreateInfo2>(mut self, next: &'a mut T) -> Self {
30743         unsafe {
30744             let next_ptr = <*const T>::cast(next);
30745             let last_next = ptr_chain_iter(next).last().unwrap();
30746             (*last_next).p_next = self.inner.p_next as _;
30747             self.inner.p_next = next_ptr;
30748         }
30749         self
30750     }
30751     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30752     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30753     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RenderPassCreateInfo230754     pub fn build(self) -> RenderPassCreateInfo2 {
30755         self.inner
30756     }
30757 }
30758 #[repr(C)]
30759 #[cfg_attr(feature = "debug", derive(Debug))]
30760 #[derive(Copy, Clone)]
30761 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassBeginInfo.html>"]
30762 pub struct SubpassBeginInfo {
30763     pub s_type: StructureType,
30764     pub p_next: *const c_void,
30765     pub contents: SubpassContents,
30766 }
30767 impl ::std::default::Default for SubpassBeginInfo {
30768     #[inline]
default() -> Self30769     fn default() -> Self {
30770         Self {
30771             s_type: Self::STRUCTURE_TYPE,
30772             p_next: ::std::ptr::null(),
30773             contents: SubpassContents::default(),
30774         }
30775     }
30776 }
30777 unsafe impl TaggedStructure for SubpassBeginInfo {
30778     const STRUCTURE_TYPE: StructureType = StructureType::SUBPASS_BEGIN_INFO;
30779 }
30780 impl SubpassBeginInfo {
builder<'a>() -> SubpassBeginInfoBuilder<'a>30781     pub fn builder<'a>() -> SubpassBeginInfoBuilder<'a> {
30782         SubpassBeginInfoBuilder {
30783             inner: Self::default(),
30784             marker: ::std::marker::PhantomData,
30785         }
30786     }
30787 }
30788 #[repr(transparent)]
30789 pub struct SubpassBeginInfoBuilder<'a> {
30790     inner: SubpassBeginInfo,
30791     marker: ::std::marker::PhantomData<&'a ()>,
30792 }
30793 impl<'a> ::std::ops::Deref for SubpassBeginInfoBuilder<'a> {
30794     type Target = SubpassBeginInfo;
deref(&self) -> &Self::Target30795     fn deref(&self) -> &Self::Target {
30796         &self.inner
30797     }
30798 }
30799 impl<'a> ::std::ops::DerefMut for SubpassBeginInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target30800     fn deref_mut(&mut self) -> &mut Self::Target {
30801         &mut self.inner
30802     }
30803 }
30804 impl<'a> SubpassBeginInfoBuilder<'a> {
30805     #[inline]
contents(mut self, contents: SubpassContents) -> Self30806     pub fn contents(mut self, contents: SubpassContents) -> Self {
30807         self.inner.contents = contents;
30808         self
30809     }
30810     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30811     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30812     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SubpassBeginInfo30813     pub fn build(self) -> SubpassBeginInfo {
30814         self.inner
30815     }
30816 }
30817 #[repr(C)]
30818 #[cfg_attr(feature = "debug", derive(Debug))]
30819 #[derive(Copy, Clone)]
30820 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassEndInfo.html>"]
30821 pub struct SubpassEndInfo {
30822     pub s_type: StructureType,
30823     pub p_next: *const c_void,
30824 }
30825 impl ::std::default::Default for SubpassEndInfo {
30826     #[inline]
default() -> Self30827     fn default() -> Self {
30828         Self {
30829             s_type: Self::STRUCTURE_TYPE,
30830             p_next: ::std::ptr::null(),
30831         }
30832     }
30833 }
30834 unsafe impl TaggedStructure for SubpassEndInfo {
30835     const STRUCTURE_TYPE: StructureType = StructureType::SUBPASS_END_INFO;
30836 }
30837 impl SubpassEndInfo {
builder<'a>() -> SubpassEndInfoBuilder<'a>30838     pub fn builder<'a>() -> SubpassEndInfoBuilder<'a> {
30839         SubpassEndInfoBuilder {
30840             inner: Self::default(),
30841             marker: ::std::marker::PhantomData,
30842         }
30843     }
30844 }
30845 #[repr(transparent)]
30846 pub struct SubpassEndInfoBuilder<'a> {
30847     inner: SubpassEndInfo,
30848     marker: ::std::marker::PhantomData<&'a ()>,
30849 }
30850 pub unsafe trait ExtendsSubpassEndInfo {}
30851 impl<'a> ::std::ops::Deref for SubpassEndInfoBuilder<'a> {
30852     type Target = SubpassEndInfo;
deref(&self) -> &Self::Target30853     fn deref(&self) -> &Self::Target {
30854         &self.inner
30855     }
30856 }
30857 impl<'a> ::std::ops::DerefMut for SubpassEndInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target30858     fn deref_mut(&mut self) -> &mut Self::Target {
30859         &mut self.inner
30860     }
30861 }
30862 impl<'a> SubpassEndInfoBuilder<'a> {
30863     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
30864     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
30865     #[doc = r" valid extension structs can be pushed into the chain."]
30866     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
30867     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSubpassEndInfo>(mut self, next: &'a mut T) -> Self30868     pub fn push_next<T: ExtendsSubpassEndInfo>(mut self, next: &'a mut T) -> Self {
30869         unsafe {
30870             let next_ptr = <*const T>::cast(next);
30871             let last_next = ptr_chain_iter(next).last().unwrap();
30872             (*last_next).p_next = self.inner.p_next as _;
30873             self.inner.p_next = next_ptr;
30874         }
30875         self
30876     }
30877     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30878     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30879     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SubpassEndInfo30880     pub fn build(self) -> SubpassEndInfo {
30881         self.inner
30882     }
30883 }
30884 #[repr(C)]
30885 #[cfg_attr(feature = "debug", derive(Debug))]
30886 #[derive(Copy, Clone)]
30887 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTimelineSemaphoreFeatures.html>"]
30888 pub struct PhysicalDeviceTimelineSemaphoreFeatures {
30889     pub s_type: StructureType,
30890     pub p_next: *mut c_void,
30891     pub timeline_semaphore: Bool32,
30892 }
30893 impl ::std::default::Default for PhysicalDeviceTimelineSemaphoreFeatures {
30894     #[inline]
default() -> Self30895     fn default() -> Self {
30896         Self {
30897             s_type: Self::STRUCTURE_TYPE,
30898             p_next: ::std::ptr::null_mut(),
30899             timeline_semaphore: Bool32::default(),
30900         }
30901     }
30902 }
30903 unsafe impl TaggedStructure for PhysicalDeviceTimelineSemaphoreFeatures {
30904     const STRUCTURE_TYPE: StructureType =
30905         StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
30906 }
30907 impl PhysicalDeviceTimelineSemaphoreFeatures {
builder<'a>() -> PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a>30908     pub fn builder<'a>() -> PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
30909         PhysicalDeviceTimelineSemaphoreFeaturesBuilder {
30910             inner: Self::default(),
30911             marker: ::std::marker::PhantomData,
30912         }
30913     }
30914 }
30915 #[repr(transparent)]
30916 pub struct PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
30917     inner: PhysicalDeviceTimelineSemaphoreFeatures,
30918     marker: ::std::marker::PhantomData<&'a ()>,
30919 }
30920 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'_> {}
30921 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTimelineSemaphoreFeatures {}
30922 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'_> {}
30923 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTimelineSemaphoreFeatures {}
30924 impl<'a> ::std::ops::Deref for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
30925     type Target = PhysicalDeviceTimelineSemaphoreFeatures;
deref(&self) -> &Self::Target30926     fn deref(&self) -> &Self::Target {
30927         &self.inner
30928     }
30929 }
30930 impl<'a> ::std::ops::DerefMut for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target30931     fn deref_mut(&mut self) -> &mut Self::Target {
30932         &mut self.inner
30933     }
30934 }
30935 impl<'a> PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
30936     #[inline]
timeline_semaphore(mut self, timeline_semaphore: bool) -> Self30937     pub fn timeline_semaphore(mut self, timeline_semaphore: bool) -> Self {
30938         self.inner.timeline_semaphore = timeline_semaphore.into();
30939         self
30940     }
30941     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30942     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30943     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceTimelineSemaphoreFeatures30944     pub fn build(self) -> PhysicalDeviceTimelineSemaphoreFeatures {
30945         self.inner
30946     }
30947 }
30948 #[repr(C)]
30949 #[cfg_attr(feature = "debug", derive(Debug))]
30950 #[derive(Copy, Clone)]
30951 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTimelineSemaphoreProperties.html>"]
30952 pub struct PhysicalDeviceTimelineSemaphoreProperties {
30953     pub s_type: StructureType,
30954     pub p_next: *mut c_void,
30955     pub max_timeline_semaphore_value_difference: u64,
30956 }
30957 impl ::std::default::Default for PhysicalDeviceTimelineSemaphoreProperties {
30958     #[inline]
default() -> Self30959     fn default() -> Self {
30960         Self {
30961             s_type: Self::STRUCTURE_TYPE,
30962             p_next: ::std::ptr::null_mut(),
30963             max_timeline_semaphore_value_difference: u64::default(),
30964         }
30965     }
30966 }
30967 unsafe impl TaggedStructure for PhysicalDeviceTimelineSemaphoreProperties {
30968     const STRUCTURE_TYPE: StructureType =
30969         StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
30970 }
30971 impl PhysicalDeviceTimelineSemaphoreProperties {
builder<'a>() -> PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a>30972     pub fn builder<'a>() -> PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
30973         PhysicalDeviceTimelineSemaphorePropertiesBuilder {
30974             inner: Self::default(),
30975             marker: ::std::marker::PhantomData,
30976         }
30977     }
30978 }
30979 #[repr(transparent)]
30980 pub struct PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
30981     inner: PhysicalDeviceTimelineSemaphoreProperties,
30982     marker: ::std::marker::PhantomData<&'a ()>,
30983 }
30984 unsafe impl ExtendsPhysicalDeviceProperties2
30985     for PhysicalDeviceTimelineSemaphorePropertiesBuilder<'_>
30986 {
30987 }
30988 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTimelineSemaphoreProperties {}
30989 impl<'a> ::std::ops::Deref for PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
30990     type Target = PhysicalDeviceTimelineSemaphoreProperties;
deref(&self) -> &Self::Target30991     fn deref(&self) -> &Self::Target {
30992         &self.inner
30993     }
30994 }
30995 impl<'a> ::std::ops::DerefMut for PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target30996     fn deref_mut(&mut self) -> &mut Self::Target {
30997         &mut self.inner
30998     }
30999 }
31000 impl<'a> PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
31001     #[inline]
max_timeline_semaphore_value_difference( mut self, max_timeline_semaphore_value_difference: u64, ) -> Self31002     pub fn max_timeline_semaphore_value_difference(
31003         mut self,
31004         max_timeline_semaphore_value_difference: u64,
31005     ) -> Self {
31006         self.inner.max_timeline_semaphore_value_difference =
31007             max_timeline_semaphore_value_difference;
31008         self
31009     }
31010     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31011     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31012     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceTimelineSemaphoreProperties31013     pub fn build(self) -> PhysicalDeviceTimelineSemaphoreProperties {
31014         self.inner
31015     }
31016 }
31017 #[repr(C)]
31018 #[cfg_attr(feature = "debug", derive(Debug))]
31019 #[derive(Copy, Clone)]
31020 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreTypeCreateInfo.html>"]
31021 pub struct SemaphoreTypeCreateInfo {
31022     pub s_type: StructureType,
31023     pub p_next: *const c_void,
31024     pub semaphore_type: SemaphoreType,
31025     pub initial_value: u64,
31026 }
31027 impl ::std::default::Default for SemaphoreTypeCreateInfo {
31028     #[inline]
default() -> Self31029     fn default() -> Self {
31030         Self {
31031             s_type: Self::STRUCTURE_TYPE,
31032             p_next: ::std::ptr::null(),
31033             semaphore_type: SemaphoreType::default(),
31034             initial_value: u64::default(),
31035         }
31036     }
31037 }
31038 unsafe impl TaggedStructure for SemaphoreTypeCreateInfo {
31039     const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_TYPE_CREATE_INFO;
31040 }
31041 impl SemaphoreTypeCreateInfo {
builder<'a>() -> SemaphoreTypeCreateInfoBuilder<'a>31042     pub fn builder<'a>() -> SemaphoreTypeCreateInfoBuilder<'a> {
31043         SemaphoreTypeCreateInfoBuilder {
31044             inner: Self::default(),
31045             marker: ::std::marker::PhantomData,
31046         }
31047     }
31048 }
31049 #[repr(transparent)]
31050 pub struct SemaphoreTypeCreateInfoBuilder<'a> {
31051     inner: SemaphoreTypeCreateInfo,
31052     marker: ::std::marker::PhantomData<&'a ()>,
31053 }
31054 unsafe impl ExtendsSemaphoreCreateInfo for SemaphoreTypeCreateInfoBuilder<'_> {}
31055 unsafe impl ExtendsSemaphoreCreateInfo for SemaphoreTypeCreateInfo {}
31056 unsafe impl ExtendsPhysicalDeviceExternalSemaphoreInfo for SemaphoreTypeCreateInfoBuilder<'_> {}
31057 unsafe impl ExtendsPhysicalDeviceExternalSemaphoreInfo for SemaphoreTypeCreateInfo {}
31058 impl<'a> ::std::ops::Deref for SemaphoreTypeCreateInfoBuilder<'a> {
31059     type Target = SemaphoreTypeCreateInfo;
deref(&self) -> &Self::Target31060     fn deref(&self) -> &Self::Target {
31061         &self.inner
31062     }
31063 }
31064 impl<'a> ::std::ops::DerefMut for SemaphoreTypeCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target31065     fn deref_mut(&mut self) -> &mut Self::Target {
31066         &mut self.inner
31067     }
31068 }
31069 impl<'a> SemaphoreTypeCreateInfoBuilder<'a> {
31070     #[inline]
semaphore_type(mut self, semaphore_type: SemaphoreType) -> Self31071     pub fn semaphore_type(mut self, semaphore_type: SemaphoreType) -> Self {
31072         self.inner.semaphore_type = semaphore_type;
31073         self
31074     }
31075     #[inline]
initial_value(mut self, initial_value: u64) -> Self31076     pub fn initial_value(mut self, initial_value: u64) -> Self {
31077         self.inner.initial_value = initial_value;
31078         self
31079     }
31080     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31081     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31082     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SemaphoreTypeCreateInfo31083     pub fn build(self) -> SemaphoreTypeCreateInfo {
31084         self.inner
31085     }
31086 }
31087 #[repr(C)]
31088 #[cfg_attr(feature = "debug", derive(Debug))]
31089 #[derive(Copy, Clone)]
31090 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkTimelineSemaphoreSubmitInfo.html>"]
31091 pub struct TimelineSemaphoreSubmitInfo {
31092     pub s_type: StructureType,
31093     pub p_next: *const c_void,
31094     pub wait_semaphore_value_count: u32,
31095     pub p_wait_semaphore_values: *const u64,
31096     pub signal_semaphore_value_count: u32,
31097     pub p_signal_semaphore_values: *const u64,
31098 }
31099 impl ::std::default::Default for TimelineSemaphoreSubmitInfo {
31100     #[inline]
default() -> Self31101     fn default() -> Self {
31102         Self {
31103             s_type: Self::STRUCTURE_TYPE,
31104             p_next: ::std::ptr::null(),
31105             wait_semaphore_value_count: u32::default(),
31106             p_wait_semaphore_values: ::std::ptr::null(),
31107             signal_semaphore_value_count: u32::default(),
31108             p_signal_semaphore_values: ::std::ptr::null(),
31109         }
31110     }
31111 }
31112 unsafe impl TaggedStructure for TimelineSemaphoreSubmitInfo {
31113     const STRUCTURE_TYPE: StructureType = StructureType::TIMELINE_SEMAPHORE_SUBMIT_INFO;
31114 }
31115 impl TimelineSemaphoreSubmitInfo {
builder<'a>() -> TimelineSemaphoreSubmitInfoBuilder<'a>31116     pub fn builder<'a>() -> TimelineSemaphoreSubmitInfoBuilder<'a> {
31117         TimelineSemaphoreSubmitInfoBuilder {
31118             inner: Self::default(),
31119             marker: ::std::marker::PhantomData,
31120         }
31121     }
31122 }
31123 #[repr(transparent)]
31124 pub struct TimelineSemaphoreSubmitInfoBuilder<'a> {
31125     inner: TimelineSemaphoreSubmitInfo,
31126     marker: ::std::marker::PhantomData<&'a ()>,
31127 }
31128 unsafe impl ExtendsSubmitInfo for TimelineSemaphoreSubmitInfoBuilder<'_> {}
31129 unsafe impl ExtendsSubmitInfo for TimelineSemaphoreSubmitInfo {}
31130 unsafe impl ExtendsBindSparseInfo for TimelineSemaphoreSubmitInfoBuilder<'_> {}
31131 unsafe impl ExtendsBindSparseInfo for TimelineSemaphoreSubmitInfo {}
31132 impl<'a> ::std::ops::Deref for TimelineSemaphoreSubmitInfoBuilder<'a> {
31133     type Target = TimelineSemaphoreSubmitInfo;
deref(&self) -> &Self::Target31134     fn deref(&self) -> &Self::Target {
31135         &self.inner
31136     }
31137 }
31138 impl<'a> ::std::ops::DerefMut for TimelineSemaphoreSubmitInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target31139     fn deref_mut(&mut self) -> &mut Self::Target {
31140         &mut self.inner
31141     }
31142 }
31143 impl<'a> TimelineSemaphoreSubmitInfoBuilder<'a> {
31144     #[inline]
wait_semaphore_values(mut self, wait_semaphore_values: &'a [u64]) -> Self31145     pub fn wait_semaphore_values(mut self, wait_semaphore_values: &'a [u64]) -> Self {
31146         self.inner.wait_semaphore_value_count = wait_semaphore_values.len() as _;
31147         self.inner.p_wait_semaphore_values = wait_semaphore_values.as_ptr();
31148         self
31149     }
31150     #[inline]
signal_semaphore_values(mut self, signal_semaphore_values: &'a [u64]) -> Self31151     pub fn signal_semaphore_values(mut self, signal_semaphore_values: &'a [u64]) -> Self {
31152         self.inner.signal_semaphore_value_count = signal_semaphore_values.len() as _;
31153         self.inner.p_signal_semaphore_values = signal_semaphore_values.as_ptr();
31154         self
31155     }
31156     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31157     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31158     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> TimelineSemaphoreSubmitInfo31159     pub fn build(self) -> TimelineSemaphoreSubmitInfo {
31160         self.inner
31161     }
31162 }
31163 #[repr(C)]
31164 #[cfg_attr(feature = "debug", derive(Debug))]
31165 #[derive(Copy, Clone)]
31166 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreWaitInfo.html>"]
31167 pub struct SemaphoreWaitInfo {
31168     pub s_type: StructureType,
31169     pub p_next: *const c_void,
31170     pub flags: SemaphoreWaitFlags,
31171     pub semaphore_count: u32,
31172     pub p_semaphores: *const Semaphore,
31173     pub p_values: *const u64,
31174 }
31175 impl ::std::default::Default for SemaphoreWaitInfo {
31176     #[inline]
default() -> Self31177     fn default() -> Self {
31178         Self {
31179             s_type: Self::STRUCTURE_TYPE,
31180             p_next: ::std::ptr::null(),
31181             flags: SemaphoreWaitFlags::default(),
31182             semaphore_count: u32::default(),
31183             p_semaphores: ::std::ptr::null(),
31184             p_values: ::std::ptr::null(),
31185         }
31186     }
31187 }
31188 unsafe impl TaggedStructure for SemaphoreWaitInfo {
31189     const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_WAIT_INFO;
31190 }
31191 impl SemaphoreWaitInfo {
builder<'a>() -> SemaphoreWaitInfoBuilder<'a>31192     pub fn builder<'a>() -> SemaphoreWaitInfoBuilder<'a> {
31193         SemaphoreWaitInfoBuilder {
31194             inner: Self::default(),
31195             marker: ::std::marker::PhantomData,
31196         }
31197     }
31198 }
31199 #[repr(transparent)]
31200 pub struct SemaphoreWaitInfoBuilder<'a> {
31201     inner: SemaphoreWaitInfo,
31202     marker: ::std::marker::PhantomData<&'a ()>,
31203 }
31204 impl<'a> ::std::ops::Deref for SemaphoreWaitInfoBuilder<'a> {
31205     type Target = SemaphoreWaitInfo;
deref(&self) -> &Self::Target31206     fn deref(&self) -> &Self::Target {
31207         &self.inner
31208     }
31209 }
31210 impl<'a> ::std::ops::DerefMut for SemaphoreWaitInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target31211     fn deref_mut(&mut self) -> &mut Self::Target {
31212         &mut self.inner
31213     }
31214 }
31215 impl<'a> SemaphoreWaitInfoBuilder<'a> {
31216     #[inline]
flags(mut self, flags: SemaphoreWaitFlags) -> Self31217     pub fn flags(mut self, flags: SemaphoreWaitFlags) -> Self {
31218         self.inner.flags = flags;
31219         self
31220     }
31221     #[inline]
semaphores(mut self, semaphores: &'a [Semaphore]) -> Self31222     pub fn semaphores(mut self, semaphores: &'a [Semaphore]) -> Self {
31223         self.inner.semaphore_count = semaphores.len() as _;
31224         self.inner.p_semaphores = semaphores.as_ptr();
31225         self
31226     }
31227     #[inline]
values(mut self, values: &'a [u64]) -> Self31228     pub fn values(mut self, values: &'a [u64]) -> Self {
31229         self.inner.semaphore_count = values.len() as _;
31230         self.inner.p_values = values.as_ptr();
31231         self
31232     }
31233     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31234     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31235     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SemaphoreWaitInfo31236     pub fn build(self) -> SemaphoreWaitInfo {
31237         self.inner
31238     }
31239 }
31240 #[repr(C)]
31241 #[cfg_attr(feature = "debug", derive(Debug))]
31242 #[derive(Copy, Clone)]
31243 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreSignalInfo.html>"]
31244 pub struct SemaphoreSignalInfo {
31245     pub s_type: StructureType,
31246     pub p_next: *const c_void,
31247     pub semaphore: Semaphore,
31248     pub value: u64,
31249 }
31250 impl ::std::default::Default for SemaphoreSignalInfo {
31251     #[inline]
default() -> Self31252     fn default() -> Self {
31253         Self {
31254             s_type: Self::STRUCTURE_TYPE,
31255             p_next: ::std::ptr::null(),
31256             semaphore: Semaphore::default(),
31257             value: u64::default(),
31258         }
31259     }
31260 }
31261 unsafe impl TaggedStructure for SemaphoreSignalInfo {
31262     const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_SIGNAL_INFO;
31263 }
31264 impl SemaphoreSignalInfo {
builder<'a>() -> SemaphoreSignalInfoBuilder<'a>31265     pub fn builder<'a>() -> SemaphoreSignalInfoBuilder<'a> {
31266         SemaphoreSignalInfoBuilder {
31267             inner: Self::default(),
31268             marker: ::std::marker::PhantomData,
31269         }
31270     }
31271 }
31272 #[repr(transparent)]
31273 pub struct SemaphoreSignalInfoBuilder<'a> {
31274     inner: SemaphoreSignalInfo,
31275     marker: ::std::marker::PhantomData<&'a ()>,
31276 }
31277 impl<'a> ::std::ops::Deref for SemaphoreSignalInfoBuilder<'a> {
31278     type Target = SemaphoreSignalInfo;
deref(&self) -> &Self::Target31279     fn deref(&self) -> &Self::Target {
31280         &self.inner
31281     }
31282 }
31283 impl<'a> ::std::ops::DerefMut for SemaphoreSignalInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target31284     fn deref_mut(&mut self) -> &mut Self::Target {
31285         &mut self.inner
31286     }
31287 }
31288 impl<'a> SemaphoreSignalInfoBuilder<'a> {
31289     #[inline]
semaphore(mut self, semaphore: Semaphore) -> Self31290     pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
31291         self.inner.semaphore = semaphore;
31292         self
31293     }
31294     #[inline]
value(mut self, value: u64) -> Self31295     pub fn value(mut self, value: u64) -> Self {
31296         self.inner.value = value;
31297         self
31298     }
31299     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31300     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31301     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SemaphoreSignalInfo31302     pub fn build(self) -> SemaphoreSignalInfo {
31303         self.inner
31304     }
31305 }
31306 #[repr(C)]
31307 #[cfg_attr(feature = "debug", derive(Debug))]
31308 #[derive(Copy, Clone, Default)]
31309 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVertexInputBindingDivisorDescriptionEXT.html>"]
31310 pub struct VertexInputBindingDivisorDescriptionEXT {
31311     pub binding: u32,
31312     pub divisor: u32,
31313 }
31314 impl VertexInputBindingDivisorDescriptionEXT {
builder<'a>() -> VertexInputBindingDivisorDescriptionEXTBuilder<'a>31315     pub fn builder<'a>() -> VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
31316         VertexInputBindingDivisorDescriptionEXTBuilder {
31317             inner: Self::default(),
31318             marker: ::std::marker::PhantomData,
31319         }
31320     }
31321 }
31322 #[repr(transparent)]
31323 pub struct VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
31324     inner: VertexInputBindingDivisorDescriptionEXT,
31325     marker: ::std::marker::PhantomData<&'a ()>,
31326 }
31327 impl<'a> ::std::ops::Deref for VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
31328     type Target = VertexInputBindingDivisorDescriptionEXT;
deref(&self) -> &Self::Target31329     fn deref(&self) -> &Self::Target {
31330         &self.inner
31331     }
31332 }
31333 impl<'a> ::std::ops::DerefMut for VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target31334     fn deref_mut(&mut self) -> &mut Self::Target {
31335         &mut self.inner
31336     }
31337 }
31338 impl<'a> VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
31339     #[inline]
binding(mut self, binding: u32) -> Self31340     pub fn binding(mut self, binding: u32) -> Self {
31341         self.inner.binding = binding;
31342         self
31343     }
31344     #[inline]
divisor(mut self, divisor: u32) -> Self31345     pub fn divisor(mut self, divisor: u32) -> Self {
31346         self.inner.divisor = divisor;
31347         self
31348     }
31349     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31350     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31351     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VertexInputBindingDivisorDescriptionEXT31352     pub fn build(self) -> VertexInputBindingDivisorDescriptionEXT {
31353         self.inner
31354     }
31355 }
31356 #[repr(C)]
31357 #[cfg_attr(feature = "debug", derive(Debug))]
31358 #[derive(Copy, Clone)]
31359 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineVertexInputDivisorStateCreateInfoEXT.html>"]
31360 pub struct PipelineVertexInputDivisorStateCreateInfoEXT {
31361     pub s_type: StructureType,
31362     pub p_next: *const c_void,
31363     pub vertex_binding_divisor_count: u32,
31364     pub p_vertex_binding_divisors: *const VertexInputBindingDivisorDescriptionEXT,
31365 }
31366 impl ::std::default::Default for PipelineVertexInputDivisorStateCreateInfoEXT {
31367     #[inline]
default() -> Self31368     fn default() -> Self {
31369         Self {
31370             s_type: Self::STRUCTURE_TYPE,
31371             p_next: ::std::ptr::null(),
31372             vertex_binding_divisor_count: u32::default(),
31373             p_vertex_binding_divisors: ::std::ptr::null(),
31374         }
31375     }
31376 }
31377 unsafe impl TaggedStructure for PipelineVertexInputDivisorStateCreateInfoEXT {
31378     const STRUCTURE_TYPE: StructureType =
31379         StructureType::PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT;
31380 }
31381 impl PipelineVertexInputDivisorStateCreateInfoEXT {
builder<'a>() -> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a>31382     pub fn builder<'a>() -> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
31383         PipelineVertexInputDivisorStateCreateInfoEXTBuilder {
31384             inner: Self::default(),
31385             marker: ::std::marker::PhantomData,
31386         }
31387     }
31388 }
31389 #[repr(transparent)]
31390 pub struct PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
31391     inner: PipelineVertexInputDivisorStateCreateInfoEXT,
31392     marker: ::std::marker::PhantomData<&'a ()>,
31393 }
31394 unsafe impl ExtendsPipelineVertexInputStateCreateInfo
31395     for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'_>
31396 {
31397 }
31398 unsafe impl ExtendsPipelineVertexInputStateCreateInfo
31399     for PipelineVertexInputDivisorStateCreateInfoEXT
31400 {
31401 }
31402 impl<'a> ::std::ops::Deref for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
31403     type Target = PipelineVertexInputDivisorStateCreateInfoEXT;
deref(&self) -> &Self::Target31404     fn deref(&self) -> &Self::Target {
31405         &self.inner
31406     }
31407 }
31408 impl<'a> ::std::ops::DerefMut for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target31409     fn deref_mut(&mut self) -> &mut Self::Target {
31410         &mut self.inner
31411     }
31412 }
31413 impl<'a> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
31414     #[inline]
vertex_binding_divisors( mut self, vertex_binding_divisors: &'a [VertexInputBindingDivisorDescriptionEXT], ) -> Self31415     pub fn vertex_binding_divisors(
31416         mut self,
31417         vertex_binding_divisors: &'a [VertexInputBindingDivisorDescriptionEXT],
31418     ) -> Self {
31419         self.inner.vertex_binding_divisor_count = vertex_binding_divisors.len() as _;
31420         self.inner.p_vertex_binding_divisors = vertex_binding_divisors.as_ptr();
31421         self
31422     }
31423     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31424     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31425     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineVertexInputDivisorStateCreateInfoEXT31426     pub fn build(self) -> PipelineVertexInputDivisorStateCreateInfoEXT {
31427         self.inner
31428     }
31429 }
31430 #[repr(C)]
31431 #[cfg_attr(feature = "debug", derive(Debug))]
31432 #[derive(Copy, Clone)]
31433 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT.html>"]
31434 pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
31435     pub s_type: StructureType,
31436     pub p_next: *mut c_void,
31437     pub max_vertex_attrib_divisor: u32,
31438 }
31439 impl ::std::default::Default for PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
31440     #[inline]
default() -> Self31441     fn default() -> Self {
31442         Self {
31443             s_type: Self::STRUCTURE_TYPE,
31444             p_next: ::std::ptr::null_mut(),
31445             max_vertex_attrib_divisor: u32::default(),
31446         }
31447     }
31448 }
31449 unsafe impl TaggedStructure for PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
31450     const STRUCTURE_TYPE: StructureType =
31451         StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT;
31452 }
31453 impl PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
builder<'a>() -> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a>31454     pub fn builder<'a>() -> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
31455         PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder {
31456             inner: Self::default(),
31457             marker: ::std::marker::PhantomData,
31458         }
31459     }
31460 }
31461 #[repr(transparent)]
31462 pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
31463     inner: PhysicalDeviceVertexAttributeDivisorPropertiesEXT,
31464     marker: ::std::marker::PhantomData<&'a ()>,
31465 }
31466 unsafe impl ExtendsPhysicalDeviceProperties2
31467     for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'_>
31468 {
31469 }
31470 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVertexAttributeDivisorPropertiesEXT {}
31471 impl<'a> ::std::ops::Deref for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
31472     type Target = PhysicalDeviceVertexAttributeDivisorPropertiesEXT;
deref(&self) -> &Self::Target31473     fn deref(&self) -> &Self::Target {
31474         &self.inner
31475     }
31476 }
31477 impl<'a> ::std::ops::DerefMut for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target31478     fn deref_mut(&mut self) -> &mut Self::Target {
31479         &mut self.inner
31480     }
31481 }
31482 impl<'a> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
31483     #[inline]
max_vertex_attrib_divisor(mut self, max_vertex_attrib_divisor: u32) -> Self31484     pub fn max_vertex_attrib_divisor(mut self, max_vertex_attrib_divisor: u32) -> Self {
31485         self.inner.max_vertex_attrib_divisor = max_vertex_attrib_divisor;
31486         self
31487     }
31488     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31489     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31490     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceVertexAttributeDivisorPropertiesEXT31491     pub fn build(self) -> PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
31492         self.inner
31493     }
31494 }
31495 #[repr(C)]
31496 #[cfg_attr(feature = "debug", derive(Debug))]
31497 #[derive(Copy, Clone)]
31498 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePCIBusInfoPropertiesEXT.html>"]
31499 pub struct PhysicalDevicePCIBusInfoPropertiesEXT {
31500     pub s_type: StructureType,
31501     pub p_next: *mut c_void,
31502     pub pci_domain: u32,
31503     pub pci_bus: u32,
31504     pub pci_device: u32,
31505     pub pci_function: u32,
31506 }
31507 impl ::std::default::Default for PhysicalDevicePCIBusInfoPropertiesEXT {
31508     #[inline]
default() -> Self31509     fn default() -> Self {
31510         Self {
31511             s_type: Self::STRUCTURE_TYPE,
31512             p_next: ::std::ptr::null_mut(),
31513             pci_domain: u32::default(),
31514             pci_bus: u32::default(),
31515             pci_device: u32::default(),
31516             pci_function: u32::default(),
31517         }
31518     }
31519 }
31520 unsafe impl TaggedStructure for PhysicalDevicePCIBusInfoPropertiesEXT {
31521     const STRUCTURE_TYPE: StructureType =
31522         StructureType::PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT;
31523 }
31524 impl PhysicalDevicePCIBusInfoPropertiesEXT {
builder<'a>() -> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a>31525     pub fn builder<'a>() -> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
31526         PhysicalDevicePCIBusInfoPropertiesEXTBuilder {
31527             inner: Self::default(),
31528             marker: ::std::marker::PhantomData,
31529         }
31530     }
31531 }
31532 #[repr(transparent)]
31533 pub struct PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
31534     inner: PhysicalDevicePCIBusInfoPropertiesEXT,
31535     marker: ::std::marker::PhantomData<&'a ()>,
31536 }
31537 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'_> {}
31538 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePCIBusInfoPropertiesEXT {}
31539 impl<'a> ::std::ops::Deref for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
31540     type Target = PhysicalDevicePCIBusInfoPropertiesEXT;
deref(&self) -> &Self::Target31541     fn deref(&self) -> &Self::Target {
31542         &self.inner
31543     }
31544 }
31545 impl<'a> ::std::ops::DerefMut for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target31546     fn deref_mut(&mut self) -> &mut Self::Target {
31547         &mut self.inner
31548     }
31549 }
31550 impl<'a> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
31551     #[inline]
pci_domain(mut self, pci_domain: u32) -> Self31552     pub fn pci_domain(mut self, pci_domain: u32) -> Self {
31553         self.inner.pci_domain = pci_domain;
31554         self
31555     }
31556     #[inline]
pci_bus(mut self, pci_bus: u32) -> Self31557     pub fn pci_bus(mut self, pci_bus: u32) -> Self {
31558         self.inner.pci_bus = pci_bus;
31559         self
31560     }
31561     #[inline]
pci_device(mut self, pci_device: u32) -> Self31562     pub fn pci_device(mut self, pci_device: u32) -> Self {
31563         self.inner.pci_device = pci_device;
31564         self
31565     }
31566     #[inline]
pci_function(mut self, pci_function: u32) -> Self31567     pub fn pci_function(mut self, pci_function: u32) -> Self {
31568         self.inner.pci_function = pci_function;
31569         self
31570     }
31571     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31572     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31573     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePCIBusInfoPropertiesEXT31574     pub fn build(self) -> PhysicalDevicePCIBusInfoPropertiesEXT {
31575         self.inner
31576     }
31577 }
31578 #[repr(C)]
31579 #[cfg_attr(feature = "debug", derive(Debug))]
31580 #[derive(Copy, Clone)]
31581 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportAndroidHardwareBufferInfoANDROID.html>"]
31582 pub struct ImportAndroidHardwareBufferInfoANDROID {
31583     pub s_type: StructureType,
31584     pub p_next: *const c_void,
31585     pub buffer: *mut AHardwareBuffer,
31586 }
31587 impl ::std::default::Default for ImportAndroidHardwareBufferInfoANDROID {
31588     #[inline]
default() -> Self31589     fn default() -> Self {
31590         Self {
31591             s_type: Self::STRUCTURE_TYPE,
31592             p_next: ::std::ptr::null(),
31593             buffer: ::std::ptr::null_mut(),
31594         }
31595     }
31596 }
31597 unsafe impl TaggedStructure for ImportAndroidHardwareBufferInfoANDROID {
31598     const STRUCTURE_TYPE: StructureType =
31599         StructureType::IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID;
31600 }
31601 impl ImportAndroidHardwareBufferInfoANDROID {
builder<'a>() -> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a>31602     pub fn builder<'a>() -> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
31603         ImportAndroidHardwareBufferInfoANDROIDBuilder {
31604             inner: Self::default(),
31605             marker: ::std::marker::PhantomData,
31606         }
31607     }
31608 }
31609 #[repr(transparent)]
31610 pub struct ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
31611     inner: ImportAndroidHardwareBufferInfoANDROID,
31612     marker: ::std::marker::PhantomData<&'a ()>,
31613 }
31614 unsafe impl ExtendsMemoryAllocateInfo for ImportAndroidHardwareBufferInfoANDROIDBuilder<'_> {}
31615 unsafe impl ExtendsMemoryAllocateInfo for ImportAndroidHardwareBufferInfoANDROID {}
31616 impl<'a> ::std::ops::Deref for ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
31617     type Target = ImportAndroidHardwareBufferInfoANDROID;
deref(&self) -> &Self::Target31618     fn deref(&self) -> &Self::Target {
31619         &self.inner
31620     }
31621 }
31622 impl<'a> ::std::ops::DerefMut for ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target31623     fn deref_mut(&mut self) -> &mut Self::Target {
31624         &mut self.inner
31625     }
31626 }
31627 impl<'a> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
31628     #[inline]
buffer(mut self, buffer: *mut AHardwareBuffer) -> Self31629     pub fn buffer(mut self, buffer: *mut AHardwareBuffer) -> Self {
31630         self.inner.buffer = buffer;
31631         self
31632     }
31633     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31634     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31635     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImportAndroidHardwareBufferInfoANDROID31636     pub fn build(self) -> ImportAndroidHardwareBufferInfoANDROID {
31637         self.inner
31638     }
31639 }
31640 #[repr(C)]
31641 #[cfg_attr(feature = "debug", derive(Debug))]
31642 #[derive(Copy, Clone)]
31643 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAndroidHardwareBufferUsageANDROID.html>"]
31644 pub struct AndroidHardwareBufferUsageANDROID {
31645     pub s_type: StructureType,
31646     pub p_next: *mut c_void,
31647     pub android_hardware_buffer_usage: u64,
31648 }
31649 impl ::std::default::Default for AndroidHardwareBufferUsageANDROID {
31650     #[inline]
default() -> Self31651     fn default() -> Self {
31652         Self {
31653             s_type: Self::STRUCTURE_TYPE,
31654             p_next: ::std::ptr::null_mut(),
31655             android_hardware_buffer_usage: u64::default(),
31656         }
31657     }
31658 }
31659 unsafe impl TaggedStructure for AndroidHardwareBufferUsageANDROID {
31660     const STRUCTURE_TYPE: StructureType = StructureType::ANDROID_HARDWARE_BUFFER_USAGE_ANDROID;
31661 }
31662 impl AndroidHardwareBufferUsageANDROID {
builder<'a>() -> AndroidHardwareBufferUsageANDROIDBuilder<'a>31663     pub fn builder<'a>() -> AndroidHardwareBufferUsageANDROIDBuilder<'a> {
31664         AndroidHardwareBufferUsageANDROIDBuilder {
31665             inner: Self::default(),
31666             marker: ::std::marker::PhantomData,
31667         }
31668     }
31669 }
31670 #[repr(transparent)]
31671 pub struct AndroidHardwareBufferUsageANDROIDBuilder<'a> {
31672     inner: AndroidHardwareBufferUsageANDROID,
31673     marker: ::std::marker::PhantomData<&'a ()>,
31674 }
31675 unsafe impl ExtendsImageFormatProperties2 for AndroidHardwareBufferUsageANDROIDBuilder<'_> {}
31676 unsafe impl ExtendsImageFormatProperties2 for AndroidHardwareBufferUsageANDROID {}
31677 impl<'a> ::std::ops::Deref for AndroidHardwareBufferUsageANDROIDBuilder<'a> {
31678     type Target = AndroidHardwareBufferUsageANDROID;
deref(&self) -> &Self::Target31679     fn deref(&self) -> &Self::Target {
31680         &self.inner
31681     }
31682 }
31683 impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferUsageANDROIDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target31684     fn deref_mut(&mut self) -> &mut Self::Target {
31685         &mut self.inner
31686     }
31687 }
31688 impl<'a> AndroidHardwareBufferUsageANDROIDBuilder<'a> {
31689     #[inline]
android_hardware_buffer_usage(mut self, android_hardware_buffer_usage: u64) -> Self31690     pub fn android_hardware_buffer_usage(mut self, android_hardware_buffer_usage: u64) -> Self {
31691         self.inner.android_hardware_buffer_usage = android_hardware_buffer_usage;
31692         self
31693     }
31694     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31695     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31696     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AndroidHardwareBufferUsageANDROID31697     pub fn build(self) -> AndroidHardwareBufferUsageANDROID {
31698         self.inner
31699     }
31700 }
31701 #[repr(C)]
31702 #[cfg_attr(feature = "debug", derive(Debug))]
31703 #[derive(Copy, Clone)]
31704 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAndroidHardwareBufferPropertiesANDROID.html>"]
31705 pub struct AndroidHardwareBufferPropertiesANDROID {
31706     pub s_type: StructureType,
31707     pub p_next: *mut c_void,
31708     pub allocation_size: DeviceSize,
31709     pub memory_type_bits: u32,
31710 }
31711 impl ::std::default::Default for AndroidHardwareBufferPropertiesANDROID {
31712     #[inline]
default() -> Self31713     fn default() -> Self {
31714         Self {
31715             s_type: Self::STRUCTURE_TYPE,
31716             p_next: ::std::ptr::null_mut(),
31717             allocation_size: DeviceSize::default(),
31718             memory_type_bits: u32::default(),
31719         }
31720     }
31721 }
31722 unsafe impl TaggedStructure for AndroidHardwareBufferPropertiesANDROID {
31723     const STRUCTURE_TYPE: StructureType = StructureType::ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID;
31724 }
31725 impl AndroidHardwareBufferPropertiesANDROID {
builder<'a>() -> AndroidHardwareBufferPropertiesANDROIDBuilder<'a>31726     pub fn builder<'a>() -> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
31727         AndroidHardwareBufferPropertiesANDROIDBuilder {
31728             inner: Self::default(),
31729             marker: ::std::marker::PhantomData,
31730         }
31731     }
31732 }
31733 #[repr(transparent)]
31734 pub struct AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
31735     inner: AndroidHardwareBufferPropertiesANDROID,
31736     marker: ::std::marker::PhantomData<&'a ()>,
31737 }
31738 pub unsafe trait ExtendsAndroidHardwareBufferPropertiesANDROID {}
31739 impl<'a> ::std::ops::Deref for AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
31740     type Target = AndroidHardwareBufferPropertiesANDROID;
deref(&self) -> &Self::Target31741     fn deref(&self) -> &Self::Target {
31742         &self.inner
31743     }
31744 }
31745 impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target31746     fn deref_mut(&mut self) -> &mut Self::Target {
31747         &mut self.inner
31748     }
31749 }
31750 impl<'a> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
31751     #[inline]
allocation_size(mut self, allocation_size: DeviceSize) -> Self31752     pub fn allocation_size(mut self, allocation_size: DeviceSize) -> Self {
31753         self.inner.allocation_size = allocation_size;
31754         self
31755     }
31756     #[inline]
memory_type_bits(mut self, memory_type_bits: u32) -> Self31757     pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self {
31758         self.inner.memory_type_bits = memory_type_bits;
31759         self
31760     }
31761     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
31762     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
31763     #[doc = r" valid extension structs can be pushed into the chain."]
31764     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
31765     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsAndroidHardwareBufferPropertiesANDROID>( mut self, next: &'a mut T, ) -> Self31766     pub fn push_next<T: ExtendsAndroidHardwareBufferPropertiesANDROID>(
31767         mut self,
31768         next: &'a mut T,
31769     ) -> Self {
31770         unsafe {
31771             let next_ptr = <*mut T>::cast(next);
31772             let last_next = ptr_chain_iter(next).last().unwrap();
31773             (*last_next).p_next = self.inner.p_next as _;
31774             self.inner.p_next = next_ptr;
31775         }
31776         self
31777     }
31778     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31779     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31780     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AndroidHardwareBufferPropertiesANDROID31781     pub fn build(self) -> AndroidHardwareBufferPropertiesANDROID {
31782         self.inner
31783     }
31784 }
31785 #[repr(C)]
31786 #[cfg_attr(feature = "debug", derive(Debug))]
31787 #[derive(Copy, Clone)]
31788 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryGetAndroidHardwareBufferInfoANDROID.html>"]
31789 pub struct MemoryGetAndroidHardwareBufferInfoANDROID {
31790     pub s_type: StructureType,
31791     pub p_next: *const c_void,
31792     pub memory: DeviceMemory,
31793 }
31794 impl ::std::default::Default for MemoryGetAndroidHardwareBufferInfoANDROID {
31795     #[inline]
default() -> Self31796     fn default() -> Self {
31797         Self {
31798             s_type: Self::STRUCTURE_TYPE,
31799             p_next: ::std::ptr::null(),
31800             memory: DeviceMemory::default(),
31801         }
31802     }
31803 }
31804 unsafe impl TaggedStructure for MemoryGetAndroidHardwareBufferInfoANDROID {
31805     const STRUCTURE_TYPE: StructureType =
31806         StructureType::MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID;
31807 }
31808 impl MemoryGetAndroidHardwareBufferInfoANDROID {
builder<'a>() -> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a>31809     pub fn builder<'a>() -> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
31810         MemoryGetAndroidHardwareBufferInfoANDROIDBuilder {
31811             inner: Self::default(),
31812             marker: ::std::marker::PhantomData,
31813         }
31814     }
31815 }
31816 #[repr(transparent)]
31817 pub struct MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
31818     inner: MemoryGetAndroidHardwareBufferInfoANDROID,
31819     marker: ::std::marker::PhantomData<&'a ()>,
31820 }
31821 impl<'a> ::std::ops::Deref for MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
31822     type Target = MemoryGetAndroidHardwareBufferInfoANDROID;
deref(&self) -> &Self::Target31823     fn deref(&self) -> &Self::Target {
31824         &self.inner
31825     }
31826 }
31827 impl<'a> ::std::ops::DerefMut for MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target31828     fn deref_mut(&mut self) -> &mut Self::Target {
31829         &mut self.inner
31830     }
31831 }
31832 impl<'a> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
31833     #[inline]
memory(mut self, memory: DeviceMemory) -> Self31834     pub fn memory(mut self, memory: DeviceMemory) -> Self {
31835         self.inner.memory = memory;
31836         self
31837     }
31838     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31839     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31840     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryGetAndroidHardwareBufferInfoANDROID31841     pub fn build(self) -> MemoryGetAndroidHardwareBufferInfoANDROID {
31842         self.inner
31843     }
31844 }
31845 #[repr(C)]
31846 #[cfg_attr(feature = "debug", derive(Debug))]
31847 #[derive(Copy, Clone)]
31848 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAndroidHardwareBufferFormatPropertiesANDROID.html>"]
31849 pub struct AndroidHardwareBufferFormatPropertiesANDROID {
31850     pub s_type: StructureType,
31851     pub p_next: *mut c_void,
31852     pub format: Format,
31853     pub external_format: u64,
31854     pub format_features: FormatFeatureFlags,
31855     pub sampler_ycbcr_conversion_components: ComponentMapping,
31856     pub suggested_ycbcr_model: SamplerYcbcrModelConversion,
31857     pub suggested_ycbcr_range: SamplerYcbcrRange,
31858     pub suggested_x_chroma_offset: ChromaLocation,
31859     pub suggested_y_chroma_offset: ChromaLocation,
31860 }
31861 impl ::std::default::Default for AndroidHardwareBufferFormatPropertiesANDROID {
31862     #[inline]
default() -> Self31863     fn default() -> Self {
31864         Self {
31865             s_type: Self::STRUCTURE_TYPE,
31866             p_next: ::std::ptr::null_mut(),
31867             format: Format::default(),
31868             external_format: u64::default(),
31869             format_features: FormatFeatureFlags::default(),
31870             sampler_ycbcr_conversion_components: ComponentMapping::default(),
31871             suggested_ycbcr_model: SamplerYcbcrModelConversion::default(),
31872             suggested_ycbcr_range: SamplerYcbcrRange::default(),
31873             suggested_x_chroma_offset: ChromaLocation::default(),
31874             suggested_y_chroma_offset: ChromaLocation::default(),
31875         }
31876     }
31877 }
31878 unsafe impl TaggedStructure for AndroidHardwareBufferFormatPropertiesANDROID {
31879     const STRUCTURE_TYPE: StructureType =
31880         StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID;
31881 }
31882 impl AndroidHardwareBufferFormatPropertiesANDROID {
builder<'a>() -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a>31883     pub fn builder<'a>() -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
31884         AndroidHardwareBufferFormatPropertiesANDROIDBuilder {
31885             inner: Self::default(),
31886             marker: ::std::marker::PhantomData,
31887         }
31888     }
31889 }
31890 #[repr(transparent)]
31891 pub struct AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
31892     inner: AndroidHardwareBufferFormatPropertiesANDROID,
31893     marker: ::std::marker::PhantomData<&'a ()>,
31894 }
31895 unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID
31896     for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'_>
31897 {
31898 }
31899 unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID
31900     for AndroidHardwareBufferFormatPropertiesANDROID
31901 {
31902 }
31903 impl<'a> ::std::ops::Deref for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
31904     type Target = AndroidHardwareBufferFormatPropertiesANDROID;
deref(&self) -> &Self::Target31905     fn deref(&self) -> &Self::Target {
31906         &self.inner
31907     }
31908 }
31909 impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target31910     fn deref_mut(&mut self) -> &mut Self::Target {
31911         &mut self.inner
31912     }
31913 }
31914 impl<'a> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
31915     #[inline]
format(mut self, format: Format) -> Self31916     pub fn format(mut self, format: Format) -> Self {
31917         self.inner.format = format;
31918         self
31919     }
31920     #[inline]
external_format(mut self, external_format: u64) -> Self31921     pub fn external_format(mut self, external_format: u64) -> Self {
31922         self.inner.external_format = external_format;
31923         self
31924     }
31925     #[inline]
format_features(mut self, format_features: FormatFeatureFlags) -> Self31926     pub fn format_features(mut self, format_features: FormatFeatureFlags) -> Self {
31927         self.inner.format_features = format_features;
31928         self
31929     }
31930     #[inline]
sampler_ycbcr_conversion_components( mut self, sampler_ycbcr_conversion_components: ComponentMapping, ) -> Self31931     pub fn sampler_ycbcr_conversion_components(
31932         mut self,
31933         sampler_ycbcr_conversion_components: ComponentMapping,
31934     ) -> Self {
31935         self.inner.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components;
31936         self
31937     }
31938     #[inline]
suggested_ycbcr_model( mut self, suggested_ycbcr_model: SamplerYcbcrModelConversion, ) -> Self31939     pub fn suggested_ycbcr_model(
31940         mut self,
31941         suggested_ycbcr_model: SamplerYcbcrModelConversion,
31942     ) -> Self {
31943         self.inner.suggested_ycbcr_model = suggested_ycbcr_model;
31944         self
31945     }
31946     #[inline]
suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self31947     pub fn suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self {
31948         self.inner.suggested_ycbcr_range = suggested_ycbcr_range;
31949         self
31950     }
31951     #[inline]
suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self31952     pub fn suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self {
31953         self.inner.suggested_x_chroma_offset = suggested_x_chroma_offset;
31954         self
31955     }
31956     #[inline]
suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self31957     pub fn suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self {
31958         self.inner.suggested_y_chroma_offset = suggested_y_chroma_offset;
31959         self
31960     }
31961     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31962     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31963     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AndroidHardwareBufferFormatPropertiesANDROID31964     pub fn build(self) -> AndroidHardwareBufferFormatPropertiesANDROID {
31965         self.inner
31966     }
31967 }
31968 #[repr(C)]
31969 #[cfg_attr(feature = "debug", derive(Debug))]
31970 #[derive(Copy, Clone)]
31971 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferInheritanceConditionalRenderingInfoEXT.html>"]
31972 pub struct CommandBufferInheritanceConditionalRenderingInfoEXT {
31973     pub s_type: StructureType,
31974     pub p_next: *const c_void,
31975     pub conditional_rendering_enable: Bool32,
31976 }
31977 impl ::std::default::Default for CommandBufferInheritanceConditionalRenderingInfoEXT {
31978     #[inline]
default() -> Self31979     fn default() -> Self {
31980         Self {
31981             s_type: Self::STRUCTURE_TYPE,
31982             p_next: ::std::ptr::null(),
31983             conditional_rendering_enable: Bool32::default(),
31984         }
31985     }
31986 }
31987 unsafe impl TaggedStructure for CommandBufferInheritanceConditionalRenderingInfoEXT {
31988     const STRUCTURE_TYPE: StructureType =
31989         StructureType::COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT;
31990 }
31991 impl CommandBufferInheritanceConditionalRenderingInfoEXT {
builder<'a>() -> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a>31992     pub fn builder<'a>() -> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
31993         CommandBufferInheritanceConditionalRenderingInfoEXTBuilder {
31994             inner: Self::default(),
31995             marker: ::std::marker::PhantomData,
31996         }
31997     }
31998 }
31999 #[repr(transparent)]
32000 pub struct CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
32001     inner: CommandBufferInheritanceConditionalRenderingInfoEXT,
32002     marker: ::std::marker::PhantomData<&'a ()>,
32003 }
32004 unsafe impl ExtendsCommandBufferInheritanceInfo
32005     for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'_>
32006 {
32007 }
32008 unsafe impl ExtendsCommandBufferInheritanceInfo
32009     for CommandBufferInheritanceConditionalRenderingInfoEXT
32010 {
32011 }
32012 impl<'a> ::std::ops::Deref for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
32013     type Target = CommandBufferInheritanceConditionalRenderingInfoEXT;
deref(&self) -> &Self::Target32014     fn deref(&self) -> &Self::Target {
32015         &self.inner
32016     }
32017 }
32018 impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target32019     fn deref_mut(&mut self) -> &mut Self::Target {
32020         &mut self.inner
32021     }
32022 }
32023 impl<'a> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
32024     #[inline]
conditional_rendering_enable(mut self, conditional_rendering_enable: bool) -> Self32025     pub fn conditional_rendering_enable(mut self, conditional_rendering_enable: bool) -> Self {
32026         self.inner.conditional_rendering_enable = conditional_rendering_enable.into();
32027         self
32028     }
32029     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32030     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32031     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CommandBufferInheritanceConditionalRenderingInfoEXT32032     pub fn build(self) -> CommandBufferInheritanceConditionalRenderingInfoEXT {
32033         self.inner
32034     }
32035 }
32036 #[repr(C)]
32037 #[cfg_attr(feature = "debug", derive(Debug))]
32038 #[derive(Copy, Clone)]
32039 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalFormatANDROID.html>"]
32040 pub struct ExternalFormatANDROID {
32041     pub s_type: StructureType,
32042     pub p_next: *mut c_void,
32043     pub external_format: u64,
32044 }
32045 impl ::std::default::Default for ExternalFormatANDROID {
32046     #[inline]
default() -> Self32047     fn default() -> Self {
32048         Self {
32049             s_type: Self::STRUCTURE_TYPE,
32050             p_next: ::std::ptr::null_mut(),
32051             external_format: u64::default(),
32052         }
32053     }
32054 }
32055 unsafe impl TaggedStructure for ExternalFormatANDROID {
32056     const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_FORMAT_ANDROID;
32057 }
32058 impl ExternalFormatANDROID {
builder<'a>() -> ExternalFormatANDROIDBuilder<'a>32059     pub fn builder<'a>() -> ExternalFormatANDROIDBuilder<'a> {
32060         ExternalFormatANDROIDBuilder {
32061             inner: Self::default(),
32062             marker: ::std::marker::PhantomData,
32063         }
32064     }
32065 }
32066 #[repr(transparent)]
32067 pub struct ExternalFormatANDROIDBuilder<'a> {
32068     inner: ExternalFormatANDROID,
32069     marker: ::std::marker::PhantomData<&'a ()>,
32070 }
32071 unsafe impl ExtendsImageCreateInfo for ExternalFormatANDROIDBuilder<'_> {}
32072 unsafe impl ExtendsImageCreateInfo for ExternalFormatANDROID {}
32073 unsafe impl ExtendsSamplerYcbcrConversionCreateInfo for ExternalFormatANDROIDBuilder<'_> {}
32074 unsafe impl ExtendsSamplerYcbcrConversionCreateInfo for ExternalFormatANDROID {}
32075 impl<'a> ::std::ops::Deref for ExternalFormatANDROIDBuilder<'a> {
32076     type Target = ExternalFormatANDROID;
deref(&self) -> &Self::Target32077     fn deref(&self) -> &Self::Target {
32078         &self.inner
32079     }
32080 }
32081 impl<'a> ::std::ops::DerefMut for ExternalFormatANDROIDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target32082     fn deref_mut(&mut self) -> &mut Self::Target {
32083         &mut self.inner
32084     }
32085 }
32086 impl<'a> ExternalFormatANDROIDBuilder<'a> {
32087     #[inline]
external_format(mut self, external_format: u64) -> Self32088     pub fn external_format(mut self, external_format: u64) -> Self {
32089         self.inner.external_format = external_format;
32090         self
32091     }
32092     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32093     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32094     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExternalFormatANDROID32095     pub fn build(self) -> ExternalFormatANDROID {
32096         self.inner
32097     }
32098 }
32099 #[repr(C)]
32100 #[cfg_attr(feature = "debug", derive(Debug))]
32101 #[derive(Copy, Clone)]
32102 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevice8BitStorageFeatures.html>"]
32103 pub struct PhysicalDevice8BitStorageFeatures {
32104     pub s_type: StructureType,
32105     pub p_next: *mut c_void,
32106     pub storage_buffer8_bit_access: Bool32,
32107     pub uniform_and_storage_buffer8_bit_access: Bool32,
32108     pub storage_push_constant8: Bool32,
32109 }
32110 impl ::std::default::Default for PhysicalDevice8BitStorageFeatures {
32111     #[inline]
default() -> Self32112     fn default() -> Self {
32113         Self {
32114             s_type: Self::STRUCTURE_TYPE,
32115             p_next: ::std::ptr::null_mut(),
32116             storage_buffer8_bit_access: Bool32::default(),
32117             uniform_and_storage_buffer8_bit_access: Bool32::default(),
32118             storage_push_constant8: Bool32::default(),
32119         }
32120     }
32121 }
32122 unsafe impl TaggedStructure for PhysicalDevice8BitStorageFeatures {
32123     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
32124 }
32125 impl PhysicalDevice8BitStorageFeatures {
builder<'a>() -> PhysicalDevice8BitStorageFeaturesBuilder<'a>32126     pub fn builder<'a>() -> PhysicalDevice8BitStorageFeaturesBuilder<'a> {
32127         PhysicalDevice8BitStorageFeaturesBuilder {
32128             inner: Self::default(),
32129             marker: ::std::marker::PhantomData,
32130         }
32131     }
32132 }
32133 #[repr(transparent)]
32134 pub struct PhysicalDevice8BitStorageFeaturesBuilder<'a> {
32135     inner: PhysicalDevice8BitStorageFeatures,
32136     marker: ::std::marker::PhantomData<&'a ()>,
32137 }
32138 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice8BitStorageFeaturesBuilder<'_> {}
32139 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice8BitStorageFeatures {}
32140 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice8BitStorageFeaturesBuilder<'_> {}
32141 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice8BitStorageFeatures {}
32142 impl<'a> ::std::ops::Deref for PhysicalDevice8BitStorageFeaturesBuilder<'a> {
32143     type Target = PhysicalDevice8BitStorageFeatures;
deref(&self) -> &Self::Target32144     fn deref(&self) -> &Self::Target {
32145         &self.inner
32146     }
32147 }
32148 impl<'a> ::std::ops::DerefMut for PhysicalDevice8BitStorageFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target32149     fn deref_mut(&mut self) -> &mut Self::Target {
32150         &mut self.inner
32151     }
32152 }
32153 impl<'a> PhysicalDevice8BitStorageFeaturesBuilder<'a> {
32154     #[inline]
storage_buffer8_bit_access(mut self, storage_buffer8_bit_access: bool) -> Self32155     pub fn storage_buffer8_bit_access(mut self, storage_buffer8_bit_access: bool) -> Self {
32156         self.inner.storage_buffer8_bit_access = storage_buffer8_bit_access.into();
32157         self
32158     }
32159     #[inline]
uniform_and_storage_buffer8_bit_access( mut self, uniform_and_storage_buffer8_bit_access: bool, ) -> Self32160     pub fn uniform_and_storage_buffer8_bit_access(
32161         mut self,
32162         uniform_and_storage_buffer8_bit_access: bool,
32163     ) -> Self {
32164         self.inner.uniform_and_storage_buffer8_bit_access =
32165             uniform_and_storage_buffer8_bit_access.into();
32166         self
32167     }
32168     #[inline]
storage_push_constant8(mut self, storage_push_constant8: bool) -> Self32169     pub fn storage_push_constant8(mut self, storage_push_constant8: bool) -> Self {
32170         self.inner.storage_push_constant8 = storage_push_constant8.into();
32171         self
32172     }
32173     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32174     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32175     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevice8BitStorageFeatures32176     pub fn build(self) -> PhysicalDevice8BitStorageFeatures {
32177         self.inner
32178     }
32179 }
32180 #[repr(C)]
32181 #[cfg_attr(feature = "debug", derive(Debug))]
32182 #[derive(Copy, Clone)]
32183 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceConditionalRenderingFeaturesEXT.html>"]
32184 pub struct PhysicalDeviceConditionalRenderingFeaturesEXT {
32185     pub s_type: StructureType,
32186     pub p_next: *mut c_void,
32187     pub conditional_rendering: Bool32,
32188     pub inherited_conditional_rendering: Bool32,
32189 }
32190 impl ::std::default::Default for PhysicalDeviceConditionalRenderingFeaturesEXT {
32191     #[inline]
default() -> Self32192     fn default() -> Self {
32193         Self {
32194             s_type: Self::STRUCTURE_TYPE,
32195             p_next: ::std::ptr::null_mut(),
32196             conditional_rendering: Bool32::default(),
32197             inherited_conditional_rendering: Bool32::default(),
32198         }
32199     }
32200 }
32201 unsafe impl TaggedStructure for PhysicalDeviceConditionalRenderingFeaturesEXT {
32202     const STRUCTURE_TYPE: StructureType =
32203         StructureType::PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
32204 }
32205 impl PhysicalDeviceConditionalRenderingFeaturesEXT {
builder<'a>() -> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a>32206     pub fn builder<'a>() -> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
32207         PhysicalDeviceConditionalRenderingFeaturesEXTBuilder {
32208             inner: Self::default(),
32209             marker: ::std::marker::PhantomData,
32210         }
32211     }
32212 }
32213 #[repr(transparent)]
32214 pub struct PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
32215     inner: PhysicalDeviceConditionalRenderingFeaturesEXT,
32216     marker: ::std::marker::PhantomData<&'a ()>,
32217 }
32218 unsafe impl ExtendsPhysicalDeviceFeatures2
32219     for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'_>
32220 {
32221 }
32222 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceConditionalRenderingFeaturesEXT {}
32223 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'_> {}
32224 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceConditionalRenderingFeaturesEXT {}
32225 impl<'a> ::std::ops::Deref for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
32226     type Target = PhysicalDeviceConditionalRenderingFeaturesEXT;
deref(&self) -> &Self::Target32227     fn deref(&self) -> &Self::Target {
32228         &self.inner
32229     }
32230 }
32231 impl<'a> ::std::ops::DerefMut for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target32232     fn deref_mut(&mut self) -> &mut Self::Target {
32233         &mut self.inner
32234     }
32235 }
32236 impl<'a> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
32237     #[inline]
conditional_rendering(mut self, conditional_rendering: bool) -> Self32238     pub fn conditional_rendering(mut self, conditional_rendering: bool) -> Self {
32239         self.inner.conditional_rendering = conditional_rendering.into();
32240         self
32241     }
32242     #[inline]
inherited_conditional_rendering( mut self, inherited_conditional_rendering: bool, ) -> Self32243     pub fn inherited_conditional_rendering(
32244         mut self,
32245         inherited_conditional_rendering: bool,
32246     ) -> Self {
32247         self.inner.inherited_conditional_rendering = inherited_conditional_rendering.into();
32248         self
32249     }
32250     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32251     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32252     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceConditionalRenderingFeaturesEXT32253     pub fn build(self) -> PhysicalDeviceConditionalRenderingFeaturesEXT {
32254         self.inner
32255     }
32256 }
32257 #[repr(C)]
32258 #[cfg_attr(feature = "debug", derive(Debug))]
32259 #[derive(Copy, Clone)]
32260 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkanMemoryModelFeatures.html>"]
32261 pub struct PhysicalDeviceVulkanMemoryModelFeatures {
32262     pub s_type: StructureType,
32263     pub p_next: *mut c_void,
32264     pub vulkan_memory_model: Bool32,
32265     pub vulkan_memory_model_device_scope: Bool32,
32266     pub vulkan_memory_model_availability_visibility_chains: Bool32,
32267 }
32268 impl ::std::default::Default for PhysicalDeviceVulkanMemoryModelFeatures {
32269     #[inline]
default() -> Self32270     fn default() -> Self {
32271         Self {
32272             s_type: Self::STRUCTURE_TYPE,
32273             p_next: ::std::ptr::null_mut(),
32274             vulkan_memory_model: Bool32::default(),
32275             vulkan_memory_model_device_scope: Bool32::default(),
32276             vulkan_memory_model_availability_visibility_chains: Bool32::default(),
32277         }
32278     }
32279 }
32280 unsafe impl TaggedStructure for PhysicalDeviceVulkanMemoryModelFeatures {
32281     const STRUCTURE_TYPE: StructureType =
32282         StructureType::PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
32283 }
32284 impl PhysicalDeviceVulkanMemoryModelFeatures {
builder<'a>() -> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a>32285     pub fn builder<'a>() -> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
32286         PhysicalDeviceVulkanMemoryModelFeaturesBuilder {
32287             inner: Self::default(),
32288             marker: ::std::marker::PhantomData,
32289         }
32290     }
32291 }
32292 #[repr(transparent)]
32293 pub struct PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
32294     inner: PhysicalDeviceVulkanMemoryModelFeatures,
32295     marker: ::std::marker::PhantomData<&'a ()>,
32296 }
32297 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'_> {}
32298 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkanMemoryModelFeatures {}
32299 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'_> {}
32300 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkanMemoryModelFeatures {}
32301 impl<'a> ::std::ops::Deref for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
32302     type Target = PhysicalDeviceVulkanMemoryModelFeatures;
deref(&self) -> &Self::Target32303     fn deref(&self) -> &Self::Target {
32304         &self.inner
32305     }
32306 }
32307 impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target32308     fn deref_mut(&mut self) -> &mut Self::Target {
32309         &mut self.inner
32310     }
32311 }
32312 impl<'a> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
32313     #[inline]
vulkan_memory_model(mut self, vulkan_memory_model: bool) -> Self32314     pub fn vulkan_memory_model(mut self, vulkan_memory_model: bool) -> Self {
32315         self.inner.vulkan_memory_model = vulkan_memory_model.into();
32316         self
32317     }
32318     #[inline]
vulkan_memory_model_device_scope( mut self, vulkan_memory_model_device_scope: bool, ) -> Self32319     pub fn vulkan_memory_model_device_scope(
32320         mut self,
32321         vulkan_memory_model_device_scope: bool,
32322     ) -> Self {
32323         self.inner.vulkan_memory_model_device_scope = vulkan_memory_model_device_scope.into();
32324         self
32325     }
32326     #[inline]
vulkan_memory_model_availability_visibility_chains( mut self, vulkan_memory_model_availability_visibility_chains: bool, ) -> Self32327     pub fn vulkan_memory_model_availability_visibility_chains(
32328         mut self,
32329         vulkan_memory_model_availability_visibility_chains: bool,
32330     ) -> Self {
32331         self.inner
32332             .vulkan_memory_model_availability_visibility_chains =
32333             vulkan_memory_model_availability_visibility_chains.into();
32334         self
32335     }
32336     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32337     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32338     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceVulkanMemoryModelFeatures32339     pub fn build(self) -> PhysicalDeviceVulkanMemoryModelFeatures {
32340         self.inner
32341     }
32342 }
32343 #[repr(C)]
32344 #[cfg_attr(feature = "debug", derive(Debug))]
32345 #[derive(Copy, Clone)]
32346 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderAtomicInt64Features.html>"]
32347 pub struct PhysicalDeviceShaderAtomicInt64Features {
32348     pub s_type: StructureType,
32349     pub p_next: *mut c_void,
32350     pub shader_buffer_int64_atomics: Bool32,
32351     pub shader_shared_int64_atomics: Bool32,
32352 }
32353 impl ::std::default::Default for PhysicalDeviceShaderAtomicInt64Features {
32354     #[inline]
default() -> Self32355     fn default() -> Self {
32356         Self {
32357             s_type: Self::STRUCTURE_TYPE,
32358             p_next: ::std::ptr::null_mut(),
32359             shader_buffer_int64_atomics: Bool32::default(),
32360             shader_shared_int64_atomics: Bool32::default(),
32361         }
32362     }
32363 }
32364 unsafe impl TaggedStructure for PhysicalDeviceShaderAtomicInt64Features {
32365     const STRUCTURE_TYPE: StructureType =
32366         StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
32367 }
32368 impl PhysicalDeviceShaderAtomicInt64Features {
builder<'a>() -> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a>32369     pub fn builder<'a>() -> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
32370         PhysicalDeviceShaderAtomicInt64FeaturesBuilder {
32371             inner: Self::default(),
32372             marker: ::std::marker::PhantomData,
32373         }
32374     }
32375 }
32376 #[repr(transparent)]
32377 pub struct PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
32378     inner: PhysicalDeviceShaderAtomicInt64Features,
32379     marker: ::std::marker::PhantomData<&'a ()>,
32380 }
32381 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'_> {}
32382 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicInt64Features {}
32383 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'_> {}
32384 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicInt64Features {}
32385 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
32386     type Target = PhysicalDeviceShaderAtomicInt64Features;
deref(&self) -> &Self::Target32387     fn deref(&self) -> &Self::Target {
32388         &self.inner
32389     }
32390 }
32391 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target32392     fn deref_mut(&mut self) -> &mut Self::Target {
32393         &mut self.inner
32394     }
32395 }
32396 impl<'a> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
32397     #[inline]
shader_buffer_int64_atomics(mut self, shader_buffer_int64_atomics: bool) -> Self32398     pub fn shader_buffer_int64_atomics(mut self, shader_buffer_int64_atomics: bool) -> Self {
32399         self.inner.shader_buffer_int64_atomics = shader_buffer_int64_atomics.into();
32400         self
32401     }
32402     #[inline]
shader_shared_int64_atomics(mut self, shader_shared_int64_atomics: bool) -> Self32403     pub fn shader_shared_int64_atomics(mut self, shader_shared_int64_atomics: bool) -> Self {
32404         self.inner.shader_shared_int64_atomics = shader_shared_int64_atomics.into();
32405         self
32406     }
32407     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32408     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32409     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderAtomicInt64Features32410     pub fn build(self) -> PhysicalDeviceShaderAtomicInt64Features {
32411         self.inner
32412     }
32413 }
32414 #[repr(C)]
32415 #[cfg_attr(feature = "debug", derive(Debug))]
32416 #[derive(Copy, Clone)]
32417 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.html>"]
32418 pub struct PhysicalDeviceShaderAtomicFloatFeaturesEXT {
32419     pub s_type: StructureType,
32420     pub p_next: *mut c_void,
32421     pub shader_buffer_float32_atomics: Bool32,
32422     pub shader_buffer_float32_atomic_add: Bool32,
32423     pub shader_buffer_float64_atomics: Bool32,
32424     pub shader_buffer_float64_atomic_add: Bool32,
32425     pub shader_shared_float32_atomics: Bool32,
32426     pub shader_shared_float32_atomic_add: Bool32,
32427     pub shader_shared_float64_atomics: Bool32,
32428     pub shader_shared_float64_atomic_add: Bool32,
32429     pub shader_image_float32_atomics: Bool32,
32430     pub shader_image_float32_atomic_add: Bool32,
32431     pub sparse_image_float32_atomics: Bool32,
32432     pub sparse_image_float32_atomic_add: Bool32,
32433 }
32434 impl ::std::default::Default for PhysicalDeviceShaderAtomicFloatFeaturesEXT {
32435     #[inline]
default() -> Self32436     fn default() -> Self {
32437         Self {
32438             s_type: Self::STRUCTURE_TYPE,
32439             p_next: ::std::ptr::null_mut(),
32440             shader_buffer_float32_atomics: Bool32::default(),
32441             shader_buffer_float32_atomic_add: Bool32::default(),
32442             shader_buffer_float64_atomics: Bool32::default(),
32443             shader_buffer_float64_atomic_add: Bool32::default(),
32444             shader_shared_float32_atomics: Bool32::default(),
32445             shader_shared_float32_atomic_add: Bool32::default(),
32446             shader_shared_float64_atomics: Bool32::default(),
32447             shader_shared_float64_atomic_add: Bool32::default(),
32448             shader_image_float32_atomics: Bool32::default(),
32449             shader_image_float32_atomic_add: Bool32::default(),
32450             sparse_image_float32_atomics: Bool32::default(),
32451             sparse_image_float32_atomic_add: Bool32::default(),
32452         }
32453     }
32454 }
32455 unsafe impl TaggedStructure for PhysicalDeviceShaderAtomicFloatFeaturesEXT {
32456     const STRUCTURE_TYPE: StructureType =
32457         StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
32458 }
32459 impl PhysicalDeviceShaderAtomicFloatFeaturesEXT {
builder<'a>() -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a>32460     pub fn builder<'a>() -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
32461         PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder {
32462             inner: Self::default(),
32463             marker: ::std::marker::PhantomData,
32464         }
32465     }
32466 }
32467 #[repr(transparent)]
32468 pub struct PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
32469     inner: PhysicalDeviceShaderAtomicFloatFeaturesEXT,
32470     marker: ::std::marker::PhantomData<&'a ()>,
32471 }
32472 unsafe impl ExtendsPhysicalDeviceFeatures2
32473     for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'_>
32474 {
32475 }
32476 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicFloatFeaturesEXT {}
32477 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'_> {}
32478 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloatFeaturesEXT {}
32479 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
32480     type Target = PhysicalDeviceShaderAtomicFloatFeaturesEXT;
deref(&self) -> &Self::Target32481     fn deref(&self) -> &Self::Target {
32482         &self.inner
32483     }
32484 }
32485 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target32486     fn deref_mut(&mut self) -> &mut Self::Target {
32487         &mut self.inner
32488     }
32489 }
32490 impl<'a> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
32491     #[inline]
shader_buffer_float32_atomics(mut self, shader_buffer_float32_atomics: bool) -> Self32492     pub fn shader_buffer_float32_atomics(mut self, shader_buffer_float32_atomics: bool) -> Self {
32493         self.inner.shader_buffer_float32_atomics = shader_buffer_float32_atomics.into();
32494         self
32495     }
32496     #[inline]
shader_buffer_float32_atomic_add( mut self, shader_buffer_float32_atomic_add: bool, ) -> Self32497     pub fn shader_buffer_float32_atomic_add(
32498         mut self,
32499         shader_buffer_float32_atomic_add: bool,
32500     ) -> Self {
32501         self.inner.shader_buffer_float32_atomic_add = shader_buffer_float32_atomic_add.into();
32502         self
32503     }
32504     #[inline]
shader_buffer_float64_atomics(mut self, shader_buffer_float64_atomics: bool) -> Self32505     pub fn shader_buffer_float64_atomics(mut self, shader_buffer_float64_atomics: bool) -> Self {
32506         self.inner.shader_buffer_float64_atomics = shader_buffer_float64_atomics.into();
32507         self
32508     }
32509     #[inline]
shader_buffer_float64_atomic_add( mut self, shader_buffer_float64_atomic_add: bool, ) -> Self32510     pub fn shader_buffer_float64_atomic_add(
32511         mut self,
32512         shader_buffer_float64_atomic_add: bool,
32513     ) -> Self {
32514         self.inner.shader_buffer_float64_atomic_add = shader_buffer_float64_atomic_add.into();
32515         self
32516     }
32517     #[inline]
shader_shared_float32_atomics(mut self, shader_shared_float32_atomics: bool) -> Self32518     pub fn shader_shared_float32_atomics(mut self, shader_shared_float32_atomics: bool) -> Self {
32519         self.inner.shader_shared_float32_atomics = shader_shared_float32_atomics.into();
32520         self
32521     }
32522     #[inline]
shader_shared_float32_atomic_add( mut self, shader_shared_float32_atomic_add: bool, ) -> Self32523     pub fn shader_shared_float32_atomic_add(
32524         mut self,
32525         shader_shared_float32_atomic_add: bool,
32526     ) -> Self {
32527         self.inner.shader_shared_float32_atomic_add = shader_shared_float32_atomic_add.into();
32528         self
32529     }
32530     #[inline]
shader_shared_float64_atomics(mut self, shader_shared_float64_atomics: bool) -> Self32531     pub fn shader_shared_float64_atomics(mut self, shader_shared_float64_atomics: bool) -> Self {
32532         self.inner.shader_shared_float64_atomics = shader_shared_float64_atomics.into();
32533         self
32534     }
32535     #[inline]
shader_shared_float64_atomic_add( mut self, shader_shared_float64_atomic_add: bool, ) -> Self32536     pub fn shader_shared_float64_atomic_add(
32537         mut self,
32538         shader_shared_float64_atomic_add: bool,
32539     ) -> Self {
32540         self.inner.shader_shared_float64_atomic_add = shader_shared_float64_atomic_add.into();
32541         self
32542     }
32543     #[inline]
shader_image_float32_atomics(mut self, shader_image_float32_atomics: bool) -> Self32544     pub fn shader_image_float32_atomics(mut self, shader_image_float32_atomics: bool) -> Self {
32545         self.inner.shader_image_float32_atomics = shader_image_float32_atomics.into();
32546         self
32547     }
32548     #[inline]
shader_image_float32_atomic_add( mut self, shader_image_float32_atomic_add: bool, ) -> Self32549     pub fn shader_image_float32_atomic_add(
32550         mut self,
32551         shader_image_float32_atomic_add: bool,
32552     ) -> Self {
32553         self.inner.shader_image_float32_atomic_add = shader_image_float32_atomic_add.into();
32554         self
32555     }
32556     #[inline]
sparse_image_float32_atomics(mut self, sparse_image_float32_atomics: bool) -> Self32557     pub fn sparse_image_float32_atomics(mut self, sparse_image_float32_atomics: bool) -> Self {
32558         self.inner.sparse_image_float32_atomics = sparse_image_float32_atomics.into();
32559         self
32560     }
32561     #[inline]
sparse_image_float32_atomic_add( mut self, sparse_image_float32_atomic_add: bool, ) -> Self32562     pub fn sparse_image_float32_atomic_add(
32563         mut self,
32564         sparse_image_float32_atomic_add: bool,
32565     ) -> Self {
32566         self.inner.sparse_image_float32_atomic_add = sparse_image_float32_atomic_add.into();
32567         self
32568     }
32569     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32570     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32571     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderAtomicFloatFeaturesEXT32572     pub fn build(self) -> PhysicalDeviceShaderAtomicFloatFeaturesEXT {
32573         self.inner
32574     }
32575 }
32576 #[repr(C)]
32577 #[cfg_attr(feature = "debug", derive(Debug))]
32578 #[derive(Copy, Clone)]
32579 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.html>"]
32580 pub struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
32581     pub s_type: StructureType,
32582     pub p_next: *mut c_void,
32583     pub shader_buffer_float16_atomics: Bool32,
32584     pub shader_buffer_float16_atomic_add: Bool32,
32585     pub shader_buffer_float16_atomic_min_max: Bool32,
32586     pub shader_buffer_float32_atomic_min_max: Bool32,
32587     pub shader_buffer_float64_atomic_min_max: Bool32,
32588     pub shader_shared_float16_atomics: Bool32,
32589     pub shader_shared_float16_atomic_add: Bool32,
32590     pub shader_shared_float16_atomic_min_max: Bool32,
32591     pub shader_shared_float32_atomic_min_max: Bool32,
32592     pub shader_shared_float64_atomic_min_max: Bool32,
32593     pub shader_image_float32_atomic_min_max: Bool32,
32594     pub sparse_image_float32_atomic_min_max: Bool32,
32595 }
32596 impl ::std::default::Default for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
32597     #[inline]
default() -> Self32598     fn default() -> Self {
32599         Self {
32600             s_type: Self::STRUCTURE_TYPE,
32601             p_next: ::std::ptr::null_mut(),
32602             shader_buffer_float16_atomics: Bool32::default(),
32603             shader_buffer_float16_atomic_add: Bool32::default(),
32604             shader_buffer_float16_atomic_min_max: Bool32::default(),
32605             shader_buffer_float32_atomic_min_max: Bool32::default(),
32606             shader_buffer_float64_atomic_min_max: Bool32::default(),
32607             shader_shared_float16_atomics: Bool32::default(),
32608             shader_shared_float16_atomic_add: Bool32::default(),
32609             shader_shared_float16_atomic_min_max: Bool32::default(),
32610             shader_shared_float32_atomic_min_max: Bool32::default(),
32611             shader_shared_float64_atomic_min_max: Bool32::default(),
32612             shader_image_float32_atomic_min_max: Bool32::default(),
32613             sparse_image_float32_atomic_min_max: Bool32::default(),
32614         }
32615     }
32616 }
32617 unsafe impl TaggedStructure for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
32618     const STRUCTURE_TYPE: StructureType =
32619         StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
32620 }
32621 impl PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
builder<'a>() -> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a>32622     pub fn builder<'a>() -> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
32623         PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder {
32624             inner: Self::default(),
32625             marker: ::std::marker::PhantomData,
32626         }
32627     }
32628 }
32629 #[repr(transparent)]
32630 pub struct PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
32631     inner: PhysicalDeviceShaderAtomicFloat2FeaturesEXT,
32632     marker: ::std::marker::PhantomData<&'a ()>,
32633 }
32634 unsafe impl ExtendsPhysicalDeviceFeatures2
32635     for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'_>
32636 {
32637 }
32638 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {}
32639 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'_> {}
32640 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {}
32641 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
32642     type Target = PhysicalDeviceShaderAtomicFloat2FeaturesEXT;
deref(&self) -> &Self::Target32643     fn deref(&self) -> &Self::Target {
32644         &self.inner
32645     }
32646 }
32647 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target32648     fn deref_mut(&mut self) -> &mut Self::Target {
32649         &mut self.inner
32650     }
32651 }
32652 impl<'a> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
32653     #[inline]
shader_buffer_float16_atomics(mut self, shader_buffer_float16_atomics: bool) -> Self32654     pub fn shader_buffer_float16_atomics(mut self, shader_buffer_float16_atomics: bool) -> Self {
32655         self.inner.shader_buffer_float16_atomics = shader_buffer_float16_atomics.into();
32656         self
32657     }
32658     #[inline]
shader_buffer_float16_atomic_add( mut self, shader_buffer_float16_atomic_add: bool, ) -> Self32659     pub fn shader_buffer_float16_atomic_add(
32660         mut self,
32661         shader_buffer_float16_atomic_add: bool,
32662     ) -> Self {
32663         self.inner.shader_buffer_float16_atomic_add = shader_buffer_float16_atomic_add.into();
32664         self
32665     }
32666     #[inline]
shader_buffer_float16_atomic_min_max( mut self, shader_buffer_float16_atomic_min_max: bool, ) -> Self32667     pub fn shader_buffer_float16_atomic_min_max(
32668         mut self,
32669         shader_buffer_float16_atomic_min_max: bool,
32670     ) -> Self {
32671         self.inner.shader_buffer_float16_atomic_min_max =
32672             shader_buffer_float16_atomic_min_max.into();
32673         self
32674     }
32675     #[inline]
shader_buffer_float32_atomic_min_max( mut self, shader_buffer_float32_atomic_min_max: bool, ) -> Self32676     pub fn shader_buffer_float32_atomic_min_max(
32677         mut self,
32678         shader_buffer_float32_atomic_min_max: bool,
32679     ) -> Self {
32680         self.inner.shader_buffer_float32_atomic_min_max =
32681             shader_buffer_float32_atomic_min_max.into();
32682         self
32683     }
32684     #[inline]
shader_buffer_float64_atomic_min_max( mut self, shader_buffer_float64_atomic_min_max: bool, ) -> Self32685     pub fn shader_buffer_float64_atomic_min_max(
32686         mut self,
32687         shader_buffer_float64_atomic_min_max: bool,
32688     ) -> Self {
32689         self.inner.shader_buffer_float64_atomic_min_max =
32690             shader_buffer_float64_atomic_min_max.into();
32691         self
32692     }
32693     #[inline]
shader_shared_float16_atomics(mut self, shader_shared_float16_atomics: bool) -> Self32694     pub fn shader_shared_float16_atomics(mut self, shader_shared_float16_atomics: bool) -> Self {
32695         self.inner.shader_shared_float16_atomics = shader_shared_float16_atomics.into();
32696         self
32697     }
32698     #[inline]
shader_shared_float16_atomic_add( mut self, shader_shared_float16_atomic_add: bool, ) -> Self32699     pub fn shader_shared_float16_atomic_add(
32700         mut self,
32701         shader_shared_float16_atomic_add: bool,
32702     ) -> Self {
32703         self.inner.shader_shared_float16_atomic_add = shader_shared_float16_atomic_add.into();
32704         self
32705     }
32706     #[inline]
shader_shared_float16_atomic_min_max( mut self, shader_shared_float16_atomic_min_max: bool, ) -> Self32707     pub fn shader_shared_float16_atomic_min_max(
32708         mut self,
32709         shader_shared_float16_atomic_min_max: bool,
32710     ) -> Self {
32711         self.inner.shader_shared_float16_atomic_min_max =
32712             shader_shared_float16_atomic_min_max.into();
32713         self
32714     }
32715     #[inline]
shader_shared_float32_atomic_min_max( mut self, shader_shared_float32_atomic_min_max: bool, ) -> Self32716     pub fn shader_shared_float32_atomic_min_max(
32717         mut self,
32718         shader_shared_float32_atomic_min_max: bool,
32719     ) -> Self {
32720         self.inner.shader_shared_float32_atomic_min_max =
32721             shader_shared_float32_atomic_min_max.into();
32722         self
32723     }
32724     #[inline]
shader_shared_float64_atomic_min_max( mut self, shader_shared_float64_atomic_min_max: bool, ) -> Self32725     pub fn shader_shared_float64_atomic_min_max(
32726         mut self,
32727         shader_shared_float64_atomic_min_max: bool,
32728     ) -> Self {
32729         self.inner.shader_shared_float64_atomic_min_max =
32730             shader_shared_float64_atomic_min_max.into();
32731         self
32732     }
32733     #[inline]
shader_image_float32_atomic_min_max( mut self, shader_image_float32_atomic_min_max: bool, ) -> Self32734     pub fn shader_image_float32_atomic_min_max(
32735         mut self,
32736         shader_image_float32_atomic_min_max: bool,
32737     ) -> Self {
32738         self.inner.shader_image_float32_atomic_min_max = shader_image_float32_atomic_min_max.into();
32739         self
32740     }
32741     #[inline]
sparse_image_float32_atomic_min_max( mut self, sparse_image_float32_atomic_min_max: bool, ) -> Self32742     pub fn sparse_image_float32_atomic_min_max(
32743         mut self,
32744         sparse_image_float32_atomic_min_max: bool,
32745     ) -> Self {
32746         self.inner.sparse_image_float32_atomic_min_max = sparse_image_float32_atomic_min_max.into();
32747         self
32748     }
32749     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32750     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32751     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderAtomicFloat2FeaturesEXT32752     pub fn build(self) -> PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
32753         self.inner
32754     }
32755 }
32756 #[repr(C)]
32757 #[cfg_attr(feature = "debug", derive(Debug))]
32758 #[derive(Copy, Clone)]
32759 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT.html>"]
32760 pub struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
32761     pub s_type: StructureType,
32762     pub p_next: *mut c_void,
32763     pub vertex_attribute_instance_rate_divisor: Bool32,
32764     pub vertex_attribute_instance_rate_zero_divisor: Bool32,
32765 }
32766 impl ::std::default::Default for PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
32767     #[inline]
default() -> Self32768     fn default() -> Self {
32769         Self {
32770             s_type: Self::STRUCTURE_TYPE,
32771             p_next: ::std::ptr::null_mut(),
32772             vertex_attribute_instance_rate_divisor: Bool32::default(),
32773             vertex_attribute_instance_rate_zero_divisor: Bool32::default(),
32774         }
32775     }
32776 }
32777 unsafe impl TaggedStructure for PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
32778     const STRUCTURE_TYPE: StructureType =
32779         StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT;
32780 }
32781 impl PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
builder<'a>() -> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a>32782     pub fn builder<'a>() -> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
32783         PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder {
32784             inner: Self::default(),
32785             marker: ::std::marker::PhantomData,
32786         }
32787     }
32788 }
32789 #[repr(transparent)]
32790 pub struct PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
32791     inner: PhysicalDeviceVertexAttributeDivisorFeaturesEXT,
32792     marker: ::std::marker::PhantomData<&'a ()>,
32793 }
32794 unsafe impl ExtendsPhysicalDeviceFeatures2
32795     for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'_>
32796 {
32797 }
32798 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVertexAttributeDivisorFeaturesEXT {}
32799 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'_> {}
32800 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexAttributeDivisorFeaturesEXT {}
32801 impl<'a> ::std::ops::Deref for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
32802     type Target = PhysicalDeviceVertexAttributeDivisorFeaturesEXT;
deref(&self) -> &Self::Target32803     fn deref(&self) -> &Self::Target {
32804         &self.inner
32805     }
32806 }
32807 impl<'a> ::std::ops::DerefMut for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target32808     fn deref_mut(&mut self) -> &mut Self::Target {
32809         &mut self.inner
32810     }
32811 }
32812 impl<'a> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
32813     #[inline]
vertex_attribute_instance_rate_divisor( mut self, vertex_attribute_instance_rate_divisor: bool, ) -> Self32814     pub fn vertex_attribute_instance_rate_divisor(
32815         mut self,
32816         vertex_attribute_instance_rate_divisor: bool,
32817     ) -> Self {
32818         self.inner.vertex_attribute_instance_rate_divisor =
32819             vertex_attribute_instance_rate_divisor.into();
32820         self
32821     }
32822     #[inline]
vertex_attribute_instance_rate_zero_divisor( mut self, vertex_attribute_instance_rate_zero_divisor: bool, ) -> Self32823     pub fn vertex_attribute_instance_rate_zero_divisor(
32824         mut self,
32825         vertex_attribute_instance_rate_zero_divisor: bool,
32826     ) -> Self {
32827         self.inner.vertex_attribute_instance_rate_zero_divisor =
32828             vertex_attribute_instance_rate_zero_divisor.into();
32829         self
32830     }
32831     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32832     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32833     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceVertexAttributeDivisorFeaturesEXT32834     pub fn build(self) -> PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
32835         self.inner
32836     }
32837 }
32838 #[repr(C)]
32839 #[cfg_attr(feature = "debug", derive(Debug))]
32840 #[derive(Copy, Clone)]
32841 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyCheckpointPropertiesNV.html>"]
32842 pub struct QueueFamilyCheckpointPropertiesNV {
32843     pub s_type: StructureType,
32844     pub p_next: *mut c_void,
32845     pub checkpoint_execution_stage_mask: PipelineStageFlags,
32846 }
32847 impl ::std::default::Default for QueueFamilyCheckpointPropertiesNV {
32848     #[inline]
default() -> Self32849     fn default() -> Self {
32850         Self {
32851             s_type: Self::STRUCTURE_TYPE,
32852             p_next: ::std::ptr::null_mut(),
32853             checkpoint_execution_stage_mask: PipelineStageFlags::default(),
32854         }
32855     }
32856 }
32857 unsafe impl TaggedStructure for QueueFamilyCheckpointPropertiesNV {
32858     const STRUCTURE_TYPE: StructureType = StructureType::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV;
32859 }
32860 impl QueueFamilyCheckpointPropertiesNV {
builder<'a>() -> QueueFamilyCheckpointPropertiesNVBuilder<'a>32861     pub fn builder<'a>() -> QueueFamilyCheckpointPropertiesNVBuilder<'a> {
32862         QueueFamilyCheckpointPropertiesNVBuilder {
32863             inner: Self::default(),
32864             marker: ::std::marker::PhantomData,
32865         }
32866     }
32867 }
32868 #[repr(transparent)]
32869 pub struct QueueFamilyCheckpointPropertiesNVBuilder<'a> {
32870     inner: QueueFamilyCheckpointPropertiesNV,
32871     marker: ::std::marker::PhantomData<&'a ()>,
32872 }
32873 unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointPropertiesNVBuilder<'_> {}
32874 unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointPropertiesNV {}
32875 impl<'a> ::std::ops::Deref for QueueFamilyCheckpointPropertiesNVBuilder<'a> {
32876     type Target = QueueFamilyCheckpointPropertiesNV;
deref(&self) -> &Self::Target32877     fn deref(&self) -> &Self::Target {
32878         &self.inner
32879     }
32880 }
32881 impl<'a> ::std::ops::DerefMut for QueueFamilyCheckpointPropertiesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target32882     fn deref_mut(&mut self) -> &mut Self::Target {
32883         &mut self.inner
32884     }
32885 }
32886 impl<'a> QueueFamilyCheckpointPropertiesNVBuilder<'a> {
32887     #[inline]
checkpoint_execution_stage_mask( mut self, checkpoint_execution_stage_mask: PipelineStageFlags, ) -> Self32888     pub fn checkpoint_execution_stage_mask(
32889         mut self,
32890         checkpoint_execution_stage_mask: PipelineStageFlags,
32891     ) -> Self {
32892         self.inner.checkpoint_execution_stage_mask = checkpoint_execution_stage_mask;
32893         self
32894     }
32895     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32896     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32897     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> QueueFamilyCheckpointPropertiesNV32898     pub fn build(self) -> QueueFamilyCheckpointPropertiesNV {
32899         self.inner
32900     }
32901 }
32902 #[repr(C)]
32903 #[cfg_attr(feature = "debug", derive(Debug))]
32904 #[derive(Copy, Clone)]
32905 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCheckpointDataNV.html>"]
32906 pub struct CheckpointDataNV {
32907     pub s_type: StructureType,
32908     pub p_next: *mut c_void,
32909     pub stage: PipelineStageFlags,
32910     pub p_checkpoint_marker: *mut c_void,
32911 }
32912 impl ::std::default::Default for CheckpointDataNV {
32913     #[inline]
default() -> Self32914     fn default() -> Self {
32915         Self {
32916             s_type: Self::STRUCTURE_TYPE,
32917             p_next: ::std::ptr::null_mut(),
32918             stage: PipelineStageFlags::default(),
32919             p_checkpoint_marker: ::std::ptr::null_mut(),
32920         }
32921     }
32922 }
32923 unsafe impl TaggedStructure for CheckpointDataNV {
32924     const STRUCTURE_TYPE: StructureType = StructureType::CHECKPOINT_DATA_NV;
32925 }
32926 impl CheckpointDataNV {
builder<'a>() -> CheckpointDataNVBuilder<'a>32927     pub fn builder<'a>() -> CheckpointDataNVBuilder<'a> {
32928         CheckpointDataNVBuilder {
32929             inner: Self::default(),
32930             marker: ::std::marker::PhantomData,
32931         }
32932     }
32933 }
32934 #[repr(transparent)]
32935 pub struct CheckpointDataNVBuilder<'a> {
32936     inner: CheckpointDataNV,
32937     marker: ::std::marker::PhantomData<&'a ()>,
32938 }
32939 impl<'a> ::std::ops::Deref for CheckpointDataNVBuilder<'a> {
32940     type Target = CheckpointDataNV;
deref(&self) -> &Self::Target32941     fn deref(&self) -> &Self::Target {
32942         &self.inner
32943     }
32944 }
32945 impl<'a> ::std::ops::DerefMut for CheckpointDataNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target32946     fn deref_mut(&mut self) -> &mut Self::Target {
32947         &mut self.inner
32948     }
32949 }
32950 impl<'a> CheckpointDataNVBuilder<'a> {
32951     #[inline]
stage(mut self, stage: PipelineStageFlags) -> Self32952     pub fn stage(mut self, stage: PipelineStageFlags) -> Self {
32953         self.inner.stage = stage;
32954         self
32955     }
32956     #[inline]
checkpoint_marker(mut self, checkpoint_marker: *mut c_void) -> Self32957     pub fn checkpoint_marker(mut self, checkpoint_marker: *mut c_void) -> Self {
32958         self.inner.p_checkpoint_marker = checkpoint_marker;
32959         self
32960     }
32961     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32962     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32963     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CheckpointDataNV32964     pub fn build(self) -> CheckpointDataNV {
32965         self.inner
32966     }
32967 }
32968 #[repr(C)]
32969 #[cfg_attr(feature = "debug", derive(Debug))]
32970 #[derive(Copy, Clone)]
32971 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDepthStencilResolveProperties.html>"]
32972 pub struct PhysicalDeviceDepthStencilResolveProperties {
32973     pub s_type: StructureType,
32974     pub p_next: *mut c_void,
32975     pub supported_depth_resolve_modes: ResolveModeFlags,
32976     pub supported_stencil_resolve_modes: ResolveModeFlags,
32977     pub independent_resolve_none: Bool32,
32978     pub independent_resolve: Bool32,
32979 }
32980 impl ::std::default::Default for PhysicalDeviceDepthStencilResolveProperties {
32981     #[inline]
default() -> Self32982     fn default() -> Self {
32983         Self {
32984             s_type: Self::STRUCTURE_TYPE,
32985             p_next: ::std::ptr::null_mut(),
32986             supported_depth_resolve_modes: ResolveModeFlags::default(),
32987             supported_stencil_resolve_modes: ResolveModeFlags::default(),
32988             independent_resolve_none: Bool32::default(),
32989             independent_resolve: Bool32::default(),
32990         }
32991     }
32992 }
32993 unsafe impl TaggedStructure for PhysicalDeviceDepthStencilResolveProperties {
32994     const STRUCTURE_TYPE: StructureType =
32995         StructureType::PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
32996 }
32997 impl PhysicalDeviceDepthStencilResolveProperties {
builder<'a>() -> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a>32998     pub fn builder<'a>() -> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
32999         PhysicalDeviceDepthStencilResolvePropertiesBuilder {
33000             inner: Self::default(),
33001             marker: ::std::marker::PhantomData,
33002         }
33003     }
33004 }
33005 #[repr(transparent)]
33006 pub struct PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
33007     inner: PhysicalDeviceDepthStencilResolveProperties,
33008     marker: ::std::marker::PhantomData<&'a ()>,
33009 }
33010 unsafe impl ExtendsPhysicalDeviceProperties2
33011     for PhysicalDeviceDepthStencilResolvePropertiesBuilder<'_>
33012 {
33013 }
33014 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDepthStencilResolveProperties {}
33015 impl<'a> ::std::ops::Deref for PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
33016     type Target = PhysicalDeviceDepthStencilResolveProperties;
deref(&self) -> &Self::Target33017     fn deref(&self) -> &Self::Target {
33018         &self.inner
33019     }
33020 }
33021 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target33022     fn deref_mut(&mut self) -> &mut Self::Target {
33023         &mut self.inner
33024     }
33025 }
33026 impl<'a> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
33027     #[inline]
supported_depth_resolve_modes( mut self, supported_depth_resolve_modes: ResolveModeFlags, ) -> Self33028     pub fn supported_depth_resolve_modes(
33029         mut self,
33030         supported_depth_resolve_modes: ResolveModeFlags,
33031     ) -> Self {
33032         self.inner.supported_depth_resolve_modes = supported_depth_resolve_modes;
33033         self
33034     }
33035     #[inline]
supported_stencil_resolve_modes( mut self, supported_stencil_resolve_modes: ResolveModeFlags, ) -> Self33036     pub fn supported_stencil_resolve_modes(
33037         mut self,
33038         supported_stencil_resolve_modes: ResolveModeFlags,
33039     ) -> Self {
33040         self.inner.supported_stencil_resolve_modes = supported_stencil_resolve_modes;
33041         self
33042     }
33043     #[inline]
independent_resolve_none(mut self, independent_resolve_none: bool) -> Self33044     pub fn independent_resolve_none(mut self, independent_resolve_none: bool) -> Self {
33045         self.inner.independent_resolve_none = independent_resolve_none.into();
33046         self
33047     }
33048     #[inline]
independent_resolve(mut self, independent_resolve: bool) -> Self33049     pub fn independent_resolve(mut self, independent_resolve: bool) -> Self {
33050         self.inner.independent_resolve = independent_resolve.into();
33051         self
33052     }
33053     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33054     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33055     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDepthStencilResolveProperties33056     pub fn build(self) -> PhysicalDeviceDepthStencilResolveProperties {
33057         self.inner
33058     }
33059 }
33060 #[repr(C)]
33061 #[cfg_attr(feature = "debug", derive(Debug))]
33062 #[derive(Copy, Clone)]
33063 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDescriptionDepthStencilResolve.html>"]
33064 pub struct SubpassDescriptionDepthStencilResolve {
33065     pub s_type: StructureType,
33066     pub p_next: *const c_void,
33067     pub depth_resolve_mode: ResolveModeFlags,
33068     pub stencil_resolve_mode: ResolveModeFlags,
33069     pub p_depth_stencil_resolve_attachment: *const AttachmentReference2,
33070 }
33071 impl ::std::default::Default for SubpassDescriptionDepthStencilResolve {
33072     #[inline]
default() -> Self33073     fn default() -> Self {
33074         Self {
33075             s_type: Self::STRUCTURE_TYPE,
33076             p_next: ::std::ptr::null(),
33077             depth_resolve_mode: ResolveModeFlags::default(),
33078             stencil_resolve_mode: ResolveModeFlags::default(),
33079             p_depth_stencil_resolve_attachment: ::std::ptr::null(),
33080         }
33081     }
33082 }
33083 unsafe impl TaggedStructure for SubpassDescriptionDepthStencilResolve {
33084     const STRUCTURE_TYPE: StructureType = StructureType::SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE;
33085 }
33086 impl SubpassDescriptionDepthStencilResolve {
builder<'a>() -> SubpassDescriptionDepthStencilResolveBuilder<'a>33087     pub fn builder<'a>() -> SubpassDescriptionDepthStencilResolveBuilder<'a> {
33088         SubpassDescriptionDepthStencilResolveBuilder {
33089             inner: Self::default(),
33090             marker: ::std::marker::PhantomData,
33091         }
33092     }
33093 }
33094 #[repr(transparent)]
33095 pub struct SubpassDescriptionDepthStencilResolveBuilder<'a> {
33096     inner: SubpassDescriptionDepthStencilResolve,
33097     marker: ::std::marker::PhantomData<&'a ()>,
33098 }
33099 unsafe impl ExtendsSubpassDescription2 for SubpassDescriptionDepthStencilResolveBuilder<'_> {}
33100 unsafe impl ExtendsSubpassDescription2 for SubpassDescriptionDepthStencilResolve {}
33101 impl<'a> ::std::ops::Deref for SubpassDescriptionDepthStencilResolveBuilder<'a> {
33102     type Target = SubpassDescriptionDepthStencilResolve;
deref(&self) -> &Self::Target33103     fn deref(&self) -> &Self::Target {
33104         &self.inner
33105     }
33106 }
33107 impl<'a> ::std::ops::DerefMut for SubpassDescriptionDepthStencilResolveBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target33108     fn deref_mut(&mut self) -> &mut Self::Target {
33109         &mut self.inner
33110     }
33111 }
33112 impl<'a> SubpassDescriptionDepthStencilResolveBuilder<'a> {
33113     #[inline]
depth_resolve_mode(mut self, depth_resolve_mode: ResolveModeFlags) -> Self33114     pub fn depth_resolve_mode(mut self, depth_resolve_mode: ResolveModeFlags) -> Self {
33115         self.inner.depth_resolve_mode = depth_resolve_mode;
33116         self
33117     }
33118     #[inline]
stencil_resolve_mode(mut self, stencil_resolve_mode: ResolveModeFlags) -> Self33119     pub fn stencil_resolve_mode(mut self, stencil_resolve_mode: ResolveModeFlags) -> Self {
33120         self.inner.stencil_resolve_mode = stencil_resolve_mode;
33121         self
33122     }
33123     #[inline]
depth_stencil_resolve_attachment( mut self, depth_stencil_resolve_attachment: &'a AttachmentReference2, ) -> Self33124     pub fn depth_stencil_resolve_attachment(
33125         mut self,
33126         depth_stencil_resolve_attachment: &'a AttachmentReference2,
33127     ) -> Self {
33128         self.inner.p_depth_stencil_resolve_attachment = depth_stencil_resolve_attachment;
33129         self
33130     }
33131     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33132     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33133     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SubpassDescriptionDepthStencilResolve33134     pub fn build(self) -> SubpassDescriptionDepthStencilResolve {
33135         self.inner
33136     }
33137 }
33138 #[repr(C)]
33139 #[cfg_attr(feature = "debug", derive(Debug))]
33140 #[derive(Copy, Clone)]
33141 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewASTCDecodeModeEXT.html>"]
33142 pub struct ImageViewASTCDecodeModeEXT {
33143     pub s_type: StructureType,
33144     pub p_next: *const c_void,
33145     pub decode_mode: Format,
33146 }
33147 impl ::std::default::Default for ImageViewASTCDecodeModeEXT {
33148     #[inline]
default() -> Self33149     fn default() -> Self {
33150         Self {
33151             s_type: Self::STRUCTURE_TYPE,
33152             p_next: ::std::ptr::null(),
33153             decode_mode: Format::default(),
33154         }
33155     }
33156 }
33157 unsafe impl TaggedStructure for ImageViewASTCDecodeModeEXT {
33158     const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_ASTC_DECODE_MODE_EXT;
33159 }
33160 impl ImageViewASTCDecodeModeEXT {
builder<'a>() -> ImageViewASTCDecodeModeEXTBuilder<'a>33161     pub fn builder<'a>() -> ImageViewASTCDecodeModeEXTBuilder<'a> {
33162         ImageViewASTCDecodeModeEXTBuilder {
33163             inner: Self::default(),
33164             marker: ::std::marker::PhantomData,
33165         }
33166     }
33167 }
33168 #[repr(transparent)]
33169 pub struct ImageViewASTCDecodeModeEXTBuilder<'a> {
33170     inner: ImageViewASTCDecodeModeEXT,
33171     marker: ::std::marker::PhantomData<&'a ()>,
33172 }
33173 unsafe impl ExtendsImageViewCreateInfo for ImageViewASTCDecodeModeEXTBuilder<'_> {}
33174 unsafe impl ExtendsImageViewCreateInfo for ImageViewASTCDecodeModeEXT {}
33175 impl<'a> ::std::ops::Deref for ImageViewASTCDecodeModeEXTBuilder<'a> {
33176     type Target = ImageViewASTCDecodeModeEXT;
deref(&self) -> &Self::Target33177     fn deref(&self) -> &Self::Target {
33178         &self.inner
33179     }
33180 }
33181 impl<'a> ::std::ops::DerefMut for ImageViewASTCDecodeModeEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target33182     fn deref_mut(&mut self) -> &mut Self::Target {
33183         &mut self.inner
33184     }
33185 }
33186 impl<'a> ImageViewASTCDecodeModeEXTBuilder<'a> {
33187     #[inline]
decode_mode(mut self, decode_mode: Format) -> Self33188     pub fn decode_mode(mut self, decode_mode: Format) -> Self {
33189         self.inner.decode_mode = decode_mode;
33190         self
33191     }
33192     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33193     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33194     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageViewASTCDecodeModeEXT33195     pub fn build(self) -> ImageViewASTCDecodeModeEXT {
33196         self.inner
33197     }
33198 }
33199 #[repr(C)]
33200 #[cfg_attr(feature = "debug", derive(Debug))]
33201 #[derive(Copy, Clone)]
33202 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceASTCDecodeFeaturesEXT.html>"]
33203 pub struct PhysicalDeviceASTCDecodeFeaturesEXT {
33204     pub s_type: StructureType,
33205     pub p_next: *mut c_void,
33206     pub decode_mode_shared_exponent: Bool32,
33207 }
33208 impl ::std::default::Default for PhysicalDeviceASTCDecodeFeaturesEXT {
33209     #[inline]
default() -> Self33210     fn default() -> Self {
33211         Self {
33212             s_type: Self::STRUCTURE_TYPE,
33213             p_next: ::std::ptr::null_mut(),
33214             decode_mode_shared_exponent: Bool32::default(),
33215         }
33216     }
33217 }
33218 unsafe impl TaggedStructure for PhysicalDeviceASTCDecodeFeaturesEXT {
33219     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
33220 }
33221 impl PhysicalDeviceASTCDecodeFeaturesEXT {
builder<'a>() -> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a>33222     pub fn builder<'a>() -> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
33223         PhysicalDeviceASTCDecodeFeaturesEXTBuilder {
33224             inner: Self::default(),
33225             marker: ::std::marker::PhantomData,
33226         }
33227     }
33228 }
33229 #[repr(transparent)]
33230 pub struct PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
33231     inner: PhysicalDeviceASTCDecodeFeaturesEXT,
33232     marker: ::std::marker::PhantomData<&'a ()>,
33233 }
33234 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'_> {}
33235 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceASTCDecodeFeaturesEXT {}
33236 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'_> {}
33237 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceASTCDecodeFeaturesEXT {}
33238 impl<'a> ::std::ops::Deref for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
33239     type Target = PhysicalDeviceASTCDecodeFeaturesEXT;
deref(&self) -> &Self::Target33240     fn deref(&self) -> &Self::Target {
33241         &self.inner
33242     }
33243 }
33244 impl<'a> ::std::ops::DerefMut for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target33245     fn deref_mut(&mut self) -> &mut Self::Target {
33246         &mut self.inner
33247     }
33248 }
33249 impl<'a> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
33250     #[inline]
decode_mode_shared_exponent(mut self, decode_mode_shared_exponent: bool) -> Self33251     pub fn decode_mode_shared_exponent(mut self, decode_mode_shared_exponent: bool) -> Self {
33252         self.inner.decode_mode_shared_exponent = decode_mode_shared_exponent.into();
33253         self
33254     }
33255     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33256     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33257     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceASTCDecodeFeaturesEXT33258     pub fn build(self) -> PhysicalDeviceASTCDecodeFeaturesEXT {
33259         self.inner
33260     }
33261 }
33262 #[repr(C)]
33263 #[cfg_attr(feature = "debug", derive(Debug))]
33264 #[derive(Copy, Clone)]
33265 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTransformFeedbackFeaturesEXT.html>"]
33266 pub struct PhysicalDeviceTransformFeedbackFeaturesEXT {
33267     pub s_type: StructureType,
33268     pub p_next: *mut c_void,
33269     pub transform_feedback: Bool32,
33270     pub geometry_streams: Bool32,
33271 }
33272 impl ::std::default::Default for PhysicalDeviceTransformFeedbackFeaturesEXT {
33273     #[inline]
default() -> Self33274     fn default() -> Self {
33275         Self {
33276             s_type: Self::STRUCTURE_TYPE,
33277             p_next: ::std::ptr::null_mut(),
33278             transform_feedback: Bool32::default(),
33279             geometry_streams: Bool32::default(),
33280         }
33281     }
33282 }
33283 unsafe impl TaggedStructure for PhysicalDeviceTransformFeedbackFeaturesEXT {
33284     const STRUCTURE_TYPE: StructureType =
33285         StructureType::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
33286 }
33287 impl PhysicalDeviceTransformFeedbackFeaturesEXT {
builder<'a>() -> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a>33288     pub fn builder<'a>() -> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
33289         PhysicalDeviceTransformFeedbackFeaturesEXTBuilder {
33290             inner: Self::default(),
33291             marker: ::std::marker::PhantomData,
33292         }
33293     }
33294 }
33295 #[repr(transparent)]
33296 pub struct PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
33297     inner: PhysicalDeviceTransformFeedbackFeaturesEXT,
33298     marker: ::std::marker::PhantomData<&'a ()>,
33299 }
33300 unsafe impl ExtendsPhysicalDeviceFeatures2
33301     for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'_>
33302 {
33303 }
33304 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTransformFeedbackFeaturesEXT {}
33305 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'_> {}
33306 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTransformFeedbackFeaturesEXT {}
33307 impl<'a> ::std::ops::Deref for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
33308     type Target = PhysicalDeviceTransformFeedbackFeaturesEXT;
deref(&self) -> &Self::Target33309     fn deref(&self) -> &Self::Target {
33310         &self.inner
33311     }
33312 }
33313 impl<'a> ::std::ops::DerefMut for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target33314     fn deref_mut(&mut self) -> &mut Self::Target {
33315         &mut self.inner
33316     }
33317 }
33318 impl<'a> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
33319     #[inline]
transform_feedback(mut self, transform_feedback: bool) -> Self33320     pub fn transform_feedback(mut self, transform_feedback: bool) -> Self {
33321         self.inner.transform_feedback = transform_feedback.into();
33322         self
33323     }
33324     #[inline]
geometry_streams(mut self, geometry_streams: bool) -> Self33325     pub fn geometry_streams(mut self, geometry_streams: bool) -> Self {
33326         self.inner.geometry_streams = geometry_streams.into();
33327         self
33328     }
33329     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33330     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33331     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceTransformFeedbackFeaturesEXT33332     pub fn build(self) -> PhysicalDeviceTransformFeedbackFeaturesEXT {
33333         self.inner
33334     }
33335 }
33336 #[repr(C)]
33337 #[cfg_attr(feature = "debug", derive(Debug))]
33338 #[derive(Copy, Clone)]
33339 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTransformFeedbackPropertiesEXT.html>"]
33340 pub struct PhysicalDeviceTransformFeedbackPropertiesEXT {
33341     pub s_type: StructureType,
33342     pub p_next: *mut c_void,
33343     pub max_transform_feedback_streams: u32,
33344     pub max_transform_feedback_buffers: u32,
33345     pub max_transform_feedback_buffer_size: DeviceSize,
33346     pub max_transform_feedback_stream_data_size: u32,
33347     pub max_transform_feedback_buffer_data_size: u32,
33348     pub max_transform_feedback_buffer_data_stride: u32,
33349     pub transform_feedback_queries: Bool32,
33350     pub transform_feedback_streams_lines_triangles: Bool32,
33351     pub transform_feedback_rasterization_stream_select: Bool32,
33352     pub transform_feedback_draw: Bool32,
33353 }
33354 impl ::std::default::Default for PhysicalDeviceTransformFeedbackPropertiesEXT {
33355     #[inline]
default() -> Self33356     fn default() -> Self {
33357         Self {
33358             s_type: Self::STRUCTURE_TYPE,
33359             p_next: ::std::ptr::null_mut(),
33360             max_transform_feedback_streams: u32::default(),
33361             max_transform_feedback_buffers: u32::default(),
33362             max_transform_feedback_buffer_size: DeviceSize::default(),
33363             max_transform_feedback_stream_data_size: u32::default(),
33364             max_transform_feedback_buffer_data_size: u32::default(),
33365             max_transform_feedback_buffer_data_stride: u32::default(),
33366             transform_feedback_queries: Bool32::default(),
33367             transform_feedback_streams_lines_triangles: Bool32::default(),
33368             transform_feedback_rasterization_stream_select: Bool32::default(),
33369             transform_feedback_draw: Bool32::default(),
33370         }
33371     }
33372 }
33373 unsafe impl TaggedStructure for PhysicalDeviceTransformFeedbackPropertiesEXT {
33374     const STRUCTURE_TYPE: StructureType =
33375         StructureType::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
33376 }
33377 impl PhysicalDeviceTransformFeedbackPropertiesEXT {
builder<'a>() -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a>33378     pub fn builder<'a>() -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
33379         PhysicalDeviceTransformFeedbackPropertiesEXTBuilder {
33380             inner: Self::default(),
33381             marker: ::std::marker::PhantomData,
33382         }
33383     }
33384 }
33385 #[repr(transparent)]
33386 pub struct PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
33387     inner: PhysicalDeviceTransformFeedbackPropertiesEXT,
33388     marker: ::std::marker::PhantomData<&'a ()>,
33389 }
33390 unsafe impl ExtendsPhysicalDeviceProperties2
33391     for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'_>
33392 {
33393 }
33394 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTransformFeedbackPropertiesEXT {}
33395 impl<'a> ::std::ops::Deref for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
33396     type Target = PhysicalDeviceTransformFeedbackPropertiesEXT;
deref(&self) -> &Self::Target33397     fn deref(&self) -> &Self::Target {
33398         &self.inner
33399     }
33400 }
33401 impl<'a> ::std::ops::DerefMut for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target33402     fn deref_mut(&mut self) -> &mut Self::Target {
33403         &mut self.inner
33404     }
33405 }
33406 impl<'a> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
33407     #[inline]
max_transform_feedback_streams(mut self, max_transform_feedback_streams: u32) -> Self33408     pub fn max_transform_feedback_streams(mut self, max_transform_feedback_streams: u32) -> Self {
33409         self.inner.max_transform_feedback_streams = max_transform_feedback_streams;
33410         self
33411     }
33412     #[inline]
max_transform_feedback_buffers(mut self, max_transform_feedback_buffers: u32) -> Self33413     pub fn max_transform_feedback_buffers(mut self, max_transform_feedback_buffers: u32) -> Self {
33414         self.inner.max_transform_feedback_buffers = max_transform_feedback_buffers;
33415         self
33416     }
33417     #[inline]
max_transform_feedback_buffer_size( mut self, max_transform_feedback_buffer_size: DeviceSize, ) -> Self33418     pub fn max_transform_feedback_buffer_size(
33419         mut self,
33420         max_transform_feedback_buffer_size: DeviceSize,
33421     ) -> Self {
33422         self.inner.max_transform_feedback_buffer_size = max_transform_feedback_buffer_size;
33423         self
33424     }
33425     #[inline]
max_transform_feedback_stream_data_size( mut self, max_transform_feedback_stream_data_size: u32, ) -> Self33426     pub fn max_transform_feedback_stream_data_size(
33427         mut self,
33428         max_transform_feedback_stream_data_size: u32,
33429     ) -> Self {
33430         self.inner.max_transform_feedback_stream_data_size =
33431             max_transform_feedback_stream_data_size;
33432         self
33433     }
33434     #[inline]
max_transform_feedback_buffer_data_size( mut self, max_transform_feedback_buffer_data_size: u32, ) -> Self33435     pub fn max_transform_feedback_buffer_data_size(
33436         mut self,
33437         max_transform_feedback_buffer_data_size: u32,
33438     ) -> Self {
33439         self.inner.max_transform_feedback_buffer_data_size =
33440             max_transform_feedback_buffer_data_size;
33441         self
33442     }
33443     #[inline]
max_transform_feedback_buffer_data_stride( mut self, max_transform_feedback_buffer_data_stride: u32, ) -> Self33444     pub fn max_transform_feedback_buffer_data_stride(
33445         mut self,
33446         max_transform_feedback_buffer_data_stride: u32,
33447     ) -> Self {
33448         self.inner.max_transform_feedback_buffer_data_stride =
33449             max_transform_feedback_buffer_data_stride;
33450         self
33451     }
33452     #[inline]
transform_feedback_queries(mut self, transform_feedback_queries: bool) -> Self33453     pub fn transform_feedback_queries(mut self, transform_feedback_queries: bool) -> Self {
33454         self.inner.transform_feedback_queries = transform_feedback_queries.into();
33455         self
33456     }
33457     #[inline]
transform_feedback_streams_lines_triangles( mut self, transform_feedback_streams_lines_triangles: bool, ) -> Self33458     pub fn transform_feedback_streams_lines_triangles(
33459         mut self,
33460         transform_feedback_streams_lines_triangles: bool,
33461     ) -> Self {
33462         self.inner.transform_feedback_streams_lines_triangles =
33463             transform_feedback_streams_lines_triangles.into();
33464         self
33465     }
33466     #[inline]
transform_feedback_rasterization_stream_select( mut self, transform_feedback_rasterization_stream_select: bool, ) -> Self33467     pub fn transform_feedback_rasterization_stream_select(
33468         mut self,
33469         transform_feedback_rasterization_stream_select: bool,
33470     ) -> Self {
33471         self.inner.transform_feedback_rasterization_stream_select =
33472             transform_feedback_rasterization_stream_select.into();
33473         self
33474     }
33475     #[inline]
transform_feedback_draw(mut self, transform_feedback_draw: bool) -> Self33476     pub fn transform_feedback_draw(mut self, transform_feedback_draw: bool) -> Self {
33477         self.inner.transform_feedback_draw = transform_feedback_draw.into();
33478         self
33479     }
33480     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33481     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33482     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceTransformFeedbackPropertiesEXT33483     pub fn build(self) -> PhysicalDeviceTransformFeedbackPropertiesEXT {
33484         self.inner
33485     }
33486 }
33487 #[repr(C)]
33488 #[cfg_attr(feature = "debug", derive(Debug))]
33489 #[derive(Copy, Clone)]
33490 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationStateStreamCreateInfoEXT.html>"]
33491 pub struct PipelineRasterizationStateStreamCreateInfoEXT {
33492     pub s_type: StructureType,
33493     pub p_next: *const c_void,
33494     pub flags: PipelineRasterizationStateStreamCreateFlagsEXT,
33495     pub rasterization_stream: u32,
33496 }
33497 impl ::std::default::Default for PipelineRasterizationStateStreamCreateInfoEXT {
33498     #[inline]
default() -> Self33499     fn default() -> Self {
33500         Self {
33501             s_type: Self::STRUCTURE_TYPE,
33502             p_next: ::std::ptr::null(),
33503             flags: PipelineRasterizationStateStreamCreateFlagsEXT::default(),
33504             rasterization_stream: u32::default(),
33505         }
33506     }
33507 }
33508 unsafe impl TaggedStructure for PipelineRasterizationStateStreamCreateInfoEXT {
33509     const STRUCTURE_TYPE: StructureType =
33510         StructureType::PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT;
33511 }
33512 impl PipelineRasterizationStateStreamCreateInfoEXT {
builder<'a>() -> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a>33513     pub fn builder<'a>() -> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
33514         PipelineRasterizationStateStreamCreateInfoEXTBuilder {
33515             inner: Self::default(),
33516             marker: ::std::marker::PhantomData,
33517         }
33518     }
33519 }
33520 #[repr(transparent)]
33521 pub struct PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
33522     inner: PipelineRasterizationStateStreamCreateInfoEXT,
33523     marker: ::std::marker::PhantomData<&'a ()>,
33524 }
33525 unsafe impl ExtendsPipelineRasterizationStateCreateInfo
33526     for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'_>
33527 {
33528 }
33529 unsafe impl ExtendsPipelineRasterizationStateCreateInfo
33530     for PipelineRasterizationStateStreamCreateInfoEXT
33531 {
33532 }
33533 impl<'a> ::std::ops::Deref for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
33534     type Target = PipelineRasterizationStateStreamCreateInfoEXT;
deref(&self) -> &Self::Target33535     fn deref(&self) -> &Self::Target {
33536         &self.inner
33537     }
33538 }
33539 impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target33540     fn deref_mut(&mut self) -> &mut Self::Target {
33541         &mut self.inner
33542     }
33543 }
33544 impl<'a> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
33545     #[inline]
flags(mut self, flags: PipelineRasterizationStateStreamCreateFlagsEXT) -> Self33546     pub fn flags(mut self, flags: PipelineRasterizationStateStreamCreateFlagsEXT) -> Self {
33547         self.inner.flags = flags;
33548         self
33549     }
33550     #[inline]
rasterization_stream(mut self, rasterization_stream: u32) -> Self33551     pub fn rasterization_stream(mut self, rasterization_stream: u32) -> Self {
33552         self.inner.rasterization_stream = rasterization_stream;
33553         self
33554     }
33555     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33556     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33557     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineRasterizationStateStreamCreateInfoEXT33558     pub fn build(self) -> PipelineRasterizationStateStreamCreateInfoEXT {
33559         self.inner
33560     }
33561 }
33562 #[repr(C)]
33563 #[cfg_attr(feature = "debug", derive(Debug))]
33564 #[derive(Copy, Clone)]
33565 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV.html>"]
33566 pub struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
33567     pub s_type: StructureType,
33568     pub p_next: *mut c_void,
33569     pub representative_fragment_test: Bool32,
33570 }
33571 impl ::std::default::Default for PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
33572     #[inline]
default() -> Self33573     fn default() -> Self {
33574         Self {
33575             s_type: Self::STRUCTURE_TYPE,
33576             p_next: ::std::ptr::null_mut(),
33577             representative_fragment_test: Bool32::default(),
33578         }
33579     }
33580 }
33581 unsafe impl TaggedStructure for PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
33582     const STRUCTURE_TYPE: StructureType =
33583         StructureType::PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
33584 }
33585 impl PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
builder<'a>() -> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a>33586     pub fn builder<'a>() -> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
33587         PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder {
33588             inner: Self::default(),
33589             marker: ::std::marker::PhantomData,
33590         }
33591     }
33592 }
33593 #[repr(transparent)]
33594 pub struct PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
33595     inner: PhysicalDeviceRepresentativeFragmentTestFeaturesNV,
33596     marker: ::std::marker::PhantomData<&'a ()>,
33597 }
33598 unsafe impl ExtendsPhysicalDeviceFeatures2
33599     for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'_>
33600 {
33601 }
33602 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRepresentativeFragmentTestFeaturesNV {}
33603 unsafe impl ExtendsDeviceCreateInfo
33604     for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'_>
33605 {
33606 }
33607 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRepresentativeFragmentTestFeaturesNV {}
33608 impl<'a> ::std::ops::Deref for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
33609     type Target = PhysicalDeviceRepresentativeFragmentTestFeaturesNV;
deref(&self) -> &Self::Target33610     fn deref(&self) -> &Self::Target {
33611         &self.inner
33612     }
33613 }
33614 impl<'a> ::std::ops::DerefMut for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target33615     fn deref_mut(&mut self) -> &mut Self::Target {
33616         &mut self.inner
33617     }
33618 }
33619 impl<'a> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
33620     #[inline]
representative_fragment_test(mut self, representative_fragment_test: bool) -> Self33621     pub fn representative_fragment_test(mut self, representative_fragment_test: bool) -> Self {
33622         self.inner.representative_fragment_test = representative_fragment_test.into();
33623         self
33624     }
33625     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33626     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33627     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceRepresentativeFragmentTestFeaturesNV33628     pub fn build(self) -> PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
33629         self.inner
33630     }
33631 }
33632 #[repr(C)]
33633 #[cfg_attr(feature = "debug", derive(Debug))]
33634 #[derive(Copy, Clone)]
33635 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRepresentativeFragmentTestStateCreateInfoNV.html>"]
33636 pub struct PipelineRepresentativeFragmentTestStateCreateInfoNV {
33637     pub s_type: StructureType,
33638     pub p_next: *const c_void,
33639     pub representative_fragment_test_enable: Bool32,
33640 }
33641 impl ::std::default::Default for PipelineRepresentativeFragmentTestStateCreateInfoNV {
33642     #[inline]
default() -> Self33643     fn default() -> Self {
33644         Self {
33645             s_type: Self::STRUCTURE_TYPE,
33646             p_next: ::std::ptr::null(),
33647             representative_fragment_test_enable: Bool32::default(),
33648         }
33649     }
33650 }
33651 unsafe impl TaggedStructure for PipelineRepresentativeFragmentTestStateCreateInfoNV {
33652     const STRUCTURE_TYPE: StructureType =
33653         StructureType::PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV;
33654 }
33655 impl PipelineRepresentativeFragmentTestStateCreateInfoNV {
builder<'a>() -> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a>33656     pub fn builder<'a>() -> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
33657         PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder {
33658             inner: Self::default(),
33659             marker: ::std::marker::PhantomData,
33660         }
33661     }
33662 }
33663 #[repr(transparent)]
33664 pub struct PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
33665     inner: PipelineRepresentativeFragmentTestStateCreateInfoNV,
33666     marker: ::std::marker::PhantomData<&'a ()>,
33667 }
33668 unsafe impl ExtendsGraphicsPipelineCreateInfo
33669     for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'_>
33670 {
33671 }
33672 unsafe impl ExtendsGraphicsPipelineCreateInfo
33673     for PipelineRepresentativeFragmentTestStateCreateInfoNV
33674 {
33675 }
33676 impl<'a> ::std::ops::Deref for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
33677     type Target = PipelineRepresentativeFragmentTestStateCreateInfoNV;
deref(&self) -> &Self::Target33678     fn deref(&self) -> &Self::Target {
33679         &self.inner
33680     }
33681 }
33682 impl<'a> ::std::ops::DerefMut for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target33683     fn deref_mut(&mut self) -> &mut Self::Target {
33684         &mut self.inner
33685     }
33686 }
33687 impl<'a> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
33688     #[inline]
representative_fragment_test_enable( mut self, representative_fragment_test_enable: bool, ) -> Self33689     pub fn representative_fragment_test_enable(
33690         mut self,
33691         representative_fragment_test_enable: bool,
33692     ) -> Self {
33693         self.inner.representative_fragment_test_enable = representative_fragment_test_enable.into();
33694         self
33695     }
33696     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33697     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33698     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineRepresentativeFragmentTestStateCreateInfoNV33699     pub fn build(self) -> PipelineRepresentativeFragmentTestStateCreateInfoNV {
33700         self.inner
33701     }
33702 }
33703 #[repr(C)]
33704 #[cfg_attr(feature = "debug", derive(Debug))]
33705 #[derive(Copy, Clone)]
33706 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExclusiveScissorFeaturesNV.html>"]
33707 pub struct PhysicalDeviceExclusiveScissorFeaturesNV {
33708     pub s_type: StructureType,
33709     pub p_next: *mut c_void,
33710     pub exclusive_scissor: Bool32,
33711 }
33712 impl ::std::default::Default for PhysicalDeviceExclusiveScissorFeaturesNV {
33713     #[inline]
default() -> Self33714     fn default() -> Self {
33715         Self {
33716             s_type: Self::STRUCTURE_TYPE,
33717             p_next: ::std::ptr::null_mut(),
33718             exclusive_scissor: Bool32::default(),
33719         }
33720     }
33721 }
33722 unsafe impl TaggedStructure for PhysicalDeviceExclusiveScissorFeaturesNV {
33723     const STRUCTURE_TYPE: StructureType =
33724         StructureType::PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
33725 }
33726 impl PhysicalDeviceExclusiveScissorFeaturesNV {
builder<'a>() -> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a>33727     pub fn builder<'a>() -> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
33728         PhysicalDeviceExclusiveScissorFeaturesNVBuilder {
33729             inner: Self::default(),
33730             marker: ::std::marker::PhantomData,
33731         }
33732     }
33733 }
33734 #[repr(transparent)]
33735 pub struct PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
33736     inner: PhysicalDeviceExclusiveScissorFeaturesNV,
33737     marker: ::std::marker::PhantomData<&'a ()>,
33738 }
33739 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'_> {}
33740 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExclusiveScissorFeaturesNV {}
33741 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'_> {}
33742 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExclusiveScissorFeaturesNV {}
33743 impl<'a> ::std::ops::Deref for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
33744     type Target = PhysicalDeviceExclusiveScissorFeaturesNV;
deref(&self) -> &Self::Target33745     fn deref(&self) -> &Self::Target {
33746         &self.inner
33747     }
33748 }
33749 impl<'a> ::std::ops::DerefMut for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target33750     fn deref_mut(&mut self) -> &mut Self::Target {
33751         &mut self.inner
33752     }
33753 }
33754 impl<'a> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
33755     #[inline]
exclusive_scissor(mut self, exclusive_scissor: bool) -> Self33756     pub fn exclusive_scissor(mut self, exclusive_scissor: bool) -> Self {
33757         self.inner.exclusive_scissor = exclusive_scissor.into();
33758         self
33759     }
33760     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33761     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33762     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceExclusiveScissorFeaturesNV33763     pub fn build(self) -> PhysicalDeviceExclusiveScissorFeaturesNV {
33764         self.inner
33765     }
33766 }
33767 #[repr(C)]
33768 #[cfg_attr(feature = "debug", derive(Debug))]
33769 #[derive(Copy, Clone)]
33770 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportExclusiveScissorStateCreateInfoNV.html>"]
33771 pub struct PipelineViewportExclusiveScissorStateCreateInfoNV {
33772     pub s_type: StructureType,
33773     pub p_next: *const c_void,
33774     pub exclusive_scissor_count: u32,
33775     pub p_exclusive_scissors: *const Rect2D,
33776 }
33777 impl ::std::default::Default for PipelineViewportExclusiveScissorStateCreateInfoNV {
33778     #[inline]
default() -> Self33779     fn default() -> Self {
33780         Self {
33781             s_type: Self::STRUCTURE_TYPE,
33782             p_next: ::std::ptr::null(),
33783             exclusive_scissor_count: u32::default(),
33784             p_exclusive_scissors: ::std::ptr::null(),
33785         }
33786     }
33787 }
33788 unsafe impl TaggedStructure for PipelineViewportExclusiveScissorStateCreateInfoNV {
33789     const STRUCTURE_TYPE: StructureType =
33790         StructureType::PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV;
33791 }
33792 impl PipelineViewportExclusiveScissorStateCreateInfoNV {
builder<'a>() -> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a>33793     pub fn builder<'a>() -> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
33794         PipelineViewportExclusiveScissorStateCreateInfoNVBuilder {
33795             inner: Self::default(),
33796             marker: ::std::marker::PhantomData,
33797         }
33798     }
33799 }
33800 #[repr(transparent)]
33801 pub struct PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
33802     inner: PipelineViewportExclusiveScissorStateCreateInfoNV,
33803     marker: ::std::marker::PhantomData<&'a ()>,
33804 }
33805 unsafe impl ExtendsPipelineViewportStateCreateInfo
33806     for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'_>
33807 {
33808 }
33809 unsafe impl ExtendsPipelineViewportStateCreateInfo
33810     for PipelineViewportExclusiveScissorStateCreateInfoNV
33811 {
33812 }
33813 impl<'a> ::std::ops::Deref for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
33814     type Target = PipelineViewportExclusiveScissorStateCreateInfoNV;
deref(&self) -> &Self::Target33815     fn deref(&self) -> &Self::Target {
33816         &self.inner
33817     }
33818 }
33819 impl<'a> ::std::ops::DerefMut for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target33820     fn deref_mut(&mut self) -> &mut Self::Target {
33821         &mut self.inner
33822     }
33823 }
33824 impl<'a> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
33825     #[inline]
exclusive_scissors(mut self, exclusive_scissors: &'a [Rect2D]) -> Self33826     pub fn exclusive_scissors(mut self, exclusive_scissors: &'a [Rect2D]) -> Self {
33827         self.inner.exclusive_scissor_count = exclusive_scissors.len() as _;
33828         self.inner.p_exclusive_scissors = exclusive_scissors.as_ptr();
33829         self
33830     }
33831     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33832     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33833     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineViewportExclusiveScissorStateCreateInfoNV33834     pub fn build(self) -> PipelineViewportExclusiveScissorStateCreateInfoNV {
33835         self.inner
33836     }
33837 }
33838 #[repr(C)]
33839 #[cfg_attr(feature = "debug", derive(Debug))]
33840 #[derive(Copy, Clone)]
33841 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCornerSampledImageFeaturesNV.html>"]
33842 pub struct PhysicalDeviceCornerSampledImageFeaturesNV {
33843     pub s_type: StructureType,
33844     pub p_next: *mut c_void,
33845     pub corner_sampled_image: Bool32,
33846 }
33847 impl ::std::default::Default for PhysicalDeviceCornerSampledImageFeaturesNV {
33848     #[inline]
default() -> Self33849     fn default() -> Self {
33850         Self {
33851             s_type: Self::STRUCTURE_TYPE,
33852             p_next: ::std::ptr::null_mut(),
33853             corner_sampled_image: Bool32::default(),
33854         }
33855     }
33856 }
33857 unsafe impl TaggedStructure for PhysicalDeviceCornerSampledImageFeaturesNV {
33858     const STRUCTURE_TYPE: StructureType =
33859         StructureType::PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
33860 }
33861 impl PhysicalDeviceCornerSampledImageFeaturesNV {
builder<'a>() -> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a>33862     pub fn builder<'a>() -> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
33863         PhysicalDeviceCornerSampledImageFeaturesNVBuilder {
33864             inner: Self::default(),
33865             marker: ::std::marker::PhantomData,
33866         }
33867     }
33868 }
33869 #[repr(transparent)]
33870 pub struct PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
33871     inner: PhysicalDeviceCornerSampledImageFeaturesNV,
33872     marker: ::std::marker::PhantomData<&'a ()>,
33873 }
33874 unsafe impl ExtendsPhysicalDeviceFeatures2
33875     for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'_>
33876 {
33877 }
33878 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCornerSampledImageFeaturesNV {}
33879 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'_> {}
33880 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCornerSampledImageFeaturesNV {}
33881 impl<'a> ::std::ops::Deref for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
33882     type Target = PhysicalDeviceCornerSampledImageFeaturesNV;
deref(&self) -> &Self::Target33883     fn deref(&self) -> &Self::Target {
33884         &self.inner
33885     }
33886 }
33887 impl<'a> ::std::ops::DerefMut for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target33888     fn deref_mut(&mut self) -> &mut Self::Target {
33889         &mut self.inner
33890     }
33891 }
33892 impl<'a> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
33893     #[inline]
corner_sampled_image(mut self, corner_sampled_image: bool) -> Self33894     pub fn corner_sampled_image(mut self, corner_sampled_image: bool) -> Self {
33895         self.inner.corner_sampled_image = corner_sampled_image.into();
33896         self
33897     }
33898     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33899     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33900     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceCornerSampledImageFeaturesNV33901     pub fn build(self) -> PhysicalDeviceCornerSampledImageFeaturesNV {
33902         self.inner
33903     }
33904 }
33905 #[repr(C)]
33906 #[cfg_attr(feature = "debug", derive(Debug))]
33907 #[derive(Copy, Clone)]
33908 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceComputeShaderDerivativesFeaturesNV.html>"]
33909 pub struct PhysicalDeviceComputeShaderDerivativesFeaturesNV {
33910     pub s_type: StructureType,
33911     pub p_next: *mut c_void,
33912     pub compute_derivative_group_quads: Bool32,
33913     pub compute_derivative_group_linear: Bool32,
33914 }
33915 impl ::std::default::Default for PhysicalDeviceComputeShaderDerivativesFeaturesNV {
33916     #[inline]
default() -> Self33917     fn default() -> Self {
33918         Self {
33919             s_type: Self::STRUCTURE_TYPE,
33920             p_next: ::std::ptr::null_mut(),
33921             compute_derivative_group_quads: Bool32::default(),
33922             compute_derivative_group_linear: Bool32::default(),
33923         }
33924     }
33925 }
33926 unsafe impl TaggedStructure for PhysicalDeviceComputeShaderDerivativesFeaturesNV {
33927     const STRUCTURE_TYPE: StructureType =
33928         StructureType::PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV;
33929 }
33930 impl PhysicalDeviceComputeShaderDerivativesFeaturesNV {
builder<'a>() -> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a>33931     pub fn builder<'a>() -> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
33932         PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder {
33933             inner: Self::default(),
33934             marker: ::std::marker::PhantomData,
33935         }
33936     }
33937 }
33938 #[repr(transparent)]
33939 pub struct PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
33940     inner: PhysicalDeviceComputeShaderDerivativesFeaturesNV,
33941     marker: ::std::marker::PhantomData<&'a ()>,
33942 }
33943 unsafe impl ExtendsPhysicalDeviceFeatures2
33944     for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'_>
33945 {
33946 }
33947 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceComputeShaderDerivativesFeaturesNV {}
33948 unsafe impl ExtendsDeviceCreateInfo
33949     for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'_>
33950 {
33951 }
33952 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceComputeShaderDerivativesFeaturesNV {}
33953 impl<'a> ::std::ops::Deref for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
33954     type Target = PhysicalDeviceComputeShaderDerivativesFeaturesNV;
deref(&self) -> &Self::Target33955     fn deref(&self) -> &Self::Target {
33956         &self.inner
33957     }
33958 }
33959 impl<'a> ::std::ops::DerefMut for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target33960     fn deref_mut(&mut self) -> &mut Self::Target {
33961         &mut self.inner
33962     }
33963 }
33964 impl<'a> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
33965     #[inline]
compute_derivative_group_quads(mut self, compute_derivative_group_quads: bool) -> Self33966     pub fn compute_derivative_group_quads(mut self, compute_derivative_group_quads: bool) -> Self {
33967         self.inner.compute_derivative_group_quads = compute_derivative_group_quads.into();
33968         self
33969     }
33970     #[inline]
compute_derivative_group_linear( mut self, compute_derivative_group_linear: bool, ) -> Self33971     pub fn compute_derivative_group_linear(
33972         mut self,
33973         compute_derivative_group_linear: bool,
33974     ) -> Self {
33975         self.inner.compute_derivative_group_linear = compute_derivative_group_linear.into();
33976         self
33977     }
33978     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33979     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33980     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceComputeShaderDerivativesFeaturesNV33981     pub fn build(self) -> PhysicalDeviceComputeShaderDerivativesFeaturesNV {
33982         self.inner
33983     }
33984 }
33985 #[repr(C)]
33986 #[cfg_attr(feature = "debug", derive(Debug))]
33987 #[derive(Copy, Clone)]
33988 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderImageFootprintFeaturesNV.html>"]
33989 pub struct PhysicalDeviceShaderImageFootprintFeaturesNV {
33990     pub s_type: StructureType,
33991     pub p_next: *mut c_void,
33992     pub image_footprint: Bool32,
33993 }
33994 impl ::std::default::Default for PhysicalDeviceShaderImageFootprintFeaturesNV {
33995     #[inline]
default() -> Self33996     fn default() -> Self {
33997         Self {
33998             s_type: Self::STRUCTURE_TYPE,
33999             p_next: ::std::ptr::null_mut(),
34000             image_footprint: Bool32::default(),
34001         }
34002     }
34003 }
34004 unsafe impl TaggedStructure for PhysicalDeviceShaderImageFootprintFeaturesNV {
34005     const STRUCTURE_TYPE: StructureType =
34006         StructureType::PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
34007 }
34008 impl PhysicalDeviceShaderImageFootprintFeaturesNV {
builder<'a>() -> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a>34009     pub fn builder<'a>() -> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
34010         PhysicalDeviceShaderImageFootprintFeaturesNVBuilder {
34011             inner: Self::default(),
34012             marker: ::std::marker::PhantomData,
34013         }
34014     }
34015 }
34016 #[repr(transparent)]
34017 pub struct PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
34018     inner: PhysicalDeviceShaderImageFootprintFeaturesNV,
34019     marker: ::std::marker::PhantomData<&'a ()>,
34020 }
34021 unsafe impl ExtendsPhysicalDeviceFeatures2
34022     for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'_>
34023 {
34024 }
34025 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderImageFootprintFeaturesNV {}
34026 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'_> {}
34027 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageFootprintFeaturesNV {}
34028 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
34029     type Target = PhysicalDeviceShaderImageFootprintFeaturesNV;
deref(&self) -> &Self::Target34030     fn deref(&self) -> &Self::Target {
34031         &self.inner
34032     }
34033 }
34034 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target34035     fn deref_mut(&mut self) -> &mut Self::Target {
34036         &mut self.inner
34037     }
34038 }
34039 impl<'a> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
34040     #[inline]
image_footprint(mut self, image_footprint: bool) -> Self34041     pub fn image_footprint(mut self, image_footprint: bool) -> Self {
34042         self.inner.image_footprint = image_footprint.into();
34043         self
34044     }
34045     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34046     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34047     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderImageFootprintFeaturesNV34048     pub fn build(self) -> PhysicalDeviceShaderImageFootprintFeaturesNV {
34049         self.inner
34050     }
34051 }
34052 #[repr(C)]
34053 #[cfg_attr(feature = "debug", derive(Debug))]
34054 #[derive(Copy, Clone)]
34055 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV.html>"]
34056 pub struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
34057     pub s_type: StructureType,
34058     pub p_next: *mut c_void,
34059     pub dedicated_allocation_image_aliasing: Bool32,
34060 }
34061 impl ::std::default::Default for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
34062     #[inline]
default() -> Self34063     fn default() -> Self {
34064         Self {
34065             s_type: Self::STRUCTURE_TYPE,
34066             p_next: ::std::ptr::null_mut(),
34067             dedicated_allocation_image_aliasing: Bool32::default(),
34068         }
34069     }
34070 }
34071 unsafe impl TaggedStructure for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
34072     const STRUCTURE_TYPE: StructureType =
34073         StructureType::PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
34074 }
34075 impl PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
builder<'a>() -> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a>34076     pub fn builder<'a>() -> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
34077         PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder {
34078             inner: Self::default(),
34079             marker: ::std::marker::PhantomData,
34080         }
34081     }
34082 }
34083 #[repr(transparent)]
34084 pub struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
34085     inner: PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV,
34086     marker: ::std::marker::PhantomData<&'a ()>,
34087 }
34088 unsafe impl ExtendsPhysicalDeviceFeatures2
34089     for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'_>
34090 {
34091 }
34092 unsafe impl ExtendsPhysicalDeviceFeatures2
34093     for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV
34094 {
34095 }
34096 unsafe impl ExtendsDeviceCreateInfo
34097     for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'_>
34098 {
34099 }
34100 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {}
34101 impl<'a> ::std::ops::Deref for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
34102     type Target = PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
deref(&self) -> &Self::Target34103     fn deref(&self) -> &Self::Target {
34104         &self.inner
34105     }
34106 }
34107 impl<'a> ::std::ops::DerefMut
34108     for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a>
34109 {
deref_mut(&mut self) -> &mut Self::Target34110     fn deref_mut(&mut self) -> &mut Self::Target {
34111         &mut self.inner
34112     }
34113 }
34114 impl<'a> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
34115     #[inline]
dedicated_allocation_image_aliasing( mut self, dedicated_allocation_image_aliasing: bool, ) -> Self34116     pub fn dedicated_allocation_image_aliasing(
34117         mut self,
34118         dedicated_allocation_image_aliasing: bool,
34119     ) -> Self {
34120         self.inner.dedicated_allocation_image_aliasing = dedicated_allocation_image_aliasing.into();
34121         self
34122     }
34123     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34124     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34125     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV34126     pub fn build(self) -> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
34127         self.inner
34128     }
34129 }
34130 #[repr(C)]
34131 #[cfg_attr(feature = "debug", derive(Debug))]
34132 #[derive(Copy, Clone)]
34133 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCopyMemoryIndirectFeaturesNV.html>"]
34134 pub struct PhysicalDeviceCopyMemoryIndirectFeaturesNV {
34135     pub s_type: StructureType,
34136     pub p_next: *mut c_void,
34137     pub indirect_copy: Bool32,
34138 }
34139 impl ::std::default::Default for PhysicalDeviceCopyMemoryIndirectFeaturesNV {
34140     #[inline]
default() -> Self34141     fn default() -> Self {
34142         Self {
34143             s_type: Self::STRUCTURE_TYPE,
34144             p_next: ::std::ptr::null_mut(),
34145             indirect_copy: Bool32::default(),
34146         }
34147     }
34148 }
34149 unsafe impl TaggedStructure for PhysicalDeviceCopyMemoryIndirectFeaturesNV {
34150     const STRUCTURE_TYPE: StructureType =
34151         StructureType::PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
34152 }
34153 impl PhysicalDeviceCopyMemoryIndirectFeaturesNV {
builder<'a>() -> PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'a>34154     pub fn builder<'a>() -> PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'a> {
34155         PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder {
34156             inner: Self::default(),
34157             marker: ::std::marker::PhantomData,
34158         }
34159     }
34160 }
34161 #[repr(transparent)]
34162 pub struct PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'a> {
34163     inner: PhysicalDeviceCopyMemoryIndirectFeaturesNV,
34164     marker: ::std::marker::PhantomData<&'a ()>,
34165 }
34166 unsafe impl ExtendsPhysicalDeviceFeatures2
34167     for PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'_>
34168 {
34169 }
34170 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCopyMemoryIndirectFeaturesNV {}
34171 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'_> {}
34172 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCopyMemoryIndirectFeaturesNV {}
34173 impl<'a> ::std::ops::Deref for PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'a> {
34174     type Target = PhysicalDeviceCopyMemoryIndirectFeaturesNV;
deref(&self) -> &Self::Target34175     fn deref(&self) -> &Self::Target {
34176         &self.inner
34177     }
34178 }
34179 impl<'a> ::std::ops::DerefMut for PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target34180     fn deref_mut(&mut self) -> &mut Self::Target {
34181         &mut self.inner
34182     }
34183 }
34184 impl<'a> PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'a> {
34185     #[inline]
indirect_copy(mut self, indirect_copy: bool) -> Self34186     pub fn indirect_copy(mut self, indirect_copy: bool) -> Self {
34187         self.inner.indirect_copy = indirect_copy.into();
34188         self
34189     }
34190     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34191     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34192     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceCopyMemoryIndirectFeaturesNV34193     pub fn build(self) -> PhysicalDeviceCopyMemoryIndirectFeaturesNV {
34194         self.inner
34195     }
34196 }
34197 #[repr(C)]
34198 #[cfg_attr(feature = "debug", derive(Debug))]
34199 #[derive(Copy, Clone)]
34200 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCopyMemoryIndirectPropertiesNV.html>"]
34201 pub struct PhysicalDeviceCopyMemoryIndirectPropertiesNV {
34202     pub s_type: StructureType,
34203     pub p_next: *mut c_void,
34204     pub supported_queues: QueueFlags,
34205 }
34206 impl ::std::default::Default for PhysicalDeviceCopyMemoryIndirectPropertiesNV {
34207     #[inline]
default() -> Self34208     fn default() -> Self {
34209         Self {
34210             s_type: Self::STRUCTURE_TYPE,
34211             p_next: ::std::ptr::null_mut(),
34212             supported_queues: QueueFlags::default(),
34213         }
34214     }
34215 }
34216 unsafe impl TaggedStructure for PhysicalDeviceCopyMemoryIndirectPropertiesNV {
34217     const STRUCTURE_TYPE: StructureType =
34218         StructureType::PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV;
34219 }
34220 impl PhysicalDeviceCopyMemoryIndirectPropertiesNV {
builder<'a>() -> PhysicalDeviceCopyMemoryIndirectPropertiesNVBuilder<'a>34221     pub fn builder<'a>() -> PhysicalDeviceCopyMemoryIndirectPropertiesNVBuilder<'a> {
34222         PhysicalDeviceCopyMemoryIndirectPropertiesNVBuilder {
34223             inner: Self::default(),
34224             marker: ::std::marker::PhantomData,
34225         }
34226     }
34227 }
34228 #[repr(transparent)]
34229 pub struct PhysicalDeviceCopyMemoryIndirectPropertiesNVBuilder<'a> {
34230     inner: PhysicalDeviceCopyMemoryIndirectPropertiesNV,
34231     marker: ::std::marker::PhantomData<&'a ()>,
34232 }
34233 unsafe impl ExtendsPhysicalDeviceProperties2
34234     for PhysicalDeviceCopyMemoryIndirectPropertiesNVBuilder<'_>
34235 {
34236 }
34237 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCopyMemoryIndirectPropertiesNV {}
34238 impl<'a> ::std::ops::Deref for PhysicalDeviceCopyMemoryIndirectPropertiesNVBuilder<'a> {
34239     type Target = PhysicalDeviceCopyMemoryIndirectPropertiesNV;
deref(&self) -> &Self::Target34240     fn deref(&self) -> &Self::Target {
34241         &self.inner
34242     }
34243 }
34244 impl<'a> ::std::ops::DerefMut for PhysicalDeviceCopyMemoryIndirectPropertiesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target34245     fn deref_mut(&mut self) -> &mut Self::Target {
34246         &mut self.inner
34247     }
34248 }
34249 impl<'a> PhysicalDeviceCopyMemoryIndirectPropertiesNVBuilder<'a> {
34250     #[inline]
supported_queues(mut self, supported_queues: QueueFlags) -> Self34251     pub fn supported_queues(mut self, supported_queues: QueueFlags) -> Self {
34252         self.inner.supported_queues = supported_queues;
34253         self
34254     }
34255     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34256     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34257     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceCopyMemoryIndirectPropertiesNV34258     pub fn build(self) -> PhysicalDeviceCopyMemoryIndirectPropertiesNV {
34259         self.inner
34260     }
34261 }
34262 #[repr(C)]
34263 #[cfg_attr(feature = "debug", derive(Debug))]
34264 #[derive(Copy, Clone)]
34265 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMemoryDecompressionFeaturesNV.html>"]
34266 pub struct PhysicalDeviceMemoryDecompressionFeaturesNV {
34267     pub s_type: StructureType,
34268     pub p_next: *mut c_void,
34269     pub memory_decompression: Bool32,
34270 }
34271 impl ::std::default::Default for PhysicalDeviceMemoryDecompressionFeaturesNV {
34272     #[inline]
default() -> Self34273     fn default() -> Self {
34274         Self {
34275             s_type: Self::STRUCTURE_TYPE,
34276             p_next: ::std::ptr::null_mut(),
34277             memory_decompression: Bool32::default(),
34278         }
34279     }
34280 }
34281 unsafe impl TaggedStructure for PhysicalDeviceMemoryDecompressionFeaturesNV {
34282     const STRUCTURE_TYPE: StructureType =
34283         StructureType::PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
34284 }
34285 impl PhysicalDeviceMemoryDecompressionFeaturesNV {
builder<'a>() -> PhysicalDeviceMemoryDecompressionFeaturesNVBuilder<'a>34286     pub fn builder<'a>() -> PhysicalDeviceMemoryDecompressionFeaturesNVBuilder<'a> {
34287         PhysicalDeviceMemoryDecompressionFeaturesNVBuilder {
34288             inner: Self::default(),
34289             marker: ::std::marker::PhantomData,
34290         }
34291     }
34292 }
34293 #[repr(transparent)]
34294 pub struct PhysicalDeviceMemoryDecompressionFeaturesNVBuilder<'a> {
34295     inner: PhysicalDeviceMemoryDecompressionFeaturesNV,
34296     marker: ::std::marker::PhantomData<&'a ()>,
34297 }
34298 unsafe impl ExtendsPhysicalDeviceFeatures2
34299     for PhysicalDeviceMemoryDecompressionFeaturesNVBuilder<'_>
34300 {
34301 }
34302 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMemoryDecompressionFeaturesNV {}
34303 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryDecompressionFeaturesNVBuilder<'_> {}
34304 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryDecompressionFeaturesNV {}
34305 impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryDecompressionFeaturesNVBuilder<'a> {
34306     type Target = PhysicalDeviceMemoryDecompressionFeaturesNV;
deref(&self) -> &Self::Target34307     fn deref(&self) -> &Self::Target {
34308         &self.inner
34309     }
34310 }
34311 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryDecompressionFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target34312     fn deref_mut(&mut self) -> &mut Self::Target {
34313         &mut self.inner
34314     }
34315 }
34316 impl<'a> PhysicalDeviceMemoryDecompressionFeaturesNVBuilder<'a> {
34317     #[inline]
memory_decompression(mut self, memory_decompression: bool) -> Self34318     pub fn memory_decompression(mut self, memory_decompression: bool) -> Self {
34319         self.inner.memory_decompression = memory_decompression.into();
34320         self
34321     }
34322     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34323     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34324     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMemoryDecompressionFeaturesNV34325     pub fn build(self) -> PhysicalDeviceMemoryDecompressionFeaturesNV {
34326         self.inner
34327     }
34328 }
34329 #[repr(C)]
34330 #[cfg_attr(feature = "debug", derive(Debug))]
34331 #[derive(Copy, Clone)]
34332 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMemoryDecompressionPropertiesNV.html>"]
34333 pub struct PhysicalDeviceMemoryDecompressionPropertiesNV {
34334     pub s_type: StructureType,
34335     pub p_next: *mut c_void,
34336     pub decompression_methods: MemoryDecompressionMethodFlagsNV,
34337     pub max_decompression_indirect_count: u64,
34338 }
34339 impl ::std::default::Default for PhysicalDeviceMemoryDecompressionPropertiesNV {
34340     #[inline]
default() -> Self34341     fn default() -> Self {
34342         Self {
34343             s_type: Self::STRUCTURE_TYPE,
34344             p_next: ::std::ptr::null_mut(),
34345             decompression_methods: MemoryDecompressionMethodFlagsNV::default(),
34346             max_decompression_indirect_count: u64::default(),
34347         }
34348     }
34349 }
34350 unsafe impl TaggedStructure for PhysicalDeviceMemoryDecompressionPropertiesNV {
34351     const STRUCTURE_TYPE: StructureType =
34352         StructureType::PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV;
34353 }
34354 impl PhysicalDeviceMemoryDecompressionPropertiesNV {
builder<'a>() -> PhysicalDeviceMemoryDecompressionPropertiesNVBuilder<'a>34355     pub fn builder<'a>() -> PhysicalDeviceMemoryDecompressionPropertiesNVBuilder<'a> {
34356         PhysicalDeviceMemoryDecompressionPropertiesNVBuilder {
34357             inner: Self::default(),
34358             marker: ::std::marker::PhantomData,
34359         }
34360     }
34361 }
34362 #[repr(transparent)]
34363 pub struct PhysicalDeviceMemoryDecompressionPropertiesNVBuilder<'a> {
34364     inner: PhysicalDeviceMemoryDecompressionPropertiesNV,
34365     marker: ::std::marker::PhantomData<&'a ()>,
34366 }
34367 unsafe impl ExtendsPhysicalDeviceProperties2
34368     for PhysicalDeviceMemoryDecompressionPropertiesNVBuilder<'_>
34369 {
34370 }
34371 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMemoryDecompressionPropertiesNV {}
34372 impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryDecompressionPropertiesNVBuilder<'a> {
34373     type Target = PhysicalDeviceMemoryDecompressionPropertiesNV;
deref(&self) -> &Self::Target34374     fn deref(&self) -> &Self::Target {
34375         &self.inner
34376     }
34377 }
34378 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryDecompressionPropertiesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target34379     fn deref_mut(&mut self) -> &mut Self::Target {
34380         &mut self.inner
34381     }
34382 }
34383 impl<'a> PhysicalDeviceMemoryDecompressionPropertiesNVBuilder<'a> {
34384     #[inline]
decompression_methods( mut self, decompression_methods: MemoryDecompressionMethodFlagsNV, ) -> Self34385     pub fn decompression_methods(
34386         mut self,
34387         decompression_methods: MemoryDecompressionMethodFlagsNV,
34388     ) -> Self {
34389         self.inner.decompression_methods = decompression_methods;
34390         self
34391     }
34392     #[inline]
max_decompression_indirect_count( mut self, max_decompression_indirect_count: u64, ) -> Self34393     pub fn max_decompression_indirect_count(
34394         mut self,
34395         max_decompression_indirect_count: u64,
34396     ) -> Self {
34397         self.inner.max_decompression_indirect_count = max_decompression_indirect_count;
34398         self
34399     }
34400     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34401     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34402     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMemoryDecompressionPropertiesNV34403     pub fn build(self) -> PhysicalDeviceMemoryDecompressionPropertiesNV {
34404         self.inner
34405     }
34406 }
34407 #[repr(C)]
34408 #[cfg_attr(feature = "debug", derive(Debug))]
34409 #[derive(Copy, Clone)]
34410 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShadingRatePaletteNV.html>"]
34411 pub struct ShadingRatePaletteNV {
34412     pub shading_rate_palette_entry_count: u32,
34413     pub p_shading_rate_palette_entries: *const ShadingRatePaletteEntryNV,
34414 }
34415 impl ::std::default::Default for ShadingRatePaletteNV {
34416     #[inline]
default() -> Self34417     fn default() -> Self {
34418         Self {
34419             shading_rate_palette_entry_count: u32::default(),
34420             p_shading_rate_palette_entries: ::std::ptr::null(),
34421         }
34422     }
34423 }
34424 impl ShadingRatePaletteNV {
builder<'a>() -> ShadingRatePaletteNVBuilder<'a>34425     pub fn builder<'a>() -> ShadingRatePaletteNVBuilder<'a> {
34426         ShadingRatePaletteNVBuilder {
34427             inner: Self::default(),
34428             marker: ::std::marker::PhantomData,
34429         }
34430     }
34431 }
34432 #[repr(transparent)]
34433 pub struct ShadingRatePaletteNVBuilder<'a> {
34434     inner: ShadingRatePaletteNV,
34435     marker: ::std::marker::PhantomData<&'a ()>,
34436 }
34437 impl<'a> ::std::ops::Deref for ShadingRatePaletteNVBuilder<'a> {
34438     type Target = ShadingRatePaletteNV;
deref(&self) -> &Self::Target34439     fn deref(&self) -> &Self::Target {
34440         &self.inner
34441     }
34442 }
34443 impl<'a> ::std::ops::DerefMut for ShadingRatePaletteNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target34444     fn deref_mut(&mut self) -> &mut Self::Target {
34445         &mut self.inner
34446     }
34447 }
34448 impl<'a> ShadingRatePaletteNVBuilder<'a> {
34449     #[inline]
shading_rate_palette_entries( mut self, shading_rate_palette_entries: &'a [ShadingRatePaletteEntryNV], ) -> Self34450     pub fn shading_rate_palette_entries(
34451         mut self,
34452         shading_rate_palette_entries: &'a [ShadingRatePaletteEntryNV],
34453     ) -> Self {
34454         self.inner.shading_rate_palette_entry_count = shading_rate_palette_entries.len() as _;
34455         self.inner.p_shading_rate_palette_entries = shading_rate_palette_entries.as_ptr();
34456         self
34457     }
34458     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34459     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34460     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ShadingRatePaletteNV34461     pub fn build(self) -> ShadingRatePaletteNV {
34462         self.inner
34463     }
34464 }
34465 #[repr(C)]
34466 #[cfg_attr(feature = "debug", derive(Debug))]
34467 #[derive(Copy, Clone)]
34468 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportShadingRateImageStateCreateInfoNV.html>"]
34469 pub struct PipelineViewportShadingRateImageStateCreateInfoNV {
34470     pub s_type: StructureType,
34471     pub p_next: *const c_void,
34472     pub shading_rate_image_enable: Bool32,
34473     pub viewport_count: u32,
34474     pub p_shading_rate_palettes: *const ShadingRatePaletteNV,
34475 }
34476 impl ::std::default::Default for PipelineViewportShadingRateImageStateCreateInfoNV {
34477     #[inline]
default() -> Self34478     fn default() -> Self {
34479         Self {
34480             s_type: Self::STRUCTURE_TYPE,
34481             p_next: ::std::ptr::null(),
34482             shading_rate_image_enable: Bool32::default(),
34483             viewport_count: u32::default(),
34484             p_shading_rate_palettes: ::std::ptr::null(),
34485         }
34486     }
34487 }
34488 unsafe impl TaggedStructure for PipelineViewportShadingRateImageStateCreateInfoNV {
34489     const STRUCTURE_TYPE: StructureType =
34490         StructureType::PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV;
34491 }
34492 impl PipelineViewportShadingRateImageStateCreateInfoNV {
builder<'a>() -> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a>34493     pub fn builder<'a>() -> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
34494         PipelineViewportShadingRateImageStateCreateInfoNVBuilder {
34495             inner: Self::default(),
34496             marker: ::std::marker::PhantomData,
34497         }
34498     }
34499 }
34500 #[repr(transparent)]
34501 pub struct PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
34502     inner: PipelineViewportShadingRateImageStateCreateInfoNV,
34503     marker: ::std::marker::PhantomData<&'a ()>,
34504 }
34505 unsafe impl ExtendsPipelineViewportStateCreateInfo
34506     for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'_>
34507 {
34508 }
34509 unsafe impl ExtendsPipelineViewportStateCreateInfo
34510     for PipelineViewportShadingRateImageStateCreateInfoNV
34511 {
34512 }
34513 impl<'a> ::std::ops::Deref for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
34514     type Target = PipelineViewportShadingRateImageStateCreateInfoNV;
deref(&self) -> &Self::Target34515     fn deref(&self) -> &Self::Target {
34516         &self.inner
34517     }
34518 }
34519 impl<'a> ::std::ops::DerefMut for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target34520     fn deref_mut(&mut self) -> &mut Self::Target {
34521         &mut self.inner
34522     }
34523 }
34524 impl<'a> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
34525     #[inline]
shading_rate_image_enable(mut self, shading_rate_image_enable: bool) -> Self34526     pub fn shading_rate_image_enable(mut self, shading_rate_image_enable: bool) -> Self {
34527         self.inner.shading_rate_image_enable = shading_rate_image_enable.into();
34528         self
34529     }
34530     #[inline]
shading_rate_palettes( mut self, shading_rate_palettes: &'a [ShadingRatePaletteNV], ) -> Self34531     pub fn shading_rate_palettes(
34532         mut self,
34533         shading_rate_palettes: &'a [ShadingRatePaletteNV],
34534     ) -> Self {
34535         self.inner.viewport_count = shading_rate_palettes.len() as _;
34536         self.inner.p_shading_rate_palettes = shading_rate_palettes.as_ptr();
34537         self
34538     }
34539     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34540     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34541     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineViewportShadingRateImageStateCreateInfoNV34542     pub fn build(self) -> PipelineViewportShadingRateImageStateCreateInfoNV {
34543         self.inner
34544     }
34545 }
34546 #[repr(C)]
34547 #[cfg_attr(feature = "debug", derive(Debug))]
34548 #[derive(Copy, Clone)]
34549 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShadingRateImageFeaturesNV.html>"]
34550 pub struct PhysicalDeviceShadingRateImageFeaturesNV {
34551     pub s_type: StructureType,
34552     pub p_next: *mut c_void,
34553     pub shading_rate_image: Bool32,
34554     pub shading_rate_coarse_sample_order: Bool32,
34555 }
34556 impl ::std::default::Default for PhysicalDeviceShadingRateImageFeaturesNV {
34557     #[inline]
default() -> Self34558     fn default() -> Self {
34559         Self {
34560             s_type: Self::STRUCTURE_TYPE,
34561             p_next: ::std::ptr::null_mut(),
34562             shading_rate_image: Bool32::default(),
34563             shading_rate_coarse_sample_order: Bool32::default(),
34564         }
34565     }
34566 }
34567 unsafe impl TaggedStructure for PhysicalDeviceShadingRateImageFeaturesNV {
34568     const STRUCTURE_TYPE: StructureType =
34569         StructureType::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
34570 }
34571 impl PhysicalDeviceShadingRateImageFeaturesNV {
builder<'a>() -> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a>34572     pub fn builder<'a>() -> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
34573         PhysicalDeviceShadingRateImageFeaturesNVBuilder {
34574             inner: Self::default(),
34575             marker: ::std::marker::PhantomData,
34576         }
34577     }
34578 }
34579 #[repr(transparent)]
34580 pub struct PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
34581     inner: PhysicalDeviceShadingRateImageFeaturesNV,
34582     marker: ::std::marker::PhantomData<&'a ()>,
34583 }
34584 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'_> {}
34585 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShadingRateImageFeaturesNV {}
34586 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'_> {}
34587 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShadingRateImageFeaturesNV {}
34588 impl<'a> ::std::ops::Deref for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
34589     type Target = PhysicalDeviceShadingRateImageFeaturesNV;
deref(&self) -> &Self::Target34590     fn deref(&self) -> &Self::Target {
34591         &self.inner
34592     }
34593 }
34594 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target34595     fn deref_mut(&mut self) -> &mut Self::Target {
34596         &mut self.inner
34597     }
34598 }
34599 impl<'a> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
34600     #[inline]
shading_rate_image(mut self, shading_rate_image: bool) -> Self34601     pub fn shading_rate_image(mut self, shading_rate_image: bool) -> Self {
34602         self.inner.shading_rate_image = shading_rate_image.into();
34603         self
34604     }
34605     #[inline]
shading_rate_coarse_sample_order( mut self, shading_rate_coarse_sample_order: bool, ) -> Self34606     pub fn shading_rate_coarse_sample_order(
34607         mut self,
34608         shading_rate_coarse_sample_order: bool,
34609     ) -> Self {
34610         self.inner.shading_rate_coarse_sample_order = shading_rate_coarse_sample_order.into();
34611         self
34612     }
34613     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34614     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34615     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShadingRateImageFeaturesNV34616     pub fn build(self) -> PhysicalDeviceShadingRateImageFeaturesNV {
34617         self.inner
34618     }
34619 }
34620 #[repr(C)]
34621 #[cfg_attr(feature = "debug", derive(Debug))]
34622 #[derive(Copy, Clone)]
34623 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShadingRateImagePropertiesNV.html>"]
34624 pub struct PhysicalDeviceShadingRateImagePropertiesNV {
34625     pub s_type: StructureType,
34626     pub p_next: *mut c_void,
34627     pub shading_rate_texel_size: Extent2D,
34628     pub shading_rate_palette_size: u32,
34629     pub shading_rate_max_coarse_samples: u32,
34630 }
34631 impl ::std::default::Default for PhysicalDeviceShadingRateImagePropertiesNV {
34632     #[inline]
default() -> Self34633     fn default() -> Self {
34634         Self {
34635             s_type: Self::STRUCTURE_TYPE,
34636             p_next: ::std::ptr::null_mut(),
34637             shading_rate_texel_size: Extent2D::default(),
34638             shading_rate_palette_size: u32::default(),
34639             shading_rate_max_coarse_samples: u32::default(),
34640         }
34641     }
34642 }
34643 unsafe impl TaggedStructure for PhysicalDeviceShadingRateImagePropertiesNV {
34644     const STRUCTURE_TYPE: StructureType =
34645         StructureType::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV;
34646 }
34647 impl PhysicalDeviceShadingRateImagePropertiesNV {
builder<'a>() -> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a>34648     pub fn builder<'a>() -> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
34649         PhysicalDeviceShadingRateImagePropertiesNVBuilder {
34650             inner: Self::default(),
34651             marker: ::std::marker::PhantomData,
34652         }
34653     }
34654 }
34655 #[repr(transparent)]
34656 pub struct PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
34657     inner: PhysicalDeviceShadingRateImagePropertiesNV,
34658     marker: ::std::marker::PhantomData<&'a ()>,
34659 }
34660 unsafe impl ExtendsPhysicalDeviceProperties2
34661     for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'_>
34662 {
34663 }
34664 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShadingRateImagePropertiesNV {}
34665 impl<'a> ::std::ops::Deref for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
34666     type Target = PhysicalDeviceShadingRateImagePropertiesNV;
deref(&self) -> &Self::Target34667     fn deref(&self) -> &Self::Target {
34668         &self.inner
34669     }
34670 }
34671 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target34672     fn deref_mut(&mut self) -> &mut Self::Target {
34673         &mut self.inner
34674     }
34675 }
34676 impl<'a> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
34677     #[inline]
shading_rate_texel_size(mut self, shading_rate_texel_size: Extent2D) -> Self34678     pub fn shading_rate_texel_size(mut self, shading_rate_texel_size: Extent2D) -> Self {
34679         self.inner.shading_rate_texel_size = shading_rate_texel_size;
34680         self
34681     }
34682     #[inline]
shading_rate_palette_size(mut self, shading_rate_palette_size: u32) -> Self34683     pub fn shading_rate_palette_size(mut self, shading_rate_palette_size: u32) -> Self {
34684         self.inner.shading_rate_palette_size = shading_rate_palette_size;
34685         self
34686     }
34687     #[inline]
shading_rate_max_coarse_samples(mut self, shading_rate_max_coarse_samples: u32) -> Self34688     pub fn shading_rate_max_coarse_samples(mut self, shading_rate_max_coarse_samples: u32) -> Self {
34689         self.inner.shading_rate_max_coarse_samples = shading_rate_max_coarse_samples;
34690         self
34691     }
34692     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34693     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34694     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShadingRateImagePropertiesNV34695     pub fn build(self) -> PhysicalDeviceShadingRateImagePropertiesNV {
34696         self.inner
34697     }
34698 }
34699 #[repr(C)]
34700 #[cfg_attr(feature = "debug", derive(Debug))]
34701 #[derive(Copy, Clone)]
34702 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceInvocationMaskFeaturesHUAWEI.html>"]
34703 pub struct PhysicalDeviceInvocationMaskFeaturesHUAWEI {
34704     pub s_type: StructureType,
34705     pub p_next: *mut c_void,
34706     pub invocation_mask: Bool32,
34707 }
34708 impl ::std::default::Default for PhysicalDeviceInvocationMaskFeaturesHUAWEI {
34709     #[inline]
default() -> Self34710     fn default() -> Self {
34711         Self {
34712             s_type: Self::STRUCTURE_TYPE,
34713             p_next: ::std::ptr::null_mut(),
34714             invocation_mask: Bool32::default(),
34715         }
34716     }
34717 }
34718 unsafe impl TaggedStructure for PhysicalDeviceInvocationMaskFeaturesHUAWEI {
34719     const STRUCTURE_TYPE: StructureType =
34720         StructureType::PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
34721 }
34722 impl PhysicalDeviceInvocationMaskFeaturesHUAWEI {
builder<'a>() -> PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a>34723     pub fn builder<'a>() -> PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
34724         PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder {
34725             inner: Self::default(),
34726             marker: ::std::marker::PhantomData,
34727         }
34728     }
34729 }
34730 #[repr(transparent)]
34731 pub struct PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
34732     inner: PhysicalDeviceInvocationMaskFeaturesHUAWEI,
34733     marker: ::std::marker::PhantomData<&'a ()>,
34734 }
34735 unsafe impl ExtendsPhysicalDeviceFeatures2
34736     for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'_>
34737 {
34738 }
34739 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInvocationMaskFeaturesHUAWEI {}
34740 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'_> {}
34741 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInvocationMaskFeaturesHUAWEI {}
34742 impl<'a> ::std::ops::Deref for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
34743     type Target = PhysicalDeviceInvocationMaskFeaturesHUAWEI;
deref(&self) -> &Self::Target34744     fn deref(&self) -> &Self::Target {
34745         &self.inner
34746     }
34747 }
34748 impl<'a> ::std::ops::DerefMut for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target34749     fn deref_mut(&mut self) -> &mut Self::Target {
34750         &mut self.inner
34751     }
34752 }
34753 impl<'a> PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
34754     #[inline]
invocation_mask(mut self, invocation_mask: bool) -> Self34755     pub fn invocation_mask(mut self, invocation_mask: bool) -> Self {
34756         self.inner.invocation_mask = invocation_mask.into();
34757         self
34758     }
34759     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34760     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34761     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceInvocationMaskFeaturesHUAWEI34762     pub fn build(self) -> PhysicalDeviceInvocationMaskFeaturesHUAWEI {
34763         self.inner
34764     }
34765 }
34766 #[repr(C)]
34767 #[cfg_attr(feature = "debug", derive(Debug))]
34768 #[derive(Copy, Clone, Default)]
34769 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCoarseSampleLocationNV.html>"]
34770 pub struct CoarseSampleLocationNV {
34771     pub pixel_x: u32,
34772     pub pixel_y: u32,
34773     pub sample: u32,
34774 }
34775 impl CoarseSampleLocationNV {
builder<'a>() -> CoarseSampleLocationNVBuilder<'a>34776     pub fn builder<'a>() -> CoarseSampleLocationNVBuilder<'a> {
34777         CoarseSampleLocationNVBuilder {
34778             inner: Self::default(),
34779             marker: ::std::marker::PhantomData,
34780         }
34781     }
34782 }
34783 #[repr(transparent)]
34784 pub struct CoarseSampleLocationNVBuilder<'a> {
34785     inner: CoarseSampleLocationNV,
34786     marker: ::std::marker::PhantomData<&'a ()>,
34787 }
34788 impl<'a> ::std::ops::Deref for CoarseSampleLocationNVBuilder<'a> {
34789     type Target = CoarseSampleLocationNV;
deref(&self) -> &Self::Target34790     fn deref(&self) -> &Self::Target {
34791         &self.inner
34792     }
34793 }
34794 impl<'a> ::std::ops::DerefMut for CoarseSampleLocationNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target34795     fn deref_mut(&mut self) -> &mut Self::Target {
34796         &mut self.inner
34797     }
34798 }
34799 impl<'a> CoarseSampleLocationNVBuilder<'a> {
34800     #[inline]
pixel_x(mut self, pixel_x: u32) -> Self34801     pub fn pixel_x(mut self, pixel_x: u32) -> Self {
34802         self.inner.pixel_x = pixel_x;
34803         self
34804     }
34805     #[inline]
pixel_y(mut self, pixel_y: u32) -> Self34806     pub fn pixel_y(mut self, pixel_y: u32) -> Self {
34807         self.inner.pixel_y = pixel_y;
34808         self
34809     }
34810     #[inline]
sample(mut self, sample: u32) -> Self34811     pub fn sample(mut self, sample: u32) -> Self {
34812         self.inner.sample = sample;
34813         self
34814     }
34815     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34816     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34817     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CoarseSampleLocationNV34818     pub fn build(self) -> CoarseSampleLocationNV {
34819         self.inner
34820     }
34821 }
34822 #[repr(C)]
34823 #[cfg_attr(feature = "debug", derive(Debug))]
34824 #[derive(Copy, Clone)]
34825 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCoarseSampleOrderCustomNV.html>"]
34826 pub struct CoarseSampleOrderCustomNV {
34827     pub shading_rate: ShadingRatePaletteEntryNV,
34828     pub sample_count: u32,
34829     pub sample_location_count: u32,
34830     pub p_sample_locations: *const CoarseSampleLocationNV,
34831 }
34832 impl ::std::default::Default for CoarseSampleOrderCustomNV {
34833     #[inline]
default() -> Self34834     fn default() -> Self {
34835         Self {
34836             shading_rate: ShadingRatePaletteEntryNV::default(),
34837             sample_count: u32::default(),
34838             sample_location_count: u32::default(),
34839             p_sample_locations: ::std::ptr::null(),
34840         }
34841     }
34842 }
34843 impl CoarseSampleOrderCustomNV {
builder<'a>() -> CoarseSampleOrderCustomNVBuilder<'a>34844     pub fn builder<'a>() -> CoarseSampleOrderCustomNVBuilder<'a> {
34845         CoarseSampleOrderCustomNVBuilder {
34846             inner: Self::default(),
34847             marker: ::std::marker::PhantomData,
34848         }
34849     }
34850 }
34851 #[repr(transparent)]
34852 pub struct CoarseSampleOrderCustomNVBuilder<'a> {
34853     inner: CoarseSampleOrderCustomNV,
34854     marker: ::std::marker::PhantomData<&'a ()>,
34855 }
34856 impl<'a> ::std::ops::Deref for CoarseSampleOrderCustomNVBuilder<'a> {
34857     type Target = CoarseSampleOrderCustomNV;
deref(&self) -> &Self::Target34858     fn deref(&self) -> &Self::Target {
34859         &self.inner
34860     }
34861 }
34862 impl<'a> ::std::ops::DerefMut for CoarseSampleOrderCustomNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target34863     fn deref_mut(&mut self) -> &mut Self::Target {
34864         &mut self.inner
34865     }
34866 }
34867 impl<'a> CoarseSampleOrderCustomNVBuilder<'a> {
34868     #[inline]
shading_rate(mut self, shading_rate: ShadingRatePaletteEntryNV) -> Self34869     pub fn shading_rate(mut self, shading_rate: ShadingRatePaletteEntryNV) -> Self {
34870         self.inner.shading_rate = shading_rate;
34871         self
34872     }
34873     #[inline]
sample_count(mut self, sample_count: u32) -> Self34874     pub fn sample_count(mut self, sample_count: u32) -> Self {
34875         self.inner.sample_count = sample_count;
34876         self
34877     }
34878     #[inline]
sample_locations(mut self, sample_locations: &'a [CoarseSampleLocationNV]) -> Self34879     pub fn sample_locations(mut self, sample_locations: &'a [CoarseSampleLocationNV]) -> Self {
34880         self.inner.sample_location_count = sample_locations.len() as _;
34881         self.inner.p_sample_locations = sample_locations.as_ptr();
34882         self
34883     }
34884     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34885     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34886     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CoarseSampleOrderCustomNV34887     pub fn build(self) -> CoarseSampleOrderCustomNV {
34888         self.inner
34889     }
34890 }
34891 #[repr(C)]
34892 #[cfg_attr(feature = "debug", derive(Debug))]
34893 #[derive(Copy, Clone)]
34894 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportCoarseSampleOrderStateCreateInfoNV.html>"]
34895 pub struct PipelineViewportCoarseSampleOrderStateCreateInfoNV {
34896     pub s_type: StructureType,
34897     pub p_next: *const c_void,
34898     pub sample_order_type: CoarseSampleOrderTypeNV,
34899     pub custom_sample_order_count: u32,
34900     pub p_custom_sample_orders: *const CoarseSampleOrderCustomNV,
34901 }
34902 impl ::std::default::Default for PipelineViewportCoarseSampleOrderStateCreateInfoNV {
34903     #[inline]
default() -> Self34904     fn default() -> Self {
34905         Self {
34906             s_type: Self::STRUCTURE_TYPE,
34907             p_next: ::std::ptr::null(),
34908             sample_order_type: CoarseSampleOrderTypeNV::default(),
34909             custom_sample_order_count: u32::default(),
34910             p_custom_sample_orders: ::std::ptr::null(),
34911         }
34912     }
34913 }
34914 unsafe impl TaggedStructure for PipelineViewportCoarseSampleOrderStateCreateInfoNV {
34915     const STRUCTURE_TYPE: StructureType =
34916         StructureType::PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV;
34917 }
34918 impl PipelineViewportCoarseSampleOrderStateCreateInfoNV {
builder<'a>() -> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a>34919     pub fn builder<'a>() -> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
34920         PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder {
34921             inner: Self::default(),
34922             marker: ::std::marker::PhantomData,
34923         }
34924     }
34925 }
34926 #[repr(transparent)]
34927 pub struct PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
34928     inner: PipelineViewportCoarseSampleOrderStateCreateInfoNV,
34929     marker: ::std::marker::PhantomData<&'a ()>,
34930 }
34931 unsafe impl ExtendsPipelineViewportStateCreateInfo
34932     for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'_>
34933 {
34934 }
34935 unsafe impl ExtendsPipelineViewportStateCreateInfo
34936     for PipelineViewportCoarseSampleOrderStateCreateInfoNV
34937 {
34938 }
34939 impl<'a> ::std::ops::Deref for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
34940     type Target = PipelineViewportCoarseSampleOrderStateCreateInfoNV;
deref(&self) -> &Self::Target34941     fn deref(&self) -> &Self::Target {
34942         &self.inner
34943     }
34944 }
34945 impl<'a> ::std::ops::DerefMut for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target34946     fn deref_mut(&mut self) -> &mut Self::Target {
34947         &mut self.inner
34948     }
34949 }
34950 impl<'a> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
34951     #[inline]
sample_order_type(mut self, sample_order_type: CoarseSampleOrderTypeNV) -> Self34952     pub fn sample_order_type(mut self, sample_order_type: CoarseSampleOrderTypeNV) -> Self {
34953         self.inner.sample_order_type = sample_order_type;
34954         self
34955     }
34956     #[inline]
custom_sample_orders( mut self, custom_sample_orders: &'a [CoarseSampleOrderCustomNV], ) -> Self34957     pub fn custom_sample_orders(
34958         mut self,
34959         custom_sample_orders: &'a [CoarseSampleOrderCustomNV],
34960     ) -> Self {
34961         self.inner.custom_sample_order_count = custom_sample_orders.len() as _;
34962         self.inner.p_custom_sample_orders = custom_sample_orders.as_ptr();
34963         self
34964     }
34965     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34966     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34967     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineViewportCoarseSampleOrderStateCreateInfoNV34968     pub fn build(self) -> PipelineViewportCoarseSampleOrderStateCreateInfoNV {
34969         self.inner
34970     }
34971 }
34972 #[repr(C)]
34973 #[cfg_attr(feature = "debug", derive(Debug))]
34974 #[derive(Copy, Clone)]
34975 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMeshShaderFeaturesNV.html>"]
34976 pub struct PhysicalDeviceMeshShaderFeaturesNV {
34977     pub s_type: StructureType,
34978     pub p_next: *mut c_void,
34979     pub task_shader: Bool32,
34980     pub mesh_shader: Bool32,
34981 }
34982 impl ::std::default::Default for PhysicalDeviceMeshShaderFeaturesNV {
34983     #[inline]
default() -> Self34984     fn default() -> Self {
34985         Self {
34986             s_type: Self::STRUCTURE_TYPE,
34987             p_next: ::std::ptr::null_mut(),
34988             task_shader: Bool32::default(),
34989             mesh_shader: Bool32::default(),
34990         }
34991     }
34992 }
34993 unsafe impl TaggedStructure for PhysicalDeviceMeshShaderFeaturesNV {
34994     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
34995 }
34996 impl PhysicalDeviceMeshShaderFeaturesNV {
builder<'a>() -> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a>34997     pub fn builder<'a>() -> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
34998         PhysicalDeviceMeshShaderFeaturesNVBuilder {
34999             inner: Self::default(),
35000             marker: ::std::marker::PhantomData,
35001         }
35002     }
35003 }
35004 #[repr(transparent)]
35005 pub struct PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
35006     inner: PhysicalDeviceMeshShaderFeaturesNV,
35007     marker: ::std::marker::PhantomData<&'a ()>,
35008 }
35009 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMeshShaderFeaturesNVBuilder<'_> {}
35010 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMeshShaderFeaturesNV {}
35011 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesNVBuilder<'_> {}
35012 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesNV {}
35013 impl<'a> ::std::ops::Deref for PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
35014     type Target = PhysicalDeviceMeshShaderFeaturesNV;
deref(&self) -> &Self::Target35015     fn deref(&self) -> &Self::Target {
35016         &self.inner
35017     }
35018 }
35019 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target35020     fn deref_mut(&mut self) -> &mut Self::Target {
35021         &mut self.inner
35022     }
35023 }
35024 impl<'a> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
35025     #[inline]
task_shader(mut self, task_shader: bool) -> Self35026     pub fn task_shader(mut self, task_shader: bool) -> Self {
35027         self.inner.task_shader = task_shader.into();
35028         self
35029     }
35030     #[inline]
mesh_shader(mut self, mesh_shader: bool) -> Self35031     pub fn mesh_shader(mut self, mesh_shader: bool) -> Self {
35032         self.inner.mesh_shader = mesh_shader.into();
35033         self
35034     }
35035     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35036     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35037     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMeshShaderFeaturesNV35038     pub fn build(self) -> PhysicalDeviceMeshShaderFeaturesNV {
35039         self.inner
35040     }
35041 }
35042 #[repr(C)]
35043 #[cfg_attr(feature = "debug", derive(Debug))]
35044 #[derive(Copy, Clone)]
35045 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMeshShaderPropertiesNV.html>"]
35046 pub struct PhysicalDeviceMeshShaderPropertiesNV {
35047     pub s_type: StructureType,
35048     pub p_next: *mut c_void,
35049     pub max_draw_mesh_tasks_count: u32,
35050     pub max_task_work_group_invocations: u32,
35051     pub max_task_work_group_size: [u32; 3],
35052     pub max_task_total_memory_size: u32,
35053     pub max_task_output_count: u32,
35054     pub max_mesh_work_group_invocations: u32,
35055     pub max_mesh_work_group_size: [u32; 3],
35056     pub max_mesh_total_memory_size: u32,
35057     pub max_mesh_output_vertices: u32,
35058     pub max_mesh_output_primitives: u32,
35059     pub max_mesh_multiview_view_count: u32,
35060     pub mesh_output_per_vertex_granularity: u32,
35061     pub mesh_output_per_primitive_granularity: u32,
35062 }
35063 impl ::std::default::Default for PhysicalDeviceMeshShaderPropertiesNV {
35064     #[inline]
default() -> Self35065     fn default() -> Self {
35066         Self {
35067             s_type: Self::STRUCTURE_TYPE,
35068             p_next: ::std::ptr::null_mut(),
35069             max_draw_mesh_tasks_count: u32::default(),
35070             max_task_work_group_invocations: u32::default(),
35071             max_task_work_group_size: unsafe { ::std::mem::zeroed() },
35072             max_task_total_memory_size: u32::default(),
35073             max_task_output_count: u32::default(),
35074             max_mesh_work_group_invocations: u32::default(),
35075             max_mesh_work_group_size: unsafe { ::std::mem::zeroed() },
35076             max_mesh_total_memory_size: u32::default(),
35077             max_mesh_output_vertices: u32::default(),
35078             max_mesh_output_primitives: u32::default(),
35079             max_mesh_multiview_view_count: u32::default(),
35080             mesh_output_per_vertex_granularity: u32::default(),
35081             mesh_output_per_primitive_granularity: u32::default(),
35082         }
35083     }
35084 }
35085 unsafe impl TaggedStructure for PhysicalDeviceMeshShaderPropertiesNV {
35086     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV;
35087 }
35088 impl PhysicalDeviceMeshShaderPropertiesNV {
builder<'a>() -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a>35089     pub fn builder<'a>() -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
35090         PhysicalDeviceMeshShaderPropertiesNVBuilder {
35091             inner: Self::default(),
35092             marker: ::std::marker::PhantomData,
35093         }
35094     }
35095 }
35096 #[repr(transparent)]
35097 pub struct PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
35098     inner: PhysicalDeviceMeshShaderPropertiesNV,
35099     marker: ::std::marker::PhantomData<&'a ()>,
35100 }
35101 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesNVBuilder<'_> {}
35102 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesNV {}
35103 impl<'a> ::std::ops::Deref for PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
35104     type Target = PhysicalDeviceMeshShaderPropertiesNV;
deref(&self) -> &Self::Target35105     fn deref(&self) -> &Self::Target {
35106         &self.inner
35107     }
35108 }
35109 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target35110     fn deref_mut(&mut self) -> &mut Self::Target {
35111         &mut self.inner
35112     }
35113 }
35114 impl<'a> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
35115     #[inline]
max_draw_mesh_tasks_count(mut self, max_draw_mesh_tasks_count: u32) -> Self35116     pub fn max_draw_mesh_tasks_count(mut self, max_draw_mesh_tasks_count: u32) -> Self {
35117         self.inner.max_draw_mesh_tasks_count = max_draw_mesh_tasks_count;
35118         self
35119     }
35120     #[inline]
max_task_work_group_invocations(mut self, max_task_work_group_invocations: u32) -> Self35121     pub fn max_task_work_group_invocations(mut self, max_task_work_group_invocations: u32) -> Self {
35122         self.inner.max_task_work_group_invocations = max_task_work_group_invocations;
35123         self
35124     }
35125     #[inline]
max_task_work_group_size(mut self, max_task_work_group_size: [u32; 3]) -> Self35126     pub fn max_task_work_group_size(mut self, max_task_work_group_size: [u32; 3]) -> Self {
35127         self.inner.max_task_work_group_size = max_task_work_group_size;
35128         self
35129     }
35130     #[inline]
max_task_total_memory_size(mut self, max_task_total_memory_size: u32) -> Self35131     pub fn max_task_total_memory_size(mut self, max_task_total_memory_size: u32) -> Self {
35132         self.inner.max_task_total_memory_size = max_task_total_memory_size;
35133         self
35134     }
35135     #[inline]
max_task_output_count(mut self, max_task_output_count: u32) -> Self35136     pub fn max_task_output_count(mut self, max_task_output_count: u32) -> Self {
35137         self.inner.max_task_output_count = max_task_output_count;
35138         self
35139     }
35140     #[inline]
max_mesh_work_group_invocations(mut self, max_mesh_work_group_invocations: u32) -> Self35141     pub fn max_mesh_work_group_invocations(mut self, max_mesh_work_group_invocations: u32) -> Self {
35142         self.inner.max_mesh_work_group_invocations = max_mesh_work_group_invocations;
35143         self
35144     }
35145     #[inline]
max_mesh_work_group_size(mut self, max_mesh_work_group_size: [u32; 3]) -> Self35146     pub fn max_mesh_work_group_size(mut self, max_mesh_work_group_size: [u32; 3]) -> Self {
35147         self.inner.max_mesh_work_group_size = max_mesh_work_group_size;
35148         self
35149     }
35150     #[inline]
max_mesh_total_memory_size(mut self, max_mesh_total_memory_size: u32) -> Self35151     pub fn max_mesh_total_memory_size(mut self, max_mesh_total_memory_size: u32) -> Self {
35152         self.inner.max_mesh_total_memory_size = max_mesh_total_memory_size;
35153         self
35154     }
35155     #[inline]
max_mesh_output_vertices(mut self, max_mesh_output_vertices: u32) -> Self35156     pub fn max_mesh_output_vertices(mut self, max_mesh_output_vertices: u32) -> Self {
35157         self.inner.max_mesh_output_vertices = max_mesh_output_vertices;
35158         self
35159     }
35160     #[inline]
max_mesh_output_primitives(mut self, max_mesh_output_primitives: u32) -> Self35161     pub fn max_mesh_output_primitives(mut self, max_mesh_output_primitives: u32) -> Self {
35162         self.inner.max_mesh_output_primitives = max_mesh_output_primitives;
35163         self
35164     }
35165     #[inline]
max_mesh_multiview_view_count(mut self, max_mesh_multiview_view_count: u32) -> Self35166     pub fn max_mesh_multiview_view_count(mut self, max_mesh_multiview_view_count: u32) -> Self {
35167         self.inner.max_mesh_multiview_view_count = max_mesh_multiview_view_count;
35168         self
35169     }
35170     #[inline]
mesh_output_per_vertex_granularity( mut self, mesh_output_per_vertex_granularity: u32, ) -> Self35171     pub fn mesh_output_per_vertex_granularity(
35172         mut self,
35173         mesh_output_per_vertex_granularity: u32,
35174     ) -> Self {
35175         self.inner.mesh_output_per_vertex_granularity = mesh_output_per_vertex_granularity;
35176         self
35177     }
35178     #[inline]
mesh_output_per_primitive_granularity( mut self, mesh_output_per_primitive_granularity: u32, ) -> Self35179     pub fn mesh_output_per_primitive_granularity(
35180         mut self,
35181         mesh_output_per_primitive_granularity: u32,
35182     ) -> Self {
35183         self.inner.mesh_output_per_primitive_granularity = mesh_output_per_primitive_granularity;
35184         self
35185     }
35186     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35187     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35188     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMeshShaderPropertiesNV35189     pub fn build(self) -> PhysicalDeviceMeshShaderPropertiesNV {
35190         self.inner
35191     }
35192 }
35193 #[repr(C)]
35194 #[cfg_attr(feature = "debug", derive(Debug))]
35195 #[derive(Copy, Clone, Default)]
35196 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrawMeshTasksIndirectCommandNV.html>"]
35197 pub struct DrawMeshTasksIndirectCommandNV {
35198     pub task_count: u32,
35199     pub first_task: u32,
35200 }
35201 impl DrawMeshTasksIndirectCommandNV {
builder<'a>() -> DrawMeshTasksIndirectCommandNVBuilder<'a>35202     pub fn builder<'a>() -> DrawMeshTasksIndirectCommandNVBuilder<'a> {
35203         DrawMeshTasksIndirectCommandNVBuilder {
35204             inner: Self::default(),
35205             marker: ::std::marker::PhantomData,
35206         }
35207     }
35208 }
35209 #[repr(transparent)]
35210 pub struct DrawMeshTasksIndirectCommandNVBuilder<'a> {
35211     inner: DrawMeshTasksIndirectCommandNV,
35212     marker: ::std::marker::PhantomData<&'a ()>,
35213 }
35214 impl<'a> ::std::ops::Deref for DrawMeshTasksIndirectCommandNVBuilder<'a> {
35215     type Target = DrawMeshTasksIndirectCommandNV;
deref(&self) -> &Self::Target35216     fn deref(&self) -> &Self::Target {
35217         &self.inner
35218     }
35219 }
35220 impl<'a> ::std::ops::DerefMut for DrawMeshTasksIndirectCommandNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target35221     fn deref_mut(&mut self) -> &mut Self::Target {
35222         &mut self.inner
35223     }
35224 }
35225 impl<'a> DrawMeshTasksIndirectCommandNVBuilder<'a> {
35226     #[inline]
task_count(mut self, task_count: u32) -> Self35227     pub fn task_count(mut self, task_count: u32) -> Self {
35228         self.inner.task_count = task_count;
35229         self
35230     }
35231     #[inline]
first_task(mut self, first_task: u32) -> Self35232     pub fn first_task(mut self, first_task: u32) -> Self {
35233         self.inner.first_task = first_task;
35234         self
35235     }
35236     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35237     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35238     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DrawMeshTasksIndirectCommandNV35239     pub fn build(self) -> DrawMeshTasksIndirectCommandNV {
35240         self.inner
35241     }
35242 }
35243 #[repr(C)]
35244 #[cfg_attr(feature = "debug", derive(Debug))]
35245 #[derive(Copy, Clone)]
35246 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMeshShaderFeaturesEXT.html>"]
35247 pub struct PhysicalDeviceMeshShaderFeaturesEXT {
35248     pub s_type: StructureType,
35249     pub p_next: *mut c_void,
35250     pub task_shader: Bool32,
35251     pub mesh_shader: Bool32,
35252     pub multiview_mesh_shader: Bool32,
35253     pub primitive_fragment_shading_rate_mesh_shader: Bool32,
35254     pub mesh_shader_queries: Bool32,
35255 }
35256 impl ::std::default::Default for PhysicalDeviceMeshShaderFeaturesEXT {
35257     #[inline]
default() -> Self35258     fn default() -> Self {
35259         Self {
35260             s_type: Self::STRUCTURE_TYPE,
35261             p_next: ::std::ptr::null_mut(),
35262             task_shader: Bool32::default(),
35263             mesh_shader: Bool32::default(),
35264             multiview_mesh_shader: Bool32::default(),
35265             primitive_fragment_shading_rate_mesh_shader: Bool32::default(),
35266             mesh_shader_queries: Bool32::default(),
35267         }
35268     }
35269 }
35270 unsafe impl TaggedStructure for PhysicalDeviceMeshShaderFeaturesEXT {
35271     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
35272 }
35273 impl PhysicalDeviceMeshShaderFeaturesEXT {
builder<'a>() -> PhysicalDeviceMeshShaderFeaturesEXTBuilder<'a>35274     pub fn builder<'a>() -> PhysicalDeviceMeshShaderFeaturesEXTBuilder<'a> {
35275         PhysicalDeviceMeshShaderFeaturesEXTBuilder {
35276             inner: Self::default(),
35277             marker: ::std::marker::PhantomData,
35278         }
35279     }
35280 }
35281 #[repr(transparent)]
35282 pub struct PhysicalDeviceMeshShaderFeaturesEXTBuilder<'a> {
35283     inner: PhysicalDeviceMeshShaderFeaturesEXT,
35284     marker: ::std::marker::PhantomData<&'a ()>,
35285 }
35286 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMeshShaderFeaturesEXTBuilder<'_> {}
35287 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMeshShaderFeaturesEXT {}
35288 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesEXTBuilder<'_> {}
35289 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesEXT {}
35290 impl<'a> ::std::ops::Deref for PhysicalDeviceMeshShaderFeaturesEXTBuilder<'a> {
35291     type Target = PhysicalDeviceMeshShaderFeaturesEXT;
deref(&self) -> &Self::Target35292     fn deref(&self) -> &Self::Target {
35293         &self.inner
35294     }
35295 }
35296 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMeshShaderFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target35297     fn deref_mut(&mut self) -> &mut Self::Target {
35298         &mut self.inner
35299     }
35300 }
35301 impl<'a> PhysicalDeviceMeshShaderFeaturesEXTBuilder<'a> {
35302     #[inline]
task_shader(mut self, task_shader: bool) -> Self35303     pub fn task_shader(mut self, task_shader: bool) -> Self {
35304         self.inner.task_shader = task_shader.into();
35305         self
35306     }
35307     #[inline]
mesh_shader(mut self, mesh_shader: bool) -> Self35308     pub fn mesh_shader(mut self, mesh_shader: bool) -> Self {
35309         self.inner.mesh_shader = mesh_shader.into();
35310         self
35311     }
35312     #[inline]
multiview_mesh_shader(mut self, multiview_mesh_shader: bool) -> Self35313     pub fn multiview_mesh_shader(mut self, multiview_mesh_shader: bool) -> Self {
35314         self.inner.multiview_mesh_shader = multiview_mesh_shader.into();
35315         self
35316     }
35317     #[inline]
primitive_fragment_shading_rate_mesh_shader( mut self, primitive_fragment_shading_rate_mesh_shader: bool, ) -> Self35318     pub fn primitive_fragment_shading_rate_mesh_shader(
35319         mut self,
35320         primitive_fragment_shading_rate_mesh_shader: bool,
35321     ) -> Self {
35322         self.inner.primitive_fragment_shading_rate_mesh_shader =
35323             primitive_fragment_shading_rate_mesh_shader.into();
35324         self
35325     }
35326     #[inline]
mesh_shader_queries(mut self, mesh_shader_queries: bool) -> Self35327     pub fn mesh_shader_queries(mut self, mesh_shader_queries: bool) -> Self {
35328         self.inner.mesh_shader_queries = mesh_shader_queries.into();
35329         self
35330     }
35331     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35332     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35333     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMeshShaderFeaturesEXT35334     pub fn build(self) -> PhysicalDeviceMeshShaderFeaturesEXT {
35335         self.inner
35336     }
35337 }
35338 #[repr(C)]
35339 #[cfg_attr(feature = "debug", derive(Debug))]
35340 #[derive(Copy, Clone)]
35341 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMeshShaderPropertiesEXT.html>"]
35342 pub struct PhysicalDeviceMeshShaderPropertiesEXT {
35343     pub s_type: StructureType,
35344     pub p_next: *mut c_void,
35345     pub max_task_work_group_total_count: u32,
35346     pub max_task_work_group_count: [u32; 3],
35347     pub max_task_work_group_invocations: u32,
35348     pub max_task_work_group_size: [u32; 3],
35349     pub max_task_payload_size: u32,
35350     pub max_task_shared_memory_size: u32,
35351     pub max_task_payload_and_shared_memory_size: u32,
35352     pub max_mesh_work_group_total_count: u32,
35353     pub max_mesh_work_group_count: [u32; 3],
35354     pub max_mesh_work_group_invocations: u32,
35355     pub max_mesh_work_group_size: [u32; 3],
35356     pub max_mesh_shared_memory_size: u32,
35357     pub max_mesh_payload_and_shared_memory_size: u32,
35358     pub max_mesh_output_memory_size: u32,
35359     pub max_mesh_payload_and_output_memory_size: u32,
35360     pub max_mesh_output_components: u32,
35361     pub max_mesh_output_vertices: u32,
35362     pub max_mesh_output_primitives: u32,
35363     pub max_mesh_output_layers: u32,
35364     pub max_mesh_multiview_view_count: u32,
35365     pub mesh_output_per_vertex_granularity: u32,
35366     pub mesh_output_per_primitive_granularity: u32,
35367     pub max_preferred_task_work_group_invocations: u32,
35368     pub max_preferred_mesh_work_group_invocations: u32,
35369     pub prefers_local_invocation_vertex_output: Bool32,
35370     pub prefers_local_invocation_primitive_output: Bool32,
35371     pub prefers_compact_vertex_output: Bool32,
35372     pub prefers_compact_primitive_output: Bool32,
35373 }
35374 impl ::std::default::Default for PhysicalDeviceMeshShaderPropertiesEXT {
35375     #[inline]
default() -> Self35376     fn default() -> Self {
35377         Self {
35378             s_type: Self::STRUCTURE_TYPE,
35379             p_next: ::std::ptr::null_mut(),
35380             max_task_work_group_total_count: u32::default(),
35381             max_task_work_group_count: unsafe { ::std::mem::zeroed() },
35382             max_task_work_group_invocations: u32::default(),
35383             max_task_work_group_size: unsafe { ::std::mem::zeroed() },
35384             max_task_payload_size: u32::default(),
35385             max_task_shared_memory_size: u32::default(),
35386             max_task_payload_and_shared_memory_size: u32::default(),
35387             max_mesh_work_group_total_count: u32::default(),
35388             max_mesh_work_group_count: unsafe { ::std::mem::zeroed() },
35389             max_mesh_work_group_invocations: u32::default(),
35390             max_mesh_work_group_size: unsafe { ::std::mem::zeroed() },
35391             max_mesh_shared_memory_size: u32::default(),
35392             max_mesh_payload_and_shared_memory_size: u32::default(),
35393             max_mesh_output_memory_size: u32::default(),
35394             max_mesh_payload_and_output_memory_size: u32::default(),
35395             max_mesh_output_components: u32::default(),
35396             max_mesh_output_vertices: u32::default(),
35397             max_mesh_output_primitives: u32::default(),
35398             max_mesh_output_layers: u32::default(),
35399             max_mesh_multiview_view_count: u32::default(),
35400             mesh_output_per_vertex_granularity: u32::default(),
35401             mesh_output_per_primitive_granularity: u32::default(),
35402             max_preferred_task_work_group_invocations: u32::default(),
35403             max_preferred_mesh_work_group_invocations: u32::default(),
35404             prefers_local_invocation_vertex_output: Bool32::default(),
35405             prefers_local_invocation_primitive_output: Bool32::default(),
35406             prefers_compact_vertex_output: Bool32::default(),
35407             prefers_compact_primitive_output: Bool32::default(),
35408         }
35409     }
35410 }
35411 unsafe impl TaggedStructure for PhysicalDeviceMeshShaderPropertiesEXT {
35412     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT;
35413 }
35414 impl PhysicalDeviceMeshShaderPropertiesEXT {
builder<'a>() -> PhysicalDeviceMeshShaderPropertiesEXTBuilder<'a>35415     pub fn builder<'a>() -> PhysicalDeviceMeshShaderPropertiesEXTBuilder<'a> {
35416         PhysicalDeviceMeshShaderPropertiesEXTBuilder {
35417             inner: Self::default(),
35418             marker: ::std::marker::PhantomData,
35419         }
35420     }
35421 }
35422 #[repr(transparent)]
35423 pub struct PhysicalDeviceMeshShaderPropertiesEXTBuilder<'a> {
35424     inner: PhysicalDeviceMeshShaderPropertiesEXT,
35425     marker: ::std::marker::PhantomData<&'a ()>,
35426 }
35427 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesEXTBuilder<'_> {}
35428 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesEXT {}
35429 impl<'a> ::std::ops::Deref for PhysicalDeviceMeshShaderPropertiesEXTBuilder<'a> {
35430     type Target = PhysicalDeviceMeshShaderPropertiesEXT;
deref(&self) -> &Self::Target35431     fn deref(&self) -> &Self::Target {
35432         &self.inner
35433     }
35434 }
35435 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMeshShaderPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target35436     fn deref_mut(&mut self) -> &mut Self::Target {
35437         &mut self.inner
35438     }
35439 }
35440 impl<'a> PhysicalDeviceMeshShaderPropertiesEXTBuilder<'a> {
35441     #[inline]
max_task_work_group_total_count(mut self, max_task_work_group_total_count: u32) -> Self35442     pub fn max_task_work_group_total_count(mut self, max_task_work_group_total_count: u32) -> Self {
35443         self.inner.max_task_work_group_total_count = max_task_work_group_total_count;
35444         self
35445     }
35446     #[inline]
max_task_work_group_count(mut self, max_task_work_group_count: [u32; 3]) -> Self35447     pub fn max_task_work_group_count(mut self, max_task_work_group_count: [u32; 3]) -> Self {
35448         self.inner.max_task_work_group_count = max_task_work_group_count;
35449         self
35450     }
35451     #[inline]
max_task_work_group_invocations(mut self, max_task_work_group_invocations: u32) -> Self35452     pub fn max_task_work_group_invocations(mut self, max_task_work_group_invocations: u32) -> Self {
35453         self.inner.max_task_work_group_invocations = max_task_work_group_invocations;
35454         self
35455     }
35456     #[inline]
max_task_work_group_size(mut self, max_task_work_group_size: [u32; 3]) -> Self35457     pub fn max_task_work_group_size(mut self, max_task_work_group_size: [u32; 3]) -> Self {
35458         self.inner.max_task_work_group_size = max_task_work_group_size;
35459         self
35460     }
35461     #[inline]
max_task_payload_size(mut self, max_task_payload_size: u32) -> Self35462     pub fn max_task_payload_size(mut self, max_task_payload_size: u32) -> Self {
35463         self.inner.max_task_payload_size = max_task_payload_size;
35464         self
35465     }
35466     #[inline]
max_task_shared_memory_size(mut self, max_task_shared_memory_size: u32) -> Self35467     pub fn max_task_shared_memory_size(mut self, max_task_shared_memory_size: u32) -> Self {
35468         self.inner.max_task_shared_memory_size = max_task_shared_memory_size;
35469         self
35470     }
35471     #[inline]
max_task_payload_and_shared_memory_size( mut self, max_task_payload_and_shared_memory_size: u32, ) -> Self35472     pub fn max_task_payload_and_shared_memory_size(
35473         mut self,
35474         max_task_payload_and_shared_memory_size: u32,
35475     ) -> Self {
35476         self.inner.max_task_payload_and_shared_memory_size =
35477             max_task_payload_and_shared_memory_size;
35478         self
35479     }
35480     #[inline]
max_mesh_work_group_total_count(mut self, max_mesh_work_group_total_count: u32) -> Self35481     pub fn max_mesh_work_group_total_count(mut self, max_mesh_work_group_total_count: u32) -> Self {
35482         self.inner.max_mesh_work_group_total_count = max_mesh_work_group_total_count;
35483         self
35484     }
35485     #[inline]
max_mesh_work_group_count(mut self, max_mesh_work_group_count: [u32; 3]) -> Self35486     pub fn max_mesh_work_group_count(mut self, max_mesh_work_group_count: [u32; 3]) -> Self {
35487         self.inner.max_mesh_work_group_count = max_mesh_work_group_count;
35488         self
35489     }
35490     #[inline]
max_mesh_work_group_invocations(mut self, max_mesh_work_group_invocations: u32) -> Self35491     pub fn max_mesh_work_group_invocations(mut self, max_mesh_work_group_invocations: u32) -> Self {
35492         self.inner.max_mesh_work_group_invocations = max_mesh_work_group_invocations;
35493         self
35494     }
35495     #[inline]
max_mesh_work_group_size(mut self, max_mesh_work_group_size: [u32; 3]) -> Self35496     pub fn max_mesh_work_group_size(mut self, max_mesh_work_group_size: [u32; 3]) -> Self {
35497         self.inner.max_mesh_work_group_size = max_mesh_work_group_size;
35498         self
35499     }
35500     #[inline]
max_mesh_shared_memory_size(mut self, max_mesh_shared_memory_size: u32) -> Self35501     pub fn max_mesh_shared_memory_size(mut self, max_mesh_shared_memory_size: u32) -> Self {
35502         self.inner.max_mesh_shared_memory_size = max_mesh_shared_memory_size;
35503         self
35504     }
35505     #[inline]
max_mesh_payload_and_shared_memory_size( mut self, max_mesh_payload_and_shared_memory_size: u32, ) -> Self35506     pub fn max_mesh_payload_and_shared_memory_size(
35507         mut self,
35508         max_mesh_payload_and_shared_memory_size: u32,
35509     ) -> Self {
35510         self.inner.max_mesh_payload_and_shared_memory_size =
35511             max_mesh_payload_and_shared_memory_size;
35512         self
35513     }
35514     #[inline]
max_mesh_output_memory_size(mut self, max_mesh_output_memory_size: u32) -> Self35515     pub fn max_mesh_output_memory_size(mut self, max_mesh_output_memory_size: u32) -> Self {
35516         self.inner.max_mesh_output_memory_size = max_mesh_output_memory_size;
35517         self
35518     }
35519     #[inline]
max_mesh_payload_and_output_memory_size( mut self, max_mesh_payload_and_output_memory_size: u32, ) -> Self35520     pub fn max_mesh_payload_and_output_memory_size(
35521         mut self,
35522         max_mesh_payload_and_output_memory_size: u32,
35523     ) -> Self {
35524         self.inner.max_mesh_payload_and_output_memory_size =
35525             max_mesh_payload_and_output_memory_size;
35526         self
35527     }
35528     #[inline]
max_mesh_output_components(mut self, max_mesh_output_components: u32) -> Self35529     pub fn max_mesh_output_components(mut self, max_mesh_output_components: u32) -> Self {
35530         self.inner.max_mesh_output_components = max_mesh_output_components;
35531         self
35532     }
35533     #[inline]
max_mesh_output_vertices(mut self, max_mesh_output_vertices: u32) -> Self35534     pub fn max_mesh_output_vertices(mut self, max_mesh_output_vertices: u32) -> Self {
35535         self.inner.max_mesh_output_vertices = max_mesh_output_vertices;
35536         self
35537     }
35538     #[inline]
max_mesh_output_primitives(mut self, max_mesh_output_primitives: u32) -> Self35539     pub fn max_mesh_output_primitives(mut self, max_mesh_output_primitives: u32) -> Self {
35540         self.inner.max_mesh_output_primitives = max_mesh_output_primitives;
35541         self
35542     }
35543     #[inline]
max_mesh_output_layers(mut self, max_mesh_output_layers: u32) -> Self35544     pub fn max_mesh_output_layers(mut self, max_mesh_output_layers: u32) -> Self {
35545         self.inner.max_mesh_output_layers = max_mesh_output_layers;
35546         self
35547     }
35548     #[inline]
max_mesh_multiview_view_count(mut self, max_mesh_multiview_view_count: u32) -> Self35549     pub fn max_mesh_multiview_view_count(mut self, max_mesh_multiview_view_count: u32) -> Self {
35550         self.inner.max_mesh_multiview_view_count = max_mesh_multiview_view_count;
35551         self
35552     }
35553     #[inline]
mesh_output_per_vertex_granularity( mut self, mesh_output_per_vertex_granularity: u32, ) -> Self35554     pub fn mesh_output_per_vertex_granularity(
35555         mut self,
35556         mesh_output_per_vertex_granularity: u32,
35557     ) -> Self {
35558         self.inner.mesh_output_per_vertex_granularity = mesh_output_per_vertex_granularity;
35559         self
35560     }
35561     #[inline]
mesh_output_per_primitive_granularity( mut self, mesh_output_per_primitive_granularity: u32, ) -> Self35562     pub fn mesh_output_per_primitive_granularity(
35563         mut self,
35564         mesh_output_per_primitive_granularity: u32,
35565     ) -> Self {
35566         self.inner.mesh_output_per_primitive_granularity = mesh_output_per_primitive_granularity;
35567         self
35568     }
35569     #[inline]
max_preferred_task_work_group_invocations( mut self, max_preferred_task_work_group_invocations: u32, ) -> Self35570     pub fn max_preferred_task_work_group_invocations(
35571         mut self,
35572         max_preferred_task_work_group_invocations: u32,
35573     ) -> Self {
35574         self.inner.max_preferred_task_work_group_invocations =
35575             max_preferred_task_work_group_invocations;
35576         self
35577     }
35578     #[inline]
max_preferred_mesh_work_group_invocations( mut self, max_preferred_mesh_work_group_invocations: u32, ) -> Self35579     pub fn max_preferred_mesh_work_group_invocations(
35580         mut self,
35581         max_preferred_mesh_work_group_invocations: u32,
35582     ) -> Self {
35583         self.inner.max_preferred_mesh_work_group_invocations =
35584             max_preferred_mesh_work_group_invocations;
35585         self
35586     }
35587     #[inline]
prefers_local_invocation_vertex_output( mut self, prefers_local_invocation_vertex_output: bool, ) -> Self35588     pub fn prefers_local_invocation_vertex_output(
35589         mut self,
35590         prefers_local_invocation_vertex_output: bool,
35591     ) -> Self {
35592         self.inner.prefers_local_invocation_vertex_output =
35593             prefers_local_invocation_vertex_output.into();
35594         self
35595     }
35596     #[inline]
prefers_local_invocation_primitive_output( mut self, prefers_local_invocation_primitive_output: bool, ) -> Self35597     pub fn prefers_local_invocation_primitive_output(
35598         mut self,
35599         prefers_local_invocation_primitive_output: bool,
35600     ) -> Self {
35601         self.inner.prefers_local_invocation_primitive_output =
35602             prefers_local_invocation_primitive_output.into();
35603         self
35604     }
35605     #[inline]
prefers_compact_vertex_output(mut self, prefers_compact_vertex_output: bool) -> Self35606     pub fn prefers_compact_vertex_output(mut self, prefers_compact_vertex_output: bool) -> Self {
35607         self.inner.prefers_compact_vertex_output = prefers_compact_vertex_output.into();
35608         self
35609     }
35610     #[inline]
prefers_compact_primitive_output( mut self, prefers_compact_primitive_output: bool, ) -> Self35611     pub fn prefers_compact_primitive_output(
35612         mut self,
35613         prefers_compact_primitive_output: bool,
35614     ) -> Self {
35615         self.inner.prefers_compact_primitive_output = prefers_compact_primitive_output.into();
35616         self
35617     }
35618     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35619     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35620     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMeshShaderPropertiesEXT35621     pub fn build(self) -> PhysicalDeviceMeshShaderPropertiesEXT {
35622         self.inner
35623     }
35624 }
35625 #[repr(C)]
35626 #[cfg_attr(feature = "debug", derive(Debug))]
35627 #[derive(Copy, Clone, Default)]
35628 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrawMeshTasksIndirectCommandEXT.html>"]
35629 pub struct DrawMeshTasksIndirectCommandEXT {
35630     pub group_count_x: u32,
35631     pub group_count_y: u32,
35632     pub group_count_z: u32,
35633 }
35634 impl DrawMeshTasksIndirectCommandEXT {
builder<'a>() -> DrawMeshTasksIndirectCommandEXTBuilder<'a>35635     pub fn builder<'a>() -> DrawMeshTasksIndirectCommandEXTBuilder<'a> {
35636         DrawMeshTasksIndirectCommandEXTBuilder {
35637             inner: Self::default(),
35638             marker: ::std::marker::PhantomData,
35639         }
35640     }
35641 }
35642 #[repr(transparent)]
35643 pub struct DrawMeshTasksIndirectCommandEXTBuilder<'a> {
35644     inner: DrawMeshTasksIndirectCommandEXT,
35645     marker: ::std::marker::PhantomData<&'a ()>,
35646 }
35647 impl<'a> ::std::ops::Deref for DrawMeshTasksIndirectCommandEXTBuilder<'a> {
35648     type Target = DrawMeshTasksIndirectCommandEXT;
deref(&self) -> &Self::Target35649     fn deref(&self) -> &Self::Target {
35650         &self.inner
35651     }
35652 }
35653 impl<'a> ::std::ops::DerefMut for DrawMeshTasksIndirectCommandEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target35654     fn deref_mut(&mut self) -> &mut Self::Target {
35655         &mut self.inner
35656     }
35657 }
35658 impl<'a> DrawMeshTasksIndirectCommandEXTBuilder<'a> {
35659     #[inline]
group_count_x(mut self, group_count_x: u32) -> Self35660     pub fn group_count_x(mut self, group_count_x: u32) -> Self {
35661         self.inner.group_count_x = group_count_x;
35662         self
35663     }
35664     #[inline]
group_count_y(mut self, group_count_y: u32) -> Self35665     pub fn group_count_y(mut self, group_count_y: u32) -> Self {
35666         self.inner.group_count_y = group_count_y;
35667         self
35668     }
35669     #[inline]
group_count_z(mut self, group_count_z: u32) -> Self35670     pub fn group_count_z(mut self, group_count_z: u32) -> Self {
35671         self.inner.group_count_z = group_count_z;
35672         self
35673     }
35674     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35675     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35676     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DrawMeshTasksIndirectCommandEXT35677     pub fn build(self) -> DrawMeshTasksIndirectCommandEXT {
35678         self.inner
35679     }
35680 }
35681 #[repr(C)]
35682 #[cfg_attr(feature = "debug", derive(Debug))]
35683 #[derive(Copy, Clone)]
35684 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRayTracingShaderGroupCreateInfoNV.html>"]
35685 pub struct RayTracingShaderGroupCreateInfoNV {
35686     pub s_type: StructureType,
35687     pub p_next: *const c_void,
35688     pub ty: RayTracingShaderGroupTypeKHR,
35689     pub general_shader: u32,
35690     pub closest_hit_shader: u32,
35691     pub any_hit_shader: u32,
35692     pub intersection_shader: u32,
35693 }
35694 impl ::std::default::Default for RayTracingShaderGroupCreateInfoNV {
35695     #[inline]
default() -> Self35696     fn default() -> Self {
35697         Self {
35698             s_type: Self::STRUCTURE_TYPE,
35699             p_next: ::std::ptr::null(),
35700             ty: RayTracingShaderGroupTypeKHR::default(),
35701             general_shader: u32::default(),
35702             closest_hit_shader: u32::default(),
35703             any_hit_shader: u32::default(),
35704             intersection_shader: u32::default(),
35705         }
35706     }
35707 }
35708 unsafe impl TaggedStructure for RayTracingShaderGroupCreateInfoNV {
35709     const STRUCTURE_TYPE: StructureType = StructureType::RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV;
35710 }
35711 impl RayTracingShaderGroupCreateInfoNV {
builder<'a>() -> RayTracingShaderGroupCreateInfoNVBuilder<'a>35712     pub fn builder<'a>() -> RayTracingShaderGroupCreateInfoNVBuilder<'a> {
35713         RayTracingShaderGroupCreateInfoNVBuilder {
35714             inner: Self::default(),
35715             marker: ::std::marker::PhantomData,
35716         }
35717     }
35718 }
35719 #[repr(transparent)]
35720 pub struct RayTracingShaderGroupCreateInfoNVBuilder<'a> {
35721     inner: RayTracingShaderGroupCreateInfoNV,
35722     marker: ::std::marker::PhantomData<&'a ()>,
35723 }
35724 impl<'a> ::std::ops::Deref for RayTracingShaderGroupCreateInfoNVBuilder<'a> {
35725     type Target = RayTracingShaderGroupCreateInfoNV;
deref(&self) -> &Self::Target35726     fn deref(&self) -> &Self::Target {
35727         &self.inner
35728     }
35729 }
35730 impl<'a> ::std::ops::DerefMut for RayTracingShaderGroupCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target35731     fn deref_mut(&mut self) -> &mut Self::Target {
35732         &mut self.inner
35733     }
35734 }
35735 impl<'a> RayTracingShaderGroupCreateInfoNVBuilder<'a> {
35736     #[inline]
ty(mut self, ty: RayTracingShaderGroupTypeKHR) -> Self35737     pub fn ty(mut self, ty: RayTracingShaderGroupTypeKHR) -> Self {
35738         self.inner.ty = ty;
35739         self
35740     }
35741     #[inline]
general_shader(mut self, general_shader: u32) -> Self35742     pub fn general_shader(mut self, general_shader: u32) -> Self {
35743         self.inner.general_shader = general_shader;
35744         self
35745     }
35746     #[inline]
closest_hit_shader(mut self, closest_hit_shader: u32) -> Self35747     pub fn closest_hit_shader(mut self, closest_hit_shader: u32) -> Self {
35748         self.inner.closest_hit_shader = closest_hit_shader;
35749         self
35750     }
35751     #[inline]
any_hit_shader(mut self, any_hit_shader: u32) -> Self35752     pub fn any_hit_shader(mut self, any_hit_shader: u32) -> Self {
35753         self.inner.any_hit_shader = any_hit_shader;
35754         self
35755     }
35756     #[inline]
intersection_shader(mut self, intersection_shader: u32) -> Self35757     pub fn intersection_shader(mut self, intersection_shader: u32) -> Self {
35758         self.inner.intersection_shader = intersection_shader;
35759         self
35760     }
35761     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35762     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35763     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RayTracingShaderGroupCreateInfoNV35764     pub fn build(self) -> RayTracingShaderGroupCreateInfoNV {
35765         self.inner
35766     }
35767 }
35768 #[repr(C)]
35769 #[cfg_attr(feature = "debug", derive(Debug))]
35770 #[derive(Copy, Clone)]
35771 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRayTracingShaderGroupCreateInfoKHR.html>"]
35772 pub struct RayTracingShaderGroupCreateInfoKHR {
35773     pub s_type: StructureType,
35774     pub p_next: *const c_void,
35775     pub ty: RayTracingShaderGroupTypeKHR,
35776     pub general_shader: u32,
35777     pub closest_hit_shader: u32,
35778     pub any_hit_shader: u32,
35779     pub intersection_shader: u32,
35780     pub p_shader_group_capture_replay_handle: *const c_void,
35781 }
35782 impl ::std::default::Default for RayTracingShaderGroupCreateInfoKHR {
35783     #[inline]
default() -> Self35784     fn default() -> Self {
35785         Self {
35786             s_type: Self::STRUCTURE_TYPE,
35787             p_next: ::std::ptr::null(),
35788             ty: RayTracingShaderGroupTypeKHR::default(),
35789             general_shader: u32::default(),
35790             closest_hit_shader: u32::default(),
35791             any_hit_shader: u32::default(),
35792             intersection_shader: u32::default(),
35793             p_shader_group_capture_replay_handle: ::std::ptr::null(),
35794         }
35795     }
35796 }
35797 unsafe impl TaggedStructure for RayTracingShaderGroupCreateInfoKHR {
35798     const STRUCTURE_TYPE: StructureType = StructureType::RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR;
35799 }
35800 impl RayTracingShaderGroupCreateInfoKHR {
builder<'a>() -> RayTracingShaderGroupCreateInfoKHRBuilder<'a>35801     pub fn builder<'a>() -> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
35802         RayTracingShaderGroupCreateInfoKHRBuilder {
35803             inner: Self::default(),
35804             marker: ::std::marker::PhantomData,
35805         }
35806     }
35807 }
35808 #[repr(transparent)]
35809 pub struct RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
35810     inner: RayTracingShaderGroupCreateInfoKHR,
35811     marker: ::std::marker::PhantomData<&'a ()>,
35812 }
35813 impl<'a> ::std::ops::Deref for RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
35814     type Target = RayTracingShaderGroupCreateInfoKHR;
deref(&self) -> &Self::Target35815     fn deref(&self) -> &Self::Target {
35816         &self.inner
35817     }
35818 }
35819 impl<'a> ::std::ops::DerefMut for RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target35820     fn deref_mut(&mut self) -> &mut Self::Target {
35821         &mut self.inner
35822     }
35823 }
35824 impl<'a> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
35825     #[inline]
ty(mut self, ty: RayTracingShaderGroupTypeKHR) -> Self35826     pub fn ty(mut self, ty: RayTracingShaderGroupTypeKHR) -> Self {
35827         self.inner.ty = ty;
35828         self
35829     }
35830     #[inline]
general_shader(mut self, general_shader: u32) -> Self35831     pub fn general_shader(mut self, general_shader: u32) -> Self {
35832         self.inner.general_shader = general_shader;
35833         self
35834     }
35835     #[inline]
closest_hit_shader(mut self, closest_hit_shader: u32) -> Self35836     pub fn closest_hit_shader(mut self, closest_hit_shader: u32) -> Self {
35837         self.inner.closest_hit_shader = closest_hit_shader;
35838         self
35839     }
35840     #[inline]
any_hit_shader(mut self, any_hit_shader: u32) -> Self35841     pub fn any_hit_shader(mut self, any_hit_shader: u32) -> Self {
35842         self.inner.any_hit_shader = any_hit_shader;
35843         self
35844     }
35845     #[inline]
intersection_shader(mut self, intersection_shader: u32) -> Self35846     pub fn intersection_shader(mut self, intersection_shader: u32) -> Self {
35847         self.inner.intersection_shader = intersection_shader;
35848         self
35849     }
35850     #[inline]
shader_group_capture_replay_handle( mut self, shader_group_capture_replay_handle: *const c_void, ) -> Self35851     pub fn shader_group_capture_replay_handle(
35852         mut self,
35853         shader_group_capture_replay_handle: *const c_void,
35854     ) -> Self {
35855         self.inner.p_shader_group_capture_replay_handle = shader_group_capture_replay_handle;
35856         self
35857     }
35858     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35859     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35860     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RayTracingShaderGroupCreateInfoKHR35861     pub fn build(self) -> RayTracingShaderGroupCreateInfoKHR {
35862         self.inner
35863     }
35864 }
35865 #[repr(C)]
35866 #[cfg_attr(feature = "debug", derive(Debug))]
35867 #[derive(Copy, Clone)]
35868 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRayTracingPipelineCreateInfoNV.html>"]
35869 pub struct RayTracingPipelineCreateInfoNV {
35870     pub s_type: StructureType,
35871     pub p_next: *const c_void,
35872     pub flags: PipelineCreateFlags,
35873     pub stage_count: u32,
35874     pub p_stages: *const PipelineShaderStageCreateInfo,
35875     pub group_count: u32,
35876     pub p_groups: *const RayTracingShaderGroupCreateInfoNV,
35877     pub max_recursion_depth: u32,
35878     pub layout: PipelineLayout,
35879     pub base_pipeline_handle: Pipeline,
35880     pub base_pipeline_index: i32,
35881 }
35882 impl ::std::default::Default for RayTracingPipelineCreateInfoNV {
35883     #[inline]
default() -> Self35884     fn default() -> Self {
35885         Self {
35886             s_type: Self::STRUCTURE_TYPE,
35887             p_next: ::std::ptr::null(),
35888             flags: PipelineCreateFlags::default(),
35889             stage_count: u32::default(),
35890             p_stages: ::std::ptr::null(),
35891             group_count: u32::default(),
35892             p_groups: ::std::ptr::null(),
35893             max_recursion_depth: u32::default(),
35894             layout: PipelineLayout::default(),
35895             base_pipeline_handle: Pipeline::default(),
35896             base_pipeline_index: i32::default(),
35897         }
35898     }
35899 }
35900 unsafe impl TaggedStructure for RayTracingPipelineCreateInfoNV {
35901     const STRUCTURE_TYPE: StructureType = StructureType::RAY_TRACING_PIPELINE_CREATE_INFO_NV;
35902 }
35903 impl RayTracingPipelineCreateInfoNV {
builder<'a>() -> RayTracingPipelineCreateInfoNVBuilder<'a>35904     pub fn builder<'a>() -> RayTracingPipelineCreateInfoNVBuilder<'a> {
35905         RayTracingPipelineCreateInfoNVBuilder {
35906             inner: Self::default(),
35907             marker: ::std::marker::PhantomData,
35908         }
35909     }
35910 }
35911 #[repr(transparent)]
35912 pub struct RayTracingPipelineCreateInfoNVBuilder<'a> {
35913     inner: RayTracingPipelineCreateInfoNV,
35914     marker: ::std::marker::PhantomData<&'a ()>,
35915 }
35916 pub unsafe trait ExtendsRayTracingPipelineCreateInfoNV {}
35917 impl<'a> ::std::ops::Deref for RayTracingPipelineCreateInfoNVBuilder<'a> {
35918     type Target = RayTracingPipelineCreateInfoNV;
deref(&self) -> &Self::Target35919     fn deref(&self) -> &Self::Target {
35920         &self.inner
35921     }
35922 }
35923 impl<'a> ::std::ops::DerefMut for RayTracingPipelineCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target35924     fn deref_mut(&mut self) -> &mut Self::Target {
35925         &mut self.inner
35926     }
35927 }
35928 impl<'a> RayTracingPipelineCreateInfoNVBuilder<'a> {
35929     #[inline]
flags(mut self, flags: PipelineCreateFlags) -> Self35930     pub fn flags(mut self, flags: PipelineCreateFlags) -> Self {
35931         self.inner.flags = flags;
35932         self
35933     }
35934     #[inline]
stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self35935     pub fn stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self {
35936         self.inner.stage_count = stages.len() as _;
35937         self.inner.p_stages = stages.as_ptr();
35938         self
35939     }
35940     #[inline]
groups(mut self, groups: &'a [RayTracingShaderGroupCreateInfoNV]) -> Self35941     pub fn groups(mut self, groups: &'a [RayTracingShaderGroupCreateInfoNV]) -> Self {
35942         self.inner.group_count = groups.len() as _;
35943         self.inner.p_groups = groups.as_ptr();
35944         self
35945     }
35946     #[inline]
max_recursion_depth(mut self, max_recursion_depth: u32) -> Self35947     pub fn max_recursion_depth(mut self, max_recursion_depth: u32) -> Self {
35948         self.inner.max_recursion_depth = max_recursion_depth;
35949         self
35950     }
35951     #[inline]
layout(mut self, layout: PipelineLayout) -> Self35952     pub fn layout(mut self, layout: PipelineLayout) -> Self {
35953         self.inner.layout = layout;
35954         self
35955     }
35956     #[inline]
base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self35957     pub fn base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self {
35958         self.inner.base_pipeline_handle = base_pipeline_handle;
35959         self
35960     }
35961     #[inline]
base_pipeline_index(mut self, base_pipeline_index: i32) -> Self35962     pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self {
35963         self.inner.base_pipeline_index = base_pipeline_index;
35964         self
35965     }
35966     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
35967     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
35968     #[doc = r" valid extension structs can be pushed into the chain."]
35969     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
35970     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsRayTracingPipelineCreateInfoNV>(mut self, next: &'a mut T) -> Self35971     pub fn push_next<T: ExtendsRayTracingPipelineCreateInfoNV>(mut self, next: &'a mut T) -> Self {
35972         unsafe {
35973             let next_ptr = <*const T>::cast(next);
35974             let last_next = ptr_chain_iter(next).last().unwrap();
35975             (*last_next).p_next = self.inner.p_next as _;
35976             self.inner.p_next = next_ptr;
35977         }
35978         self
35979     }
35980     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35981     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35982     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RayTracingPipelineCreateInfoNV35983     pub fn build(self) -> RayTracingPipelineCreateInfoNV {
35984         self.inner
35985     }
35986 }
35987 #[repr(C)]
35988 #[cfg_attr(feature = "debug", derive(Debug))]
35989 #[derive(Copy, Clone)]
35990 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRayTracingPipelineCreateInfoKHR.html>"]
35991 pub struct RayTracingPipelineCreateInfoKHR {
35992     pub s_type: StructureType,
35993     pub p_next: *const c_void,
35994     pub flags: PipelineCreateFlags,
35995     pub stage_count: u32,
35996     pub p_stages: *const PipelineShaderStageCreateInfo,
35997     pub group_count: u32,
35998     pub p_groups: *const RayTracingShaderGroupCreateInfoKHR,
35999     pub max_pipeline_ray_recursion_depth: u32,
36000     pub p_library_info: *const PipelineLibraryCreateInfoKHR,
36001     pub p_library_interface: *const RayTracingPipelineInterfaceCreateInfoKHR,
36002     pub p_dynamic_state: *const PipelineDynamicStateCreateInfo,
36003     pub layout: PipelineLayout,
36004     pub base_pipeline_handle: Pipeline,
36005     pub base_pipeline_index: i32,
36006 }
36007 impl ::std::default::Default for RayTracingPipelineCreateInfoKHR {
36008     #[inline]
default() -> Self36009     fn default() -> Self {
36010         Self {
36011             s_type: Self::STRUCTURE_TYPE,
36012             p_next: ::std::ptr::null(),
36013             flags: PipelineCreateFlags::default(),
36014             stage_count: u32::default(),
36015             p_stages: ::std::ptr::null(),
36016             group_count: u32::default(),
36017             p_groups: ::std::ptr::null(),
36018             max_pipeline_ray_recursion_depth: u32::default(),
36019             p_library_info: ::std::ptr::null(),
36020             p_library_interface: ::std::ptr::null(),
36021             p_dynamic_state: ::std::ptr::null(),
36022             layout: PipelineLayout::default(),
36023             base_pipeline_handle: Pipeline::default(),
36024             base_pipeline_index: i32::default(),
36025         }
36026     }
36027 }
36028 unsafe impl TaggedStructure for RayTracingPipelineCreateInfoKHR {
36029     const STRUCTURE_TYPE: StructureType = StructureType::RAY_TRACING_PIPELINE_CREATE_INFO_KHR;
36030 }
36031 impl RayTracingPipelineCreateInfoKHR {
builder<'a>() -> RayTracingPipelineCreateInfoKHRBuilder<'a>36032     pub fn builder<'a>() -> RayTracingPipelineCreateInfoKHRBuilder<'a> {
36033         RayTracingPipelineCreateInfoKHRBuilder {
36034             inner: Self::default(),
36035             marker: ::std::marker::PhantomData,
36036         }
36037     }
36038 }
36039 #[repr(transparent)]
36040 pub struct RayTracingPipelineCreateInfoKHRBuilder<'a> {
36041     inner: RayTracingPipelineCreateInfoKHR,
36042     marker: ::std::marker::PhantomData<&'a ()>,
36043 }
36044 pub unsafe trait ExtendsRayTracingPipelineCreateInfoKHR {}
36045 impl<'a> ::std::ops::Deref for RayTracingPipelineCreateInfoKHRBuilder<'a> {
36046     type Target = RayTracingPipelineCreateInfoKHR;
deref(&self) -> &Self::Target36047     fn deref(&self) -> &Self::Target {
36048         &self.inner
36049     }
36050 }
36051 impl<'a> ::std::ops::DerefMut for RayTracingPipelineCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target36052     fn deref_mut(&mut self) -> &mut Self::Target {
36053         &mut self.inner
36054     }
36055 }
36056 impl<'a> RayTracingPipelineCreateInfoKHRBuilder<'a> {
36057     #[inline]
flags(mut self, flags: PipelineCreateFlags) -> Self36058     pub fn flags(mut self, flags: PipelineCreateFlags) -> Self {
36059         self.inner.flags = flags;
36060         self
36061     }
36062     #[inline]
stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self36063     pub fn stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self {
36064         self.inner.stage_count = stages.len() as _;
36065         self.inner.p_stages = stages.as_ptr();
36066         self
36067     }
36068     #[inline]
groups(mut self, groups: &'a [RayTracingShaderGroupCreateInfoKHR]) -> Self36069     pub fn groups(mut self, groups: &'a [RayTracingShaderGroupCreateInfoKHR]) -> Self {
36070         self.inner.group_count = groups.len() as _;
36071         self.inner.p_groups = groups.as_ptr();
36072         self
36073     }
36074     #[inline]
max_pipeline_ray_recursion_depth( mut self, max_pipeline_ray_recursion_depth: u32, ) -> Self36075     pub fn max_pipeline_ray_recursion_depth(
36076         mut self,
36077         max_pipeline_ray_recursion_depth: u32,
36078     ) -> Self {
36079         self.inner.max_pipeline_ray_recursion_depth = max_pipeline_ray_recursion_depth;
36080         self
36081     }
36082     #[inline]
library_info(mut self, library_info: &'a PipelineLibraryCreateInfoKHR) -> Self36083     pub fn library_info(mut self, library_info: &'a PipelineLibraryCreateInfoKHR) -> Self {
36084         self.inner.p_library_info = library_info;
36085         self
36086     }
36087     #[inline]
library_interface( mut self, library_interface: &'a RayTracingPipelineInterfaceCreateInfoKHR, ) -> Self36088     pub fn library_interface(
36089         mut self,
36090         library_interface: &'a RayTracingPipelineInterfaceCreateInfoKHR,
36091     ) -> Self {
36092         self.inner.p_library_interface = library_interface;
36093         self
36094     }
36095     #[inline]
dynamic_state(mut self, dynamic_state: &'a PipelineDynamicStateCreateInfo) -> Self36096     pub fn dynamic_state(mut self, dynamic_state: &'a PipelineDynamicStateCreateInfo) -> Self {
36097         self.inner.p_dynamic_state = dynamic_state;
36098         self
36099     }
36100     #[inline]
layout(mut self, layout: PipelineLayout) -> Self36101     pub fn layout(mut self, layout: PipelineLayout) -> Self {
36102         self.inner.layout = layout;
36103         self
36104     }
36105     #[inline]
base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self36106     pub fn base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self {
36107         self.inner.base_pipeline_handle = base_pipeline_handle;
36108         self
36109     }
36110     #[inline]
base_pipeline_index(mut self, base_pipeline_index: i32) -> Self36111     pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self {
36112         self.inner.base_pipeline_index = base_pipeline_index;
36113         self
36114     }
36115     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
36116     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
36117     #[doc = r" valid extension structs can be pushed into the chain."]
36118     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
36119     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsRayTracingPipelineCreateInfoKHR>(mut self, next: &'a mut T) -> Self36120     pub fn push_next<T: ExtendsRayTracingPipelineCreateInfoKHR>(mut self, next: &'a mut T) -> Self {
36121         unsafe {
36122             let next_ptr = <*const T>::cast(next);
36123             let last_next = ptr_chain_iter(next).last().unwrap();
36124             (*last_next).p_next = self.inner.p_next as _;
36125             self.inner.p_next = next_ptr;
36126         }
36127         self
36128     }
36129     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36130     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36131     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RayTracingPipelineCreateInfoKHR36132     pub fn build(self) -> RayTracingPipelineCreateInfoKHR {
36133         self.inner
36134     }
36135 }
36136 #[repr(C)]
36137 #[cfg_attr(feature = "debug", derive(Debug))]
36138 #[derive(Copy, Clone)]
36139 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeometryTrianglesNV.html>"]
36140 pub struct GeometryTrianglesNV {
36141     pub s_type: StructureType,
36142     pub p_next: *const c_void,
36143     pub vertex_data: Buffer,
36144     pub vertex_offset: DeviceSize,
36145     pub vertex_count: u32,
36146     pub vertex_stride: DeviceSize,
36147     pub vertex_format: Format,
36148     pub index_data: Buffer,
36149     pub index_offset: DeviceSize,
36150     pub index_count: u32,
36151     pub index_type: IndexType,
36152     pub transform_data: Buffer,
36153     pub transform_offset: DeviceSize,
36154 }
36155 impl ::std::default::Default for GeometryTrianglesNV {
36156     #[inline]
default() -> Self36157     fn default() -> Self {
36158         Self {
36159             s_type: Self::STRUCTURE_TYPE,
36160             p_next: ::std::ptr::null(),
36161             vertex_data: Buffer::default(),
36162             vertex_offset: DeviceSize::default(),
36163             vertex_count: u32::default(),
36164             vertex_stride: DeviceSize::default(),
36165             vertex_format: Format::default(),
36166             index_data: Buffer::default(),
36167             index_offset: DeviceSize::default(),
36168             index_count: u32::default(),
36169             index_type: IndexType::default(),
36170             transform_data: Buffer::default(),
36171             transform_offset: DeviceSize::default(),
36172         }
36173     }
36174 }
36175 unsafe impl TaggedStructure for GeometryTrianglesNV {
36176     const STRUCTURE_TYPE: StructureType = StructureType::GEOMETRY_TRIANGLES_NV;
36177 }
36178 impl GeometryTrianglesNV {
builder<'a>() -> GeometryTrianglesNVBuilder<'a>36179     pub fn builder<'a>() -> GeometryTrianglesNVBuilder<'a> {
36180         GeometryTrianglesNVBuilder {
36181             inner: Self::default(),
36182             marker: ::std::marker::PhantomData,
36183         }
36184     }
36185 }
36186 #[repr(transparent)]
36187 pub struct GeometryTrianglesNVBuilder<'a> {
36188     inner: GeometryTrianglesNV,
36189     marker: ::std::marker::PhantomData<&'a ()>,
36190 }
36191 impl<'a> ::std::ops::Deref for GeometryTrianglesNVBuilder<'a> {
36192     type Target = GeometryTrianglesNV;
deref(&self) -> &Self::Target36193     fn deref(&self) -> &Self::Target {
36194         &self.inner
36195     }
36196 }
36197 impl<'a> ::std::ops::DerefMut for GeometryTrianglesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target36198     fn deref_mut(&mut self) -> &mut Self::Target {
36199         &mut self.inner
36200     }
36201 }
36202 impl<'a> GeometryTrianglesNVBuilder<'a> {
36203     #[inline]
vertex_data(mut self, vertex_data: Buffer) -> Self36204     pub fn vertex_data(mut self, vertex_data: Buffer) -> Self {
36205         self.inner.vertex_data = vertex_data;
36206         self
36207     }
36208     #[inline]
vertex_offset(mut self, vertex_offset: DeviceSize) -> Self36209     pub fn vertex_offset(mut self, vertex_offset: DeviceSize) -> Self {
36210         self.inner.vertex_offset = vertex_offset;
36211         self
36212     }
36213     #[inline]
vertex_count(mut self, vertex_count: u32) -> Self36214     pub fn vertex_count(mut self, vertex_count: u32) -> Self {
36215         self.inner.vertex_count = vertex_count;
36216         self
36217     }
36218     #[inline]
vertex_stride(mut self, vertex_stride: DeviceSize) -> Self36219     pub fn vertex_stride(mut self, vertex_stride: DeviceSize) -> Self {
36220         self.inner.vertex_stride = vertex_stride;
36221         self
36222     }
36223     #[inline]
vertex_format(mut self, vertex_format: Format) -> Self36224     pub fn vertex_format(mut self, vertex_format: Format) -> Self {
36225         self.inner.vertex_format = vertex_format;
36226         self
36227     }
36228     #[inline]
index_data(mut self, index_data: Buffer) -> Self36229     pub fn index_data(mut self, index_data: Buffer) -> Self {
36230         self.inner.index_data = index_data;
36231         self
36232     }
36233     #[inline]
index_offset(mut self, index_offset: DeviceSize) -> Self36234     pub fn index_offset(mut self, index_offset: DeviceSize) -> Self {
36235         self.inner.index_offset = index_offset;
36236         self
36237     }
36238     #[inline]
index_count(mut self, index_count: u32) -> Self36239     pub fn index_count(mut self, index_count: u32) -> Self {
36240         self.inner.index_count = index_count;
36241         self
36242     }
36243     #[inline]
index_type(mut self, index_type: IndexType) -> Self36244     pub fn index_type(mut self, index_type: IndexType) -> Self {
36245         self.inner.index_type = index_type;
36246         self
36247     }
36248     #[inline]
transform_data(mut self, transform_data: Buffer) -> Self36249     pub fn transform_data(mut self, transform_data: Buffer) -> Self {
36250         self.inner.transform_data = transform_data;
36251         self
36252     }
36253     #[inline]
transform_offset(mut self, transform_offset: DeviceSize) -> Self36254     pub fn transform_offset(mut self, transform_offset: DeviceSize) -> Self {
36255         self.inner.transform_offset = transform_offset;
36256         self
36257     }
36258     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36259     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36260     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> GeometryTrianglesNV36261     pub fn build(self) -> GeometryTrianglesNV {
36262         self.inner
36263     }
36264 }
36265 #[repr(C)]
36266 #[cfg_attr(feature = "debug", derive(Debug))]
36267 #[derive(Copy, Clone)]
36268 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeometryAABBNV.html>"]
36269 pub struct GeometryAABBNV {
36270     pub s_type: StructureType,
36271     pub p_next: *const c_void,
36272     pub aabb_data: Buffer,
36273     pub num_aab_bs: u32,
36274     pub stride: u32,
36275     pub offset: DeviceSize,
36276 }
36277 impl ::std::default::Default for GeometryAABBNV {
36278     #[inline]
default() -> Self36279     fn default() -> Self {
36280         Self {
36281             s_type: Self::STRUCTURE_TYPE,
36282             p_next: ::std::ptr::null(),
36283             aabb_data: Buffer::default(),
36284             num_aab_bs: u32::default(),
36285             stride: u32::default(),
36286             offset: DeviceSize::default(),
36287         }
36288     }
36289 }
36290 unsafe impl TaggedStructure for GeometryAABBNV {
36291     const STRUCTURE_TYPE: StructureType = StructureType::GEOMETRY_AABB_NV;
36292 }
36293 impl GeometryAABBNV {
builder<'a>() -> GeometryAABBNVBuilder<'a>36294     pub fn builder<'a>() -> GeometryAABBNVBuilder<'a> {
36295         GeometryAABBNVBuilder {
36296             inner: Self::default(),
36297             marker: ::std::marker::PhantomData,
36298         }
36299     }
36300 }
36301 #[repr(transparent)]
36302 pub struct GeometryAABBNVBuilder<'a> {
36303     inner: GeometryAABBNV,
36304     marker: ::std::marker::PhantomData<&'a ()>,
36305 }
36306 impl<'a> ::std::ops::Deref for GeometryAABBNVBuilder<'a> {
36307     type Target = GeometryAABBNV;
deref(&self) -> &Self::Target36308     fn deref(&self) -> &Self::Target {
36309         &self.inner
36310     }
36311 }
36312 impl<'a> ::std::ops::DerefMut for GeometryAABBNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target36313     fn deref_mut(&mut self) -> &mut Self::Target {
36314         &mut self.inner
36315     }
36316 }
36317 impl<'a> GeometryAABBNVBuilder<'a> {
36318     #[inline]
aabb_data(mut self, aabb_data: Buffer) -> Self36319     pub fn aabb_data(mut self, aabb_data: Buffer) -> Self {
36320         self.inner.aabb_data = aabb_data;
36321         self
36322     }
36323     #[inline]
num_aab_bs(mut self, num_aab_bs: u32) -> Self36324     pub fn num_aab_bs(mut self, num_aab_bs: u32) -> Self {
36325         self.inner.num_aab_bs = num_aab_bs;
36326         self
36327     }
36328     #[inline]
stride(mut self, stride: u32) -> Self36329     pub fn stride(mut self, stride: u32) -> Self {
36330         self.inner.stride = stride;
36331         self
36332     }
36333     #[inline]
offset(mut self, offset: DeviceSize) -> Self36334     pub fn offset(mut self, offset: DeviceSize) -> Self {
36335         self.inner.offset = offset;
36336         self
36337     }
36338     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36339     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36340     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> GeometryAABBNV36341     pub fn build(self) -> GeometryAABBNV {
36342         self.inner
36343     }
36344 }
36345 #[repr(C)]
36346 #[cfg_attr(feature = "debug", derive(Debug))]
36347 #[derive(Copy, Clone, Default)]
36348 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeometryDataNV.html>"]
36349 pub struct GeometryDataNV {
36350     pub triangles: GeometryTrianglesNV,
36351     pub aabbs: GeometryAABBNV,
36352 }
36353 impl GeometryDataNV {
builder<'a>() -> GeometryDataNVBuilder<'a>36354     pub fn builder<'a>() -> GeometryDataNVBuilder<'a> {
36355         GeometryDataNVBuilder {
36356             inner: Self::default(),
36357             marker: ::std::marker::PhantomData,
36358         }
36359     }
36360 }
36361 #[repr(transparent)]
36362 pub struct GeometryDataNVBuilder<'a> {
36363     inner: GeometryDataNV,
36364     marker: ::std::marker::PhantomData<&'a ()>,
36365 }
36366 impl<'a> ::std::ops::Deref for GeometryDataNVBuilder<'a> {
36367     type Target = GeometryDataNV;
deref(&self) -> &Self::Target36368     fn deref(&self) -> &Self::Target {
36369         &self.inner
36370     }
36371 }
36372 impl<'a> ::std::ops::DerefMut for GeometryDataNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target36373     fn deref_mut(&mut self) -> &mut Self::Target {
36374         &mut self.inner
36375     }
36376 }
36377 impl<'a> GeometryDataNVBuilder<'a> {
36378     #[inline]
triangles(mut self, triangles: GeometryTrianglesNV) -> Self36379     pub fn triangles(mut self, triangles: GeometryTrianglesNV) -> Self {
36380         self.inner.triangles = triangles;
36381         self
36382     }
36383     #[inline]
aabbs(mut self, aabbs: GeometryAABBNV) -> Self36384     pub fn aabbs(mut self, aabbs: GeometryAABBNV) -> Self {
36385         self.inner.aabbs = aabbs;
36386         self
36387     }
36388     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36389     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36390     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> GeometryDataNV36391     pub fn build(self) -> GeometryDataNV {
36392         self.inner
36393     }
36394 }
36395 #[repr(C)]
36396 #[cfg_attr(feature = "debug", derive(Debug))]
36397 #[derive(Copy, Clone)]
36398 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeometryNV.html>"]
36399 pub struct GeometryNV {
36400     pub s_type: StructureType,
36401     pub p_next: *const c_void,
36402     pub geometry_type: GeometryTypeKHR,
36403     pub geometry: GeometryDataNV,
36404     pub flags: GeometryFlagsKHR,
36405 }
36406 impl ::std::default::Default for GeometryNV {
36407     #[inline]
default() -> Self36408     fn default() -> Self {
36409         Self {
36410             s_type: Self::STRUCTURE_TYPE,
36411             p_next: ::std::ptr::null(),
36412             geometry_type: GeometryTypeKHR::default(),
36413             geometry: GeometryDataNV::default(),
36414             flags: GeometryFlagsKHR::default(),
36415         }
36416     }
36417 }
36418 unsafe impl TaggedStructure for GeometryNV {
36419     const STRUCTURE_TYPE: StructureType = StructureType::GEOMETRY_NV;
36420 }
36421 impl GeometryNV {
builder<'a>() -> GeometryNVBuilder<'a>36422     pub fn builder<'a>() -> GeometryNVBuilder<'a> {
36423         GeometryNVBuilder {
36424             inner: Self::default(),
36425             marker: ::std::marker::PhantomData,
36426         }
36427     }
36428 }
36429 #[repr(transparent)]
36430 pub struct GeometryNVBuilder<'a> {
36431     inner: GeometryNV,
36432     marker: ::std::marker::PhantomData<&'a ()>,
36433 }
36434 impl<'a> ::std::ops::Deref for GeometryNVBuilder<'a> {
36435     type Target = GeometryNV;
deref(&self) -> &Self::Target36436     fn deref(&self) -> &Self::Target {
36437         &self.inner
36438     }
36439 }
36440 impl<'a> ::std::ops::DerefMut for GeometryNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target36441     fn deref_mut(&mut self) -> &mut Self::Target {
36442         &mut self.inner
36443     }
36444 }
36445 impl<'a> GeometryNVBuilder<'a> {
36446     #[inline]
geometry_type(mut self, geometry_type: GeometryTypeKHR) -> Self36447     pub fn geometry_type(mut self, geometry_type: GeometryTypeKHR) -> Self {
36448         self.inner.geometry_type = geometry_type;
36449         self
36450     }
36451     #[inline]
geometry(mut self, geometry: GeometryDataNV) -> Self36452     pub fn geometry(mut self, geometry: GeometryDataNV) -> Self {
36453         self.inner.geometry = geometry;
36454         self
36455     }
36456     #[inline]
flags(mut self, flags: GeometryFlagsKHR) -> Self36457     pub fn flags(mut self, flags: GeometryFlagsKHR) -> Self {
36458         self.inner.flags = flags;
36459         self
36460     }
36461     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36462     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36463     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> GeometryNV36464     pub fn build(self) -> GeometryNV {
36465         self.inner
36466     }
36467 }
36468 #[repr(C)]
36469 #[cfg_attr(feature = "debug", derive(Debug))]
36470 #[derive(Copy, Clone)]
36471 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureInfoNV.html>"]
36472 pub struct AccelerationStructureInfoNV {
36473     pub s_type: StructureType,
36474     pub p_next: *const c_void,
36475     pub ty: AccelerationStructureTypeNV,
36476     pub flags: BuildAccelerationStructureFlagsNV,
36477     pub instance_count: u32,
36478     pub geometry_count: u32,
36479     pub p_geometries: *const GeometryNV,
36480 }
36481 impl ::std::default::Default for AccelerationStructureInfoNV {
36482     #[inline]
default() -> Self36483     fn default() -> Self {
36484         Self {
36485             s_type: Self::STRUCTURE_TYPE,
36486             p_next: ::std::ptr::null(),
36487             ty: AccelerationStructureTypeNV::default(),
36488             flags: BuildAccelerationStructureFlagsNV::default(),
36489             instance_count: u32::default(),
36490             geometry_count: u32::default(),
36491             p_geometries: ::std::ptr::null(),
36492         }
36493     }
36494 }
36495 unsafe impl TaggedStructure for AccelerationStructureInfoNV {
36496     const STRUCTURE_TYPE: StructureType = StructureType::ACCELERATION_STRUCTURE_INFO_NV;
36497 }
36498 impl AccelerationStructureInfoNV {
builder<'a>() -> AccelerationStructureInfoNVBuilder<'a>36499     pub fn builder<'a>() -> AccelerationStructureInfoNVBuilder<'a> {
36500         AccelerationStructureInfoNVBuilder {
36501             inner: Self::default(),
36502             marker: ::std::marker::PhantomData,
36503         }
36504     }
36505 }
36506 #[repr(transparent)]
36507 pub struct AccelerationStructureInfoNVBuilder<'a> {
36508     inner: AccelerationStructureInfoNV,
36509     marker: ::std::marker::PhantomData<&'a ()>,
36510 }
36511 impl<'a> ::std::ops::Deref for AccelerationStructureInfoNVBuilder<'a> {
36512     type Target = AccelerationStructureInfoNV;
deref(&self) -> &Self::Target36513     fn deref(&self) -> &Self::Target {
36514         &self.inner
36515     }
36516 }
36517 impl<'a> ::std::ops::DerefMut for AccelerationStructureInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target36518     fn deref_mut(&mut self) -> &mut Self::Target {
36519         &mut self.inner
36520     }
36521 }
36522 impl<'a> AccelerationStructureInfoNVBuilder<'a> {
36523     #[inline]
ty(mut self, ty: AccelerationStructureTypeNV) -> Self36524     pub fn ty(mut self, ty: AccelerationStructureTypeNV) -> Self {
36525         self.inner.ty = ty;
36526         self
36527     }
36528     #[inline]
flags(mut self, flags: BuildAccelerationStructureFlagsNV) -> Self36529     pub fn flags(mut self, flags: BuildAccelerationStructureFlagsNV) -> Self {
36530         self.inner.flags = flags;
36531         self
36532     }
36533     #[inline]
instance_count(mut self, instance_count: u32) -> Self36534     pub fn instance_count(mut self, instance_count: u32) -> Self {
36535         self.inner.instance_count = instance_count;
36536         self
36537     }
36538     #[inline]
geometries(mut self, geometries: &'a [GeometryNV]) -> Self36539     pub fn geometries(mut self, geometries: &'a [GeometryNV]) -> Self {
36540         self.inner.geometry_count = geometries.len() as _;
36541         self.inner.p_geometries = geometries.as_ptr();
36542         self
36543     }
36544     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36545     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36546     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureInfoNV36547     pub fn build(self) -> AccelerationStructureInfoNV {
36548         self.inner
36549     }
36550 }
36551 #[repr(C)]
36552 #[cfg_attr(feature = "debug", derive(Debug))]
36553 #[derive(Copy, Clone)]
36554 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureCreateInfoNV.html>"]
36555 pub struct AccelerationStructureCreateInfoNV {
36556     pub s_type: StructureType,
36557     pub p_next: *const c_void,
36558     pub compacted_size: DeviceSize,
36559     pub info: AccelerationStructureInfoNV,
36560 }
36561 impl ::std::default::Default for AccelerationStructureCreateInfoNV {
36562     #[inline]
default() -> Self36563     fn default() -> Self {
36564         Self {
36565             s_type: Self::STRUCTURE_TYPE,
36566             p_next: ::std::ptr::null(),
36567             compacted_size: DeviceSize::default(),
36568             info: AccelerationStructureInfoNV::default(),
36569         }
36570     }
36571 }
36572 unsafe impl TaggedStructure for AccelerationStructureCreateInfoNV {
36573     const STRUCTURE_TYPE: StructureType = StructureType::ACCELERATION_STRUCTURE_CREATE_INFO_NV;
36574 }
36575 impl AccelerationStructureCreateInfoNV {
builder<'a>() -> AccelerationStructureCreateInfoNVBuilder<'a>36576     pub fn builder<'a>() -> AccelerationStructureCreateInfoNVBuilder<'a> {
36577         AccelerationStructureCreateInfoNVBuilder {
36578             inner: Self::default(),
36579             marker: ::std::marker::PhantomData,
36580         }
36581     }
36582 }
36583 #[repr(transparent)]
36584 pub struct AccelerationStructureCreateInfoNVBuilder<'a> {
36585     inner: AccelerationStructureCreateInfoNV,
36586     marker: ::std::marker::PhantomData<&'a ()>,
36587 }
36588 pub unsafe trait ExtendsAccelerationStructureCreateInfoNV {}
36589 impl<'a> ::std::ops::Deref for AccelerationStructureCreateInfoNVBuilder<'a> {
36590     type Target = AccelerationStructureCreateInfoNV;
deref(&self) -> &Self::Target36591     fn deref(&self) -> &Self::Target {
36592         &self.inner
36593     }
36594 }
36595 impl<'a> ::std::ops::DerefMut for AccelerationStructureCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target36596     fn deref_mut(&mut self) -> &mut Self::Target {
36597         &mut self.inner
36598     }
36599 }
36600 impl<'a> AccelerationStructureCreateInfoNVBuilder<'a> {
36601     #[inline]
compacted_size(mut self, compacted_size: DeviceSize) -> Self36602     pub fn compacted_size(mut self, compacted_size: DeviceSize) -> Self {
36603         self.inner.compacted_size = compacted_size;
36604         self
36605     }
36606     #[inline]
info(mut self, info: AccelerationStructureInfoNV) -> Self36607     pub fn info(mut self, info: AccelerationStructureInfoNV) -> Self {
36608         self.inner.info = info;
36609         self
36610     }
36611     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
36612     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
36613     #[doc = r" valid extension structs can be pushed into the chain."]
36614     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
36615     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsAccelerationStructureCreateInfoNV>( mut self, next: &'a mut T, ) -> Self36616     pub fn push_next<T: ExtendsAccelerationStructureCreateInfoNV>(
36617         mut self,
36618         next: &'a mut T,
36619     ) -> Self {
36620         unsafe {
36621             let next_ptr = <*const T>::cast(next);
36622             let last_next = ptr_chain_iter(next).last().unwrap();
36623             (*last_next).p_next = self.inner.p_next as _;
36624             self.inner.p_next = next_ptr;
36625         }
36626         self
36627     }
36628     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36629     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36630     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureCreateInfoNV36631     pub fn build(self) -> AccelerationStructureCreateInfoNV {
36632         self.inner
36633     }
36634 }
36635 #[repr(C)]
36636 #[cfg_attr(feature = "debug", derive(Debug))]
36637 #[derive(Copy, Clone)]
36638 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindAccelerationStructureMemoryInfoNV.html>"]
36639 pub struct BindAccelerationStructureMemoryInfoNV {
36640     pub s_type: StructureType,
36641     pub p_next: *const c_void,
36642     pub acceleration_structure: AccelerationStructureNV,
36643     pub memory: DeviceMemory,
36644     pub memory_offset: DeviceSize,
36645     pub device_index_count: u32,
36646     pub p_device_indices: *const u32,
36647 }
36648 impl ::std::default::Default for BindAccelerationStructureMemoryInfoNV {
36649     #[inline]
default() -> Self36650     fn default() -> Self {
36651         Self {
36652             s_type: Self::STRUCTURE_TYPE,
36653             p_next: ::std::ptr::null(),
36654             acceleration_structure: AccelerationStructureNV::default(),
36655             memory: DeviceMemory::default(),
36656             memory_offset: DeviceSize::default(),
36657             device_index_count: u32::default(),
36658             p_device_indices: ::std::ptr::null(),
36659         }
36660     }
36661 }
36662 unsafe impl TaggedStructure for BindAccelerationStructureMemoryInfoNV {
36663     const STRUCTURE_TYPE: StructureType = StructureType::BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV;
36664 }
36665 impl BindAccelerationStructureMemoryInfoNV {
builder<'a>() -> BindAccelerationStructureMemoryInfoNVBuilder<'a>36666     pub fn builder<'a>() -> BindAccelerationStructureMemoryInfoNVBuilder<'a> {
36667         BindAccelerationStructureMemoryInfoNVBuilder {
36668             inner: Self::default(),
36669             marker: ::std::marker::PhantomData,
36670         }
36671     }
36672 }
36673 #[repr(transparent)]
36674 pub struct BindAccelerationStructureMemoryInfoNVBuilder<'a> {
36675     inner: BindAccelerationStructureMemoryInfoNV,
36676     marker: ::std::marker::PhantomData<&'a ()>,
36677 }
36678 impl<'a> ::std::ops::Deref for BindAccelerationStructureMemoryInfoNVBuilder<'a> {
36679     type Target = BindAccelerationStructureMemoryInfoNV;
deref(&self) -> &Self::Target36680     fn deref(&self) -> &Self::Target {
36681         &self.inner
36682     }
36683 }
36684 impl<'a> ::std::ops::DerefMut for BindAccelerationStructureMemoryInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target36685     fn deref_mut(&mut self) -> &mut Self::Target {
36686         &mut self.inner
36687     }
36688 }
36689 impl<'a> BindAccelerationStructureMemoryInfoNVBuilder<'a> {
36690     #[inline]
acceleration_structure( mut self, acceleration_structure: AccelerationStructureNV, ) -> Self36691     pub fn acceleration_structure(
36692         mut self,
36693         acceleration_structure: AccelerationStructureNV,
36694     ) -> Self {
36695         self.inner.acceleration_structure = acceleration_structure;
36696         self
36697     }
36698     #[inline]
memory(mut self, memory: DeviceMemory) -> Self36699     pub fn memory(mut self, memory: DeviceMemory) -> Self {
36700         self.inner.memory = memory;
36701         self
36702     }
36703     #[inline]
memory_offset(mut self, memory_offset: DeviceSize) -> Self36704     pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self {
36705         self.inner.memory_offset = memory_offset;
36706         self
36707     }
36708     #[inline]
device_indices(mut self, device_indices: &'a [u32]) -> Self36709     pub fn device_indices(mut self, device_indices: &'a [u32]) -> Self {
36710         self.inner.device_index_count = device_indices.len() as _;
36711         self.inner.p_device_indices = device_indices.as_ptr();
36712         self
36713     }
36714     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36715     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36716     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BindAccelerationStructureMemoryInfoNV36717     pub fn build(self) -> BindAccelerationStructureMemoryInfoNV {
36718         self.inner
36719     }
36720 }
36721 #[repr(C)]
36722 #[cfg_attr(feature = "debug", derive(Debug))]
36723 #[derive(Copy, Clone)]
36724 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWriteDescriptorSetAccelerationStructureKHR.html>"]
36725 pub struct WriteDescriptorSetAccelerationStructureKHR {
36726     pub s_type: StructureType,
36727     pub p_next: *const c_void,
36728     pub acceleration_structure_count: u32,
36729     pub p_acceleration_structures: *const AccelerationStructureKHR,
36730 }
36731 impl ::std::default::Default for WriteDescriptorSetAccelerationStructureKHR {
36732     #[inline]
default() -> Self36733     fn default() -> Self {
36734         Self {
36735             s_type: Self::STRUCTURE_TYPE,
36736             p_next: ::std::ptr::null(),
36737             acceleration_structure_count: u32::default(),
36738             p_acceleration_structures: ::std::ptr::null(),
36739         }
36740     }
36741 }
36742 unsafe impl TaggedStructure for WriteDescriptorSetAccelerationStructureKHR {
36743     const STRUCTURE_TYPE: StructureType =
36744         StructureType::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR;
36745 }
36746 impl WriteDescriptorSetAccelerationStructureKHR {
builder<'a>() -> WriteDescriptorSetAccelerationStructureKHRBuilder<'a>36747     pub fn builder<'a>() -> WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
36748         WriteDescriptorSetAccelerationStructureKHRBuilder {
36749             inner: Self::default(),
36750             marker: ::std::marker::PhantomData,
36751         }
36752     }
36753 }
36754 #[repr(transparent)]
36755 pub struct WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
36756     inner: WriteDescriptorSetAccelerationStructureKHR,
36757     marker: ::std::marker::PhantomData<&'a ()>,
36758 }
36759 unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureKHRBuilder<'_> {}
36760 unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureKHR {}
36761 impl<'a> ::std::ops::Deref for WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
36762     type Target = WriteDescriptorSetAccelerationStructureKHR;
deref(&self) -> &Self::Target36763     fn deref(&self) -> &Self::Target {
36764         &self.inner
36765     }
36766 }
36767 impl<'a> ::std::ops::DerefMut for WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target36768     fn deref_mut(&mut self) -> &mut Self::Target {
36769         &mut self.inner
36770     }
36771 }
36772 impl<'a> WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
36773     #[inline]
acceleration_structures( mut self, acceleration_structures: &'a [AccelerationStructureKHR], ) -> Self36774     pub fn acceleration_structures(
36775         mut self,
36776         acceleration_structures: &'a [AccelerationStructureKHR],
36777     ) -> Self {
36778         self.inner.acceleration_structure_count = acceleration_structures.len() as _;
36779         self.inner.p_acceleration_structures = acceleration_structures.as_ptr();
36780         self
36781     }
36782     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36783     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36784     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> WriteDescriptorSetAccelerationStructureKHR36785     pub fn build(self) -> WriteDescriptorSetAccelerationStructureKHR {
36786         self.inner
36787     }
36788 }
36789 #[repr(C)]
36790 #[cfg_attr(feature = "debug", derive(Debug))]
36791 #[derive(Copy, Clone)]
36792 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWriteDescriptorSetAccelerationStructureNV.html>"]
36793 pub struct WriteDescriptorSetAccelerationStructureNV {
36794     pub s_type: StructureType,
36795     pub p_next: *const c_void,
36796     pub acceleration_structure_count: u32,
36797     pub p_acceleration_structures: *const AccelerationStructureNV,
36798 }
36799 impl ::std::default::Default for WriteDescriptorSetAccelerationStructureNV {
36800     #[inline]
default() -> Self36801     fn default() -> Self {
36802         Self {
36803             s_type: Self::STRUCTURE_TYPE,
36804             p_next: ::std::ptr::null(),
36805             acceleration_structure_count: u32::default(),
36806             p_acceleration_structures: ::std::ptr::null(),
36807         }
36808     }
36809 }
36810 unsafe impl TaggedStructure for WriteDescriptorSetAccelerationStructureNV {
36811     const STRUCTURE_TYPE: StructureType =
36812         StructureType::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV;
36813 }
36814 impl WriteDescriptorSetAccelerationStructureNV {
builder<'a>() -> WriteDescriptorSetAccelerationStructureNVBuilder<'a>36815     pub fn builder<'a>() -> WriteDescriptorSetAccelerationStructureNVBuilder<'a> {
36816         WriteDescriptorSetAccelerationStructureNVBuilder {
36817             inner: Self::default(),
36818             marker: ::std::marker::PhantomData,
36819         }
36820     }
36821 }
36822 #[repr(transparent)]
36823 pub struct WriteDescriptorSetAccelerationStructureNVBuilder<'a> {
36824     inner: WriteDescriptorSetAccelerationStructureNV,
36825     marker: ::std::marker::PhantomData<&'a ()>,
36826 }
36827 unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureNVBuilder<'_> {}
36828 unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureNV {}
36829 impl<'a> ::std::ops::Deref for WriteDescriptorSetAccelerationStructureNVBuilder<'a> {
36830     type Target = WriteDescriptorSetAccelerationStructureNV;
deref(&self) -> &Self::Target36831     fn deref(&self) -> &Self::Target {
36832         &self.inner
36833     }
36834 }
36835 impl<'a> ::std::ops::DerefMut for WriteDescriptorSetAccelerationStructureNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target36836     fn deref_mut(&mut self) -> &mut Self::Target {
36837         &mut self.inner
36838     }
36839 }
36840 impl<'a> WriteDescriptorSetAccelerationStructureNVBuilder<'a> {
36841     #[inline]
acceleration_structures( mut self, acceleration_structures: &'a [AccelerationStructureNV], ) -> Self36842     pub fn acceleration_structures(
36843         mut self,
36844         acceleration_structures: &'a [AccelerationStructureNV],
36845     ) -> Self {
36846         self.inner.acceleration_structure_count = acceleration_structures.len() as _;
36847         self.inner.p_acceleration_structures = acceleration_structures.as_ptr();
36848         self
36849     }
36850     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36851     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36852     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> WriteDescriptorSetAccelerationStructureNV36853     pub fn build(self) -> WriteDescriptorSetAccelerationStructureNV {
36854         self.inner
36855     }
36856 }
36857 #[repr(C)]
36858 #[cfg_attr(feature = "debug", derive(Debug))]
36859 #[derive(Copy, Clone)]
36860 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMemoryRequirementsInfoNV.html>"]
36861 pub struct AccelerationStructureMemoryRequirementsInfoNV {
36862     pub s_type: StructureType,
36863     pub p_next: *const c_void,
36864     pub ty: AccelerationStructureMemoryRequirementsTypeNV,
36865     pub acceleration_structure: AccelerationStructureNV,
36866 }
36867 impl ::std::default::Default for AccelerationStructureMemoryRequirementsInfoNV {
36868     #[inline]
default() -> Self36869     fn default() -> Self {
36870         Self {
36871             s_type: Self::STRUCTURE_TYPE,
36872             p_next: ::std::ptr::null(),
36873             ty: AccelerationStructureMemoryRequirementsTypeNV::default(),
36874             acceleration_structure: AccelerationStructureNV::default(),
36875         }
36876     }
36877 }
36878 unsafe impl TaggedStructure for AccelerationStructureMemoryRequirementsInfoNV {
36879     const STRUCTURE_TYPE: StructureType =
36880         StructureType::ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV;
36881 }
36882 impl AccelerationStructureMemoryRequirementsInfoNV {
builder<'a>() -> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a>36883     pub fn builder<'a>() -> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
36884         AccelerationStructureMemoryRequirementsInfoNVBuilder {
36885             inner: Self::default(),
36886             marker: ::std::marker::PhantomData,
36887         }
36888     }
36889 }
36890 #[repr(transparent)]
36891 pub struct AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
36892     inner: AccelerationStructureMemoryRequirementsInfoNV,
36893     marker: ::std::marker::PhantomData<&'a ()>,
36894 }
36895 impl<'a> ::std::ops::Deref for AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
36896     type Target = AccelerationStructureMemoryRequirementsInfoNV;
deref(&self) -> &Self::Target36897     fn deref(&self) -> &Self::Target {
36898         &self.inner
36899     }
36900 }
36901 impl<'a> ::std::ops::DerefMut for AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target36902     fn deref_mut(&mut self) -> &mut Self::Target {
36903         &mut self.inner
36904     }
36905 }
36906 impl<'a> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
36907     #[inline]
ty(mut self, ty: AccelerationStructureMemoryRequirementsTypeNV) -> Self36908     pub fn ty(mut self, ty: AccelerationStructureMemoryRequirementsTypeNV) -> Self {
36909         self.inner.ty = ty;
36910         self
36911     }
36912     #[inline]
acceleration_structure( mut self, acceleration_structure: AccelerationStructureNV, ) -> Self36913     pub fn acceleration_structure(
36914         mut self,
36915         acceleration_structure: AccelerationStructureNV,
36916     ) -> Self {
36917         self.inner.acceleration_structure = acceleration_structure;
36918         self
36919     }
36920     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36921     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36922     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureMemoryRequirementsInfoNV36923     pub fn build(self) -> AccelerationStructureMemoryRequirementsInfoNV {
36924         self.inner
36925     }
36926 }
36927 #[repr(C)]
36928 #[cfg_attr(feature = "debug", derive(Debug))]
36929 #[derive(Copy, Clone)]
36930 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceAccelerationStructureFeaturesKHR.html>"]
36931 pub struct PhysicalDeviceAccelerationStructureFeaturesKHR {
36932     pub s_type: StructureType,
36933     pub p_next: *mut c_void,
36934     pub acceleration_structure: Bool32,
36935     pub acceleration_structure_capture_replay: Bool32,
36936     pub acceleration_structure_indirect_build: Bool32,
36937     pub acceleration_structure_host_commands: Bool32,
36938     pub descriptor_binding_acceleration_structure_update_after_bind: Bool32,
36939 }
36940 impl ::std::default::Default for PhysicalDeviceAccelerationStructureFeaturesKHR {
36941     #[inline]
default() -> Self36942     fn default() -> Self {
36943         Self {
36944             s_type: Self::STRUCTURE_TYPE,
36945             p_next: ::std::ptr::null_mut(),
36946             acceleration_structure: Bool32::default(),
36947             acceleration_structure_capture_replay: Bool32::default(),
36948             acceleration_structure_indirect_build: Bool32::default(),
36949             acceleration_structure_host_commands: Bool32::default(),
36950             descriptor_binding_acceleration_structure_update_after_bind: Bool32::default(),
36951         }
36952     }
36953 }
36954 unsafe impl TaggedStructure for PhysicalDeviceAccelerationStructureFeaturesKHR {
36955     const STRUCTURE_TYPE: StructureType =
36956         StructureType::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
36957 }
36958 impl PhysicalDeviceAccelerationStructureFeaturesKHR {
builder<'a>() -> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a>36959     pub fn builder<'a>() -> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
36960         PhysicalDeviceAccelerationStructureFeaturesKHRBuilder {
36961             inner: Self::default(),
36962             marker: ::std::marker::PhantomData,
36963         }
36964     }
36965 }
36966 #[repr(transparent)]
36967 pub struct PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
36968     inner: PhysicalDeviceAccelerationStructureFeaturesKHR,
36969     marker: ::std::marker::PhantomData<&'a ()>,
36970 }
36971 unsafe impl ExtendsPhysicalDeviceFeatures2
36972     for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'_>
36973 {
36974 }
36975 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceAccelerationStructureFeaturesKHR {}
36976 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'_> {}
36977 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAccelerationStructureFeaturesKHR {}
36978 impl<'a> ::std::ops::Deref for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
36979     type Target = PhysicalDeviceAccelerationStructureFeaturesKHR;
deref(&self) -> &Self::Target36980     fn deref(&self) -> &Self::Target {
36981         &self.inner
36982     }
36983 }
36984 impl<'a> ::std::ops::DerefMut for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target36985     fn deref_mut(&mut self) -> &mut Self::Target {
36986         &mut self.inner
36987     }
36988 }
36989 impl<'a> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
36990     #[inline]
acceleration_structure(mut self, acceleration_structure: bool) -> Self36991     pub fn acceleration_structure(mut self, acceleration_structure: bool) -> Self {
36992         self.inner.acceleration_structure = acceleration_structure.into();
36993         self
36994     }
36995     #[inline]
acceleration_structure_capture_replay( mut self, acceleration_structure_capture_replay: bool, ) -> Self36996     pub fn acceleration_structure_capture_replay(
36997         mut self,
36998         acceleration_structure_capture_replay: bool,
36999     ) -> Self {
37000         self.inner.acceleration_structure_capture_replay =
37001             acceleration_structure_capture_replay.into();
37002         self
37003     }
37004     #[inline]
acceleration_structure_indirect_build( mut self, acceleration_structure_indirect_build: bool, ) -> Self37005     pub fn acceleration_structure_indirect_build(
37006         mut self,
37007         acceleration_structure_indirect_build: bool,
37008     ) -> Self {
37009         self.inner.acceleration_structure_indirect_build =
37010             acceleration_structure_indirect_build.into();
37011         self
37012     }
37013     #[inline]
acceleration_structure_host_commands( mut self, acceleration_structure_host_commands: bool, ) -> Self37014     pub fn acceleration_structure_host_commands(
37015         mut self,
37016         acceleration_structure_host_commands: bool,
37017     ) -> Self {
37018         self.inner.acceleration_structure_host_commands =
37019             acceleration_structure_host_commands.into();
37020         self
37021     }
37022     #[inline]
descriptor_binding_acceleration_structure_update_after_bind( mut self, descriptor_binding_acceleration_structure_update_after_bind: bool, ) -> Self37023     pub fn descriptor_binding_acceleration_structure_update_after_bind(
37024         mut self,
37025         descriptor_binding_acceleration_structure_update_after_bind: bool,
37026     ) -> Self {
37027         self.inner
37028             .descriptor_binding_acceleration_structure_update_after_bind =
37029             descriptor_binding_acceleration_structure_update_after_bind.into();
37030         self
37031     }
37032     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37033     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37034     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceAccelerationStructureFeaturesKHR37035     pub fn build(self) -> PhysicalDeviceAccelerationStructureFeaturesKHR {
37036         self.inner
37037     }
37038 }
37039 #[repr(C)]
37040 #[cfg_attr(feature = "debug", derive(Debug))]
37041 #[derive(Copy, Clone)]
37042 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingPipelineFeaturesKHR.html>"]
37043 pub struct PhysicalDeviceRayTracingPipelineFeaturesKHR {
37044     pub s_type: StructureType,
37045     pub p_next: *mut c_void,
37046     pub ray_tracing_pipeline: Bool32,
37047     pub ray_tracing_pipeline_shader_group_handle_capture_replay: Bool32,
37048     pub ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: Bool32,
37049     pub ray_tracing_pipeline_trace_rays_indirect: Bool32,
37050     pub ray_traversal_primitive_culling: Bool32,
37051 }
37052 impl ::std::default::Default for PhysicalDeviceRayTracingPipelineFeaturesKHR {
37053     #[inline]
default() -> Self37054     fn default() -> Self {
37055         Self {
37056             s_type: Self::STRUCTURE_TYPE,
37057             p_next: ::std::ptr::null_mut(),
37058             ray_tracing_pipeline: Bool32::default(),
37059             ray_tracing_pipeline_shader_group_handle_capture_replay: Bool32::default(),
37060             ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: Bool32::default(),
37061             ray_tracing_pipeline_trace_rays_indirect: Bool32::default(),
37062             ray_traversal_primitive_culling: Bool32::default(),
37063         }
37064     }
37065 }
37066 unsafe impl TaggedStructure for PhysicalDeviceRayTracingPipelineFeaturesKHR {
37067     const STRUCTURE_TYPE: StructureType =
37068         StructureType::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
37069 }
37070 impl PhysicalDeviceRayTracingPipelineFeaturesKHR {
builder<'a>() -> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a>37071     pub fn builder<'a>() -> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
37072         PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder {
37073             inner: Self::default(),
37074             marker: ::std::marker::PhantomData,
37075         }
37076     }
37077 }
37078 #[repr(transparent)]
37079 pub struct PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
37080     inner: PhysicalDeviceRayTracingPipelineFeaturesKHR,
37081     marker: ::std::marker::PhantomData<&'a ()>,
37082 }
37083 unsafe impl ExtendsPhysicalDeviceFeatures2
37084     for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'_>
37085 {
37086 }
37087 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingPipelineFeaturesKHR {}
37088 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'_> {}
37089 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingPipelineFeaturesKHR {}
37090 impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
37091     type Target = PhysicalDeviceRayTracingPipelineFeaturesKHR;
deref(&self) -> &Self::Target37092     fn deref(&self) -> &Self::Target {
37093         &self.inner
37094     }
37095 }
37096 impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target37097     fn deref_mut(&mut self) -> &mut Self::Target {
37098         &mut self.inner
37099     }
37100 }
37101 impl<'a> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
37102     #[inline]
ray_tracing_pipeline(mut self, ray_tracing_pipeline: bool) -> Self37103     pub fn ray_tracing_pipeline(mut self, ray_tracing_pipeline: bool) -> Self {
37104         self.inner.ray_tracing_pipeline = ray_tracing_pipeline.into();
37105         self
37106     }
37107     #[inline]
ray_tracing_pipeline_shader_group_handle_capture_replay( mut self, ray_tracing_pipeline_shader_group_handle_capture_replay: bool, ) -> Self37108     pub fn ray_tracing_pipeline_shader_group_handle_capture_replay(
37109         mut self,
37110         ray_tracing_pipeline_shader_group_handle_capture_replay: bool,
37111     ) -> Self {
37112         self.inner
37113             .ray_tracing_pipeline_shader_group_handle_capture_replay =
37114             ray_tracing_pipeline_shader_group_handle_capture_replay.into();
37115         self
37116     }
37117     #[inline]
ray_tracing_pipeline_shader_group_handle_capture_replay_mixed( mut self, ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: bool, ) -> Self37118     pub fn ray_tracing_pipeline_shader_group_handle_capture_replay_mixed(
37119         mut self,
37120         ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: bool,
37121     ) -> Self {
37122         self.inner
37123             .ray_tracing_pipeline_shader_group_handle_capture_replay_mixed =
37124             ray_tracing_pipeline_shader_group_handle_capture_replay_mixed.into();
37125         self
37126     }
37127     #[inline]
ray_tracing_pipeline_trace_rays_indirect( mut self, ray_tracing_pipeline_trace_rays_indirect: bool, ) -> Self37128     pub fn ray_tracing_pipeline_trace_rays_indirect(
37129         mut self,
37130         ray_tracing_pipeline_trace_rays_indirect: bool,
37131     ) -> Self {
37132         self.inner.ray_tracing_pipeline_trace_rays_indirect =
37133             ray_tracing_pipeline_trace_rays_indirect.into();
37134         self
37135     }
37136     #[inline]
ray_traversal_primitive_culling( mut self, ray_traversal_primitive_culling: bool, ) -> Self37137     pub fn ray_traversal_primitive_culling(
37138         mut self,
37139         ray_traversal_primitive_culling: bool,
37140     ) -> Self {
37141         self.inner.ray_traversal_primitive_culling = ray_traversal_primitive_culling.into();
37142         self
37143     }
37144     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37145     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37146     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceRayTracingPipelineFeaturesKHR37147     pub fn build(self) -> PhysicalDeviceRayTracingPipelineFeaturesKHR {
37148         self.inner
37149     }
37150 }
37151 #[repr(C)]
37152 #[cfg_attr(feature = "debug", derive(Debug))]
37153 #[derive(Copy, Clone)]
37154 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayQueryFeaturesKHR.html>"]
37155 pub struct PhysicalDeviceRayQueryFeaturesKHR {
37156     pub s_type: StructureType,
37157     pub p_next: *mut c_void,
37158     pub ray_query: Bool32,
37159 }
37160 impl ::std::default::Default for PhysicalDeviceRayQueryFeaturesKHR {
37161     #[inline]
default() -> Self37162     fn default() -> Self {
37163         Self {
37164             s_type: Self::STRUCTURE_TYPE,
37165             p_next: ::std::ptr::null_mut(),
37166             ray_query: Bool32::default(),
37167         }
37168     }
37169 }
37170 unsafe impl TaggedStructure for PhysicalDeviceRayQueryFeaturesKHR {
37171     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
37172 }
37173 impl PhysicalDeviceRayQueryFeaturesKHR {
builder<'a>() -> PhysicalDeviceRayQueryFeaturesKHRBuilder<'a>37174     pub fn builder<'a>() -> PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
37175         PhysicalDeviceRayQueryFeaturesKHRBuilder {
37176             inner: Self::default(),
37177             marker: ::std::marker::PhantomData,
37178         }
37179     }
37180 }
37181 #[repr(transparent)]
37182 pub struct PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
37183     inner: PhysicalDeviceRayQueryFeaturesKHR,
37184     marker: ::std::marker::PhantomData<&'a ()>,
37185 }
37186 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayQueryFeaturesKHRBuilder<'_> {}
37187 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayQueryFeaturesKHR {}
37188 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayQueryFeaturesKHRBuilder<'_> {}
37189 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayQueryFeaturesKHR {}
37190 impl<'a> ::std::ops::Deref for PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
37191     type Target = PhysicalDeviceRayQueryFeaturesKHR;
deref(&self) -> &Self::Target37192     fn deref(&self) -> &Self::Target {
37193         &self.inner
37194     }
37195 }
37196 impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target37197     fn deref_mut(&mut self) -> &mut Self::Target {
37198         &mut self.inner
37199     }
37200 }
37201 impl<'a> PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
37202     #[inline]
ray_query(mut self, ray_query: bool) -> Self37203     pub fn ray_query(mut self, ray_query: bool) -> Self {
37204         self.inner.ray_query = ray_query.into();
37205         self
37206     }
37207     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37208     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37209     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceRayQueryFeaturesKHR37210     pub fn build(self) -> PhysicalDeviceRayQueryFeaturesKHR {
37211         self.inner
37212     }
37213 }
37214 #[repr(C)]
37215 #[cfg_attr(feature = "debug", derive(Debug))]
37216 #[derive(Copy, Clone)]
37217 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceAccelerationStructurePropertiesKHR.html>"]
37218 pub struct PhysicalDeviceAccelerationStructurePropertiesKHR {
37219     pub s_type: StructureType,
37220     pub p_next: *mut c_void,
37221     pub max_geometry_count: u64,
37222     pub max_instance_count: u64,
37223     pub max_primitive_count: u64,
37224     pub max_per_stage_descriptor_acceleration_structures: u32,
37225     pub max_per_stage_descriptor_update_after_bind_acceleration_structures: u32,
37226     pub max_descriptor_set_acceleration_structures: u32,
37227     pub max_descriptor_set_update_after_bind_acceleration_structures: u32,
37228     pub min_acceleration_structure_scratch_offset_alignment: u32,
37229 }
37230 impl ::std::default::Default for PhysicalDeviceAccelerationStructurePropertiesKHR {
37231     #[inline]
default() -> Self37232     fn default() -> Self {
37233         Self {
37234             s_type: Self::STRUCTURE_TYPE,
37235             p_next: ::std::ptr::null_mut(),
37236             max_geometry_count: u64::default(),
37237             max_instance_count: u64::default(),
37238             max_primitive_count: u64::default(),
37239             max_per_stage_descriptor_acceleration_structures: u32::default(),
37240             max_per_stage_descriptor_update_after_bind_acceleration_structures: u32::default(),
37241             max_descriptor_set_acceleration_structures: u32::default(),
37242             max_descriptor_set_update_after_bind_acceleration_structures: u32::default(),
37243             min_acceleration_structure_scratch_offset_alignment: u32::default(),
37244         }
37245     }
37246 }
37247 unsafe impl TaggedStructure for PhysicalDeviceAccelerationStructurePropertiesKHR {
37248     const STRUCTURE_TYPE: StructureType =
37249         StructureType::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR;
37250 }
37251 impl PhysicalDeviceAccelerationStructurePropertiesKHR {
builder<'a>() -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a>37252     pub fn builder<'a>() -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
37253         PhysicalDeviceAccelerationStructurePropertiesKHRBuilder {
37254             inner: Self::default(),
37255             marker: ::std::marker::PhantomData,
37256         }
37257     }
37258 }
37259 #[repr(transparent)]
37260 pub struct PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
37261     inner: PhysicalDeviceAccelerationStructurePropertiesKHR,
37262     marker: ::std::marker::PhantomData<&'a ()>,
37263 }
37264 unsafe impl ExtendsPhysicalDeviceProperties2
37265     for PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'_>
37266 {
37267 }
37268 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceAccelerationStructurePropertiesKHR {}
37269 impl<'a> ::std::ops::Deref for PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
37270     type Target = PhysicalDeviceAccelerationStructurePropertiesKHR;
deref(&self) -> &Self::Target37271     fn deref(&self) -> &Self::Target {
37272         &self.inner
37273     }
37274 }
37275 impl<'a> ::std::ops::DerefMut for PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target37276     fn deref_mut(&mut self) -> &mut Self::Target {
37277         &mut self.inner
37278     }
37279 }
37280 impl<'a> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
37281     #[inline]
max_geometry_count(mut self, max_geometry_count: u64) -> Self37282     pub fn max_geometry_count(mut self, max_geometry_count: u64) -> Self {
37283         self.inner.max_geometry_count = max_geometry_count;
37284         self
37285     }
37286     #[inline]
max_instance_count(mut self, max_instance_count: u64) -> Self37287     pub fn max_instance_count(mut self, max_instance_count: u64) -> Self {
37288         self.inner.max_instance_count = max_instance_count;
37289         self
37290     }
37291     #[inline]
max_primitive_count(mut self, max_primitive_count: u64) -> Self37292     pub fn max_primitive_count(mut self, max_primitive_count: u64) -> Self {
37293         self.inner.max_primitive_count = max_primitive_count;
37294         self
37295     }
37296     #[inline]
max_per_stage_descriptor_acceleration_structures( mut self, max_per_stage_descriptor_acceleration_structures: u32, ) -> Self37297     pub fn max_per_stage_descriptor_acceleration_structures(
37298         mut self,
37299         max_per_stage_descriptor_acceleration_structures: u32,
37300     ) -> Self {
37301         self.inner.max_per_stage_descriptor_acceleration_structures =
37302             max_per_stage_descriptor_acceleration_structures;
37303         self
37304     }
37305     #[inline]
max_per_stage_descriptor_update_after_bind_acceleration_structures( mut self, max_per_stage_descriptor_update_after_bind_acceleration_structures: u32, ) -> Self37306     pub fn max_per_stage_descriptor_update_after_bind_acceleration_structures(
37307         mut self,
37308         max_per_stage_descriptor_update_after_bind_acceleration_structures: u32,
37309     ) -> Self {
37310         self.inner
37311             .max_per_stage_descriptor_update_after_bind_acceleration_structures =
37312             max_per_stage_descriptor_update_after_bind_acceleration_structures;
37313         self
37314     }
37315     #[inline]
max_descriptor_set_acceleration_structures( mut self, max_descriptor_set_acceleration_structures: u32, ) -> Self37316     pub fn max_descriptor_set_acceleration_structures(
37317         mut self,
37318         max_descriptor_set_acceleration_structures: u32,
37319     ) -> Self {
37320         self.inner.max_descriptor_set_acceleration_structures =
37321             max_descriptor_set_acceleration_structures;
37322         self
37323     }
37324     #[inline]
max_descriptor_set_update_after_bind_acceleration_structures( mut self, max_descriptor_set_update_after_bind_acceleration_structures: u32, ) -> Self37325     pub fn max_descriptor_set_update_after_bind_acceleration_structures(
37326         mut self,
37327         max_descriptor_set_update_after_bind_acceleration_structures: u32,
37328     ) -> Self {
37329         self.inner
37330             .max_descriptor_set_update_after_bind_acceleration_structures =
37331             max_descriptor_set_update_after_bind_acceleration_structures;
37332         self
37333     }
37334     #[inline]
min_acceleration_structure_scratch_offset_alignment( mut self, min_acceleration_structure_scratch_offset_alignment: u32, ) -> Self37335     pub fn min_acceleration_structure_scratch_offset_alignment(
37336         mut self,
37337         min_acceleration_structure_scratch_offset_alignment: u32,
37338     ) -> Self {
37339         self.inner
37340             .min_acceleration_structure_scratch_offset_alignment =
37341             min_acceleration_structure_scratch_offset_alignment;
37342         self
37343     }
37344     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37345     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37346     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceAccelerationStructurePropertiesKHR37347     pub fn build(self) -> PhysicalDeviceAccelerationStructurePropertiesKHR {
37348         self.inner
37349     }
37350 }
37351 #[repr(C)]
37352 #[cfg_attr(feature = "debug", derive(Debug))]
37353 #[derive(Copy, Clone)]
37354 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingPipelinePropertiesKHR.html>"]
37355 pub struct PhysicalDeviceRayTracingPipelinePropertiesKHR {
37356     pub s_type: StructureType,
37357     pub p_next: *mut c_void,
37358     pub shader_group_handle_size: u32,
37359     pub max_ray_recursion_depth: u32,
37360     pub max_shader_group_stride: u32,
37361     pub shader_group_base_alignment: u32,
37362     pub shader_group_handle_capture_replay_size: u32,
37363     pub max_ray_dispatch_invocation_count: u32,
37364     pub shader_group_handle_alignment: u32,
37365     pub max_ray_hit_attribute_size: u32,
37366 }
37367 impl ::std::default::Default for PhysicalDeviceRayTracingPipelinePropertiesKHR {
37368     #[inline]
default() -> Self37369     fn default() -> Self {
37370         Self {
37371             s_type: Self::STRUCTURE_TYPE,
37372             p_next: ::std::ptr::null_mut(),
37373             shader_group_handle_size: u32::default(),
37374             max_ray_recursion_depth: u32::default(),
37375             max_shader_group_stride: u32::default(),
37376             shader_group_base_alignment: u32::default(),
37377             shader_group_handle_capture_replay_size: u32::default(),
37378             max_ray_dispatch_invocation_count: u32::default(),
37379             shader_group_handle_alignment: u32::default(),
37380             max_ray_hit_attribute_size: u32::default(),
37381         }
37382     }
37383 }
37384 unsafe impl TaggedStructure for PhysicalDeviceRayTracingPipelinePropertiesKHR {
37385     const STRUCTURE_TYPE: StructureType =
37386         StructureType::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR;
37387 }
37388 impl PhysicalDeviceRayTracingPipelinePropertiesKHR {
builder<'a>() -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a>37389     pub fn builder<'a>() -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
37390         PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder {
37391             inner: Self::default(),
37392             marker: ::std::marker::PhantomData,
37393         }
37394     }
37395 }
37396 #[repr(transparent)]
37397 pub struct PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
37398     inner: PhysicalDeviceRayTracingPipelinePropertiesKHR,
37399     marker: ::std::marker::PhantomData<&'a ()>,
37400 }
37401 unsafe impl ExtendsPhysicalDeviceProperties2
37402     for PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'_>
37403 {
37404 }
37405 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPipelinePropertiesKHR {}
37406 impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
37407     type Target = PhysicalDeviceRayTracingPipelinePropertiesKHR;
deref(&self) -> &Self::Target37408     fn deref(&self) -> &Self::Target {
37409         &self.inner
37410     }
37411 }
37412 impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target37413     fn deref_mut(&mut self) -> &mut Self::Target {
37414         &mut self.inner
37415     }
37416 }
37417 impl<'a> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
37418     #[inline]
shader_group_handle_size(mut self, shader_group_handle_size: u32) -> Self37419     pub fn shader_group_handle_size(mut self, shader_group_handle_size: u32) -> Self {
37420         self.inner.shader_group_handle_size = shader_group_handle_size;
37421         self
37422     }
37423     #[inline]
max_ray_recursion_depth(mut self, max_ray_recursion_depth: u32) -> Self37424     pub fn max_ray_recursion_depth(mut self, max_ray_recursion_depth: u32) -> Self {
37425         self.inner.max_ray_recursion_depth = max_ray_recursion_depth;
37426         self
37427     }
37428     #[inline]
max_shader_group_stride(mut self, max_shader_group_stride: u32) -> Self37429     pub fn max_shader_group_stride(mut self, max_shader_group_stride: u32) -> Self {
37430         self.inner.max_shader_group_stride = max_shader_group_stride;
37431         self
37432     }
37433     #[inline]
shader_group_base_alignment(mut self, shader_group_base_alignment: u32) -> Self37434     pub fn shader_group_base_alignment(mut self, shader_group_base_alignment: u32) -> Self {
37435         self.inner.shader_group_base_alignment = shader_group_base_alignment;
37436         self
37437     }
37438     #[inline]
shader_group_handle_capture_replay_size( mut self, shader_group_handle_capture_replay_size: u32, ) -> Self37439     pub fn shader_group_handle_capture_replay_size(
37440         mut self,
37441         shader_group_handle_capture_replay_size: u32,
37442     ) -> Self {
37443         self.inner.shader_group_handle_capture_replay_size =
37444             shader_group_handle_capture_replay_size;
37445         self
37446     }
37447     #[inline]
max_ray_dispatch_invocation_count( mut self, max_ray_dispatch_invocation_count: u32, ) -> Self37448     pub fn max_ray_dispatch_invocation_count(
37449         mut self,
37450         max_ray_dispatch_invocation_count: u32,
37451     ) -> Self {
37452         self.inner.max_ray_dispatch_invocation_count = max_ray_dispatch_invocation_count;
37453         self
37454     }
37455     #[inline]
shader_group_handle_alignment(mut self, shader_group_handle_alignment: u32) -> Self37456     pub fn shader_group_handle_alignment(mut self, shader_group_handle_alignment: u32) -> Self {
37457         self.inner.shader_group_handle_alignment = shader_group_handle_alignment;
37458         self
37459     }
37460     #[inline]
max_ray_hit_attribute_size(mut self, max_ray_hit_attribute_size: u32) -> Self37461     pub fn max_ray_hit_attribute_size(mut self, max_ray_hit_attribute_size: u32) -> Self {
37462         self.inner.max_ray_hit_attribute_size = max_ray_hit_attribute_size;
37463         self
37464     }
37465     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37466     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37467     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceRayTracingPipelinePropertiesKHR37468     pub fn build(self) -> PhysicalDeviceRayTracingPipelinePropertiesKHR {
37469         self.inner
37470     }
37471 }
37472 #[repr(C)]
37473 #[cfg_attr(feature = "debug", derive(Debug))]
37474 #[derive(Copy, Clone)]
37475 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingPropertiesNV.html>"]
37476 pub struct PhysicalDeviceRayTracingPropertiesNV {
37477     pub s_type: StructureType,
37478     pub p_next: *mut c_void,
37479     pub shader_group_handle_size: u32,
37480     pub max_recursion_depth: u32,
37481     pub max_shader_group_stride: u32,
37482     pub shader_group_base_alignment: u32,
37483     pub max_geometry_count: u64,
37484     pub max_instance_count: u64,
37485     pub max_triangle_count: u64,
37486     pub max_descriptor_set_acceleration_structures: u32,
37487 }
37488 impl ::std::default::Default for PhysicalDeviceRayTracingPropertiesNV {
37489     #[inline]
default() -> Self37490     fn default() -> Self {
37491         Self {
37492             s_type: Self::STRUCTURE_TYPE,
37493             p_next: ::std::ptr::null_mut(),
37494             shader_group_handle_size: u32::default(),
37495             max_recursion_depth: u32::default(),
37496             max_shader_group_stride: u32::default(),
37497             shader_group_base_alignment: u32::default(),
37498             max_geometry_count: u64::default(),
37499             max_instance_count: u64::default(),
37500             max_triangle_count: u64::default(),
37501             max_descriptor_set_acceleration_structures: u32::default(),
37502         }
37503     }
37504 }
37505 unsafe impl TaggedStructure for PhysicalDeviceRayTracingPropertiesNV {
37506     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV;
37507 }
37508 impl PhysicalDeviceRayTracingPropertiesNV {
builder<'a>() -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a>37509     pub fn builder<'a>() -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
37510         PhysicalDeviceRayTracingPropertiesNVBuilder {
37511             inner: Self::default(),
37512             marker: ::std::marker::PhantomData,
37513         }
37514     }
37515 }
37516 #[repr(transparent)]
37517 pub struct PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
37518     inner: PhysicalDeviceRayTracingPropertiesNV,
37519     marker: ::std::marker::PhantomData<&'a ()>,
37520 }
37521 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPropertiesNVBuilder<'_> {}
37522 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPropertiesNV {}
37523 impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
37524     type Target = PhysicalDeviceRayTracingPropertiesNV;
deref(&self) -> &Self::Target37525     fn deref(&self) -> &Self::Target {
37526         &self.inner
37527     }
37528 }
37529 impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target37530     fn deref_mut(&mut self) -> &mut Self::Target {
37531         &mut self.inner
37532     }
37533 }
37534 impl<'a> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
37535     #[inline]
shader_group_handle_size(mut self, shader_group_handle_size: u32) -> Self37536     pub fn shader_group_handle_size(mut self, shader_group_handle_size: u32) -> Self {
37537         self.inner.shader_group_handle_size = shader_group_handle_size;
37538         self
37539     }
37540     #[inline]
max_recursion_depth(mut self, max_recursion_depth: u32) -> Self37541     pub fn max_recursion_depth(mut self, max_recursion_depth: u32) -> Self {
37542         self.inner.max_recursion_depth = max_recursion_depth;
37543         self
37544     }
37545     #[inline]
max_shader_group_stride(mut self, max_shader_group_stride: u32) -> Self37546     pub fn max_shader_group_stride(mut self, max_shader_group_stride: u32) -> Self {
37547         self.inner.max_shader_group_stride = max_shader_group_stride;
37548         self
37549     }
37550     #[inline]
shader_group_base_alignment(mut self, shader_group_base_alignment: u32) -> Self37551     pub fn shader_group_base_alignment(mut self, shader_group_base_alignment: u32) -> Self {
37552         self.inner.shader_group_base_alignment = shader_group_base_alignment;
37553         self
37554     }
37555     #[inline]
max_geometry_count(mut self, max_geometry_count: u64) -> Self37556     pub fn max_geometry_count(mut self, max_geometry_count: u64) -> Self {
37557         self.inner.max_geometry_count = max_geometry_count;
37558         self
37559     }
37560     #[inline]
max_instance_count(mut self, max_instance_count: u64) -> Self37561     pub fn max_instance_count(mut self, max_instance_count: u64) -> Self {
37562         self.inner.max_instance_count = max_instance_count;
37563         self
37564     }
37565     #[inline]
max_triangle_count(mut self, max_triangle_count: u64) -> Self37566     pub fn max_triangle_count(mut self, max_triangle_count: u64) -> Self {
37567         self.inner.max_triangle_count = max_triangle_count;
37568         self
37569     }
37570     #[inline]
max_descriptor_set_acceleration_structures( mut self, max_descriptor_set_acceleration_structures: u32, ) -> Self37571     pub fn max_descriptor_set_acceleration_structures(
37572         mut self,
37573         max_descriptor_set_acceleration_structures: u32,
37574     ) -> Self {
37575         self.inner.max_descriptor_set_acceleration_structures =
37576             max_descriptor_set_acceleration_structures;
37577         self
37578     }
37579     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37580     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37581     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceRayTracingPropertiesNV37582     pub fn build(self) -> PhysicalDeviceRayTracingPropertiesNV {
37583         self.inner
37584     }
37585 }
37586 #[repr(C)]
37587 #[cfg_attr(feature = "debug", derive(Debug))]
37588 #[derive(Copy, Clone, Default)]
37589 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkStridedDeviceAddressRegionKHR.html>"]
37590 pub struct StridedDeviceAddressRegionKHR {
37591     pub device_address: DeviceAddress,
37592     pub stride: DeviceSize,
37593     pub size: DeviceSize,
37594 }
37595 impl StridedDeviceAddressRegionKHR {
builder<'a>() -> StridedDeviceAddressRegionKHRBuilder<'a>37596     pub fn builder<'a>() -> StridedDeviceAddressRegionKHRBuilder<'a> {
37597         StridedDeviceAddressRegionKHRBuilder {
37598             inner: Self::default(),
37599             marker: ::std::marker::PhantomData,
37600         }
37601     }
37602 }
37603 #[repr(transparent)]
37604 pub struct StridedDeviceAddressRegionKHRBuilder<'a> {
37605     inner: StridedDeviceAddressRegionKHR,
37606     marker: ::std::marker::PhantomData<&'a ()>,
37607 }
37608 impl<'a> ::std::ops::Deref for StridedDeviceAddressRegionKHRBuilder<'a> {
37609     type Target = StridedDeviceAddressRegionKHR;
deref(&self) -> &Self::Target37610     fn deref(&self) -> &Self::Target {
37611         &self.inner
37612     }
37613 }
37614 impl<'a> ::std::ops::DerefMut for StridedDeviceAddressRegionKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target37615     fn deref_mut(&mut self) -> &mut Self::Target {
37616         &mut self.inner
37617     }
37618 }
37619 impl<'a> StridedDeviceAddressRegionKHRBuilder<'a> {
37620     #[inline]
device_address(mut self, device_address: DeviceAddress) -> Self37621     pub fn device_address(mut self, device_address: DeviceAddress) -> Self {
37622         self.inner.device_address = device_address;
37623         self
37624     }
37625     #[inline]
stride(mut self, stride: DeviceSize) -> Self37626     pub fn stride(mut self, stride: DeviceSize) -> Self {
37627         self.inner.stride = stride;
37628         self
37629     }
37630     #[inline]
size(mut self, size: DeviceSize) -> Self37631     pub fn size(mut self, size: DeviceSize) -> Self {
37632         self.inner.size = size;
37633         self
37634     }
37635     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37636     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37637     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> StridedDeviceAddressRegionKHR37638     pub fn build(self) -> StridedDeviceAddressRegionKHR {
37639         self.inner
37640     }
37641 }
37642 #[repr(C)]
37643 #[cfg_attr(feature = "debug", derive(Debug))]
37644 #[derive(Copy, Clone, Default)]
37645 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkTraceRaysIndirectCommandKHR.html>"]
37646 pub struct TraceRaysIndirectCommandKHR {
37647     pub width: u32,
37648     pub height: u32,
37649     pub depth: u32,
37650 }
37651 impl TraceRaysIndirectCommandKHR {
builder<'a>() -> TraceRaysIndirectCommandKHRBuilder<'a>37652     pub fn builder<'a>() -> TraceRaysIndirectCommandKHRBuilder<'a> {
37653         TraceRaysIndirectCommandKHRBuilder {
37654             inner: Self::default(),
37655             marker: ::std::marker::PhantomData,
37656         }
37657     }
37658 }
37659 #[repr(transparent)]
37660 pub struct TraceRaysIndirectCommandKHRBuilder<'a> {
37661     inner: TraceRaysIndirectCommandKHR,
37662     marker: ::std::marker::PhantomData<&'a ()>,
37663 }
37664 impl<'a> ::std::ops::Deref for TraceRaysIndirectCommandKHRBuilder<'a> {
37665     type Target = TraceRaysIndirectCommandKHR;
deref(&self) -> &Self::Target37666     fn deref(&self) -> &Self::Target {
37667         &self.inner
37668     }
37669 }
37670 impl<'a> ::std::ops::DerefMut for TraceRaysIndirectCommandKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target37671     fn deref_mut(&mut self) -> &mut Self::Target {
37672         &mut self.inner
37673     }
37674 }
37675 impl<'a> TraceRaysIndirectCommandKHRBuilder<'a> {
37676     #[inline]
width(mut self, width: u32) -> Self37677     pub fn width(mut self, width: u32) -> Self {
37678         self.inner.width = width;
37679         self
37680     }
37681     #[inline]
height(mut self, height: u32) -> Self37682     pub fn height(mut self, height: u32) -> Self {
37683         self.inner.height = height;
37684         self
37685     }
37686     #[inline]
depth(mut self, depth: u32) -> Self37687     pub fn depth(mut self, depth: u32) -> Self {
37688         self.inner.depth = depth;
37689         self
37690     }
37691     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37692     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37693     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> TraceRaysIndirectCommandKHR37694     pub fn build(self) -> TraceRaysIndirectCommandKHR {
37695         self.inner
37696     }
37697 }
37698 #[repr(C)]
37699 #[cfg_attr(feature = "debug", derive(Debug))]
37700 #[derive(Copy, Clone, Default)]
37701 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkTraceRaysIndirectCommand2KHR.html>"]
37702 pub struct TraceRaysIndirectCommand2KHR {
37703     pub raygen_shader_record_address: DeviceAddress,
37704     pub raygen_shader_record_size: DeviceSize,
37705     pub miss_shader_binding_table_address: DeviceAddress,
37706     pub miss_shader_binding_table_size: DeviceSize,
37707     pub miss_shader_binding_table_stride: DeviceSize,
37708     pub hit_shader_binding_table_address: DeviceAddress,
37709     pub hit_shader_binding_table_size: DeviceSize,
37710     pub hit_shader_binding_table_stride: DeviceSize,
37711     pub callable_shader_binding_table_address: DeviceAddress,
37712     pub callable_shader_binding_table_size: DeviceSize,
37713     pub callable_shader_binding_table_stride: DeviceSize,
37714     pub width: u32,
37715     pub height: u32,
37716     pub depth: u32,
37717 }
37718 impl TraceRaysIndirectCommand2KHR {
builder<'a>() -> TraceRaysIndirectCommand2KHRBuilder<'a>37719     pub fn builder<'a>() -> TraceRaysIndirectCommand2KHRBuilder<'a> {
37720         TraceRaysIndirectCommand2KHRBuilder {
37721             inner: Self::default(),
37722             marker: ::std::marker::PhantomData,
37723         }
37724     }
37725 }
37726 #[repr(transparent)]
37727 pub struct TraceRaysIndirectCommand2KHRBuilder<'a> {
37728     inner: TraceRaysIndirectCommand2KHR,
37729     marker: ::std::marker::PhantomData<&'a ()>,
37730 }
37731 impl<'a> ::std::ops::Deref for TraceRaysIndirectCommand2KHRBuilder<'a> {
37732     type Target = TraceRaysIndirectCommand2KHR;
deref(&self) -> &Self::Target37733     fn deref(&self) -> &Self::Target {
37734         &self.inner
37735     }
37736 }
37737 impl<'a> ::std::ops::DerefMut for TraceRaysIndirectCommand2KHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target37738     fn deref_mut(&mut self) -> &mut Self::Target {
37739         &mut self.inner
37740     }
37741 }
37742 impl<'a> TraceRaysIndirectCommand2KHRBuilder<'a> {
37743     #[inline]
raygen_shader_record_address( mut self, raygen_shader_record_address: DeviceAddress, ) -> Self37744     pub fn raygen_shader_record_address(
37745         mut self,
37746         raygen_shader_record_address: DeviceAddress,
37747     ) -> Self {
37748         self.inner.raygen_shader_record_address = raygen_shader_record_address;
37749         self
37750     }
37751     #[inline]
raygen_shader_record_size(mut self, raygen_shader_record_size: DeviceSize) -> Self37752     pub fn raygen_shader_record_size(mut self, raygen_shader_record_size: DeviceSize) -> Self {
37753         self.inner.raygen_shader_record_size = raygen_shader_record_size;
37754         self
37755     }
37756     #[inline]
miss_shader_binding_table_address( mut self, miss_shader_binding_table_address: DeviceAddress, ) -> Self37757     pub fn miss_shader_binding_table_address(
37758         mut self,
37759         miss_shader_binding_table_address: DeviceAddress,
37760     ) -> Self {
37761         self.inner.miss_shader_binding_table_address = miss_shader_binding_table_address;
37762         self
37763     }
37764     #[inline]
miss_shader_binding_table_size( mut self, miss_shader_binding_table_size: DeviceSize, ) -> Self37765     pub fn miss_shader_binding_table_size(
37766         mut self,
37767         miss_shader_binding_table_size: DeviceSize,
37768     ) -> Self {
37769         self.inner.miss_shader_binding_table_size = miss_shader_binding_table_size;
37770         self
37771     }
37772     #[inline]
miss_shader_binding_table_stride( mut self, miss_shader_binding_table_stride: DeviceSize, ) -> Self37773     pub fn miss_shader_binding_table_stride(
37774         mut self,
37775         miss_shader_binding_table_stride: DeviceSize,
37776     ) -> Self {
37777         self.inner.miss_shader_binding_table_stride = miss_shader_binding_table_stride;
37778         self
37779     }
37780     #[inline]
hit_shader_binding_table_address( mut self, hit_shader_binding_table_address: DeviceAddress, ) -> Self37781     pub fn hit_shader_binding_table_address(
37782         mut self,
37783         hit_shader_binding_table_address: DeviceAddress,
37784     ) -> Self {
37785         self.inner.hit_shader_binding_table_address = hit_shader_binding_table_address;
37786         self
37787     }
37788     #[inline]
hit_shader_binding_table_size( mut self, hit_shader_binding_table_size: DeviceSize, ) -> Self37789     pub fn hit_shader_binding_table_size(
37790         mut self,
37791         hit_shader_binding_table_size: DeviceSize,
37792     ) -> Self {
37793         self.inner.hit_shader_binding_table_size = hit_shader_binding_table_size;
37794         self
37795     }
37796     #[inline]
hit_shader_binding_table_stride( mut self, hit_shader_binding_table_stride: DeviceSize, ) -> Self37797     pub fn hit_shader_binding_table_stride(
37798         mut self,
37799         hit_shader_binding_table_stride: DeviceSize,
37800     ) -> Self {
37801         self.inner.hit_shader_binding_table_stride = hit_shader_binding_table_stride;
37802         self
37803     }
37804     #[inline]
callable_shader_binding_table_address( mut self, callable_shader_binding_table_address: DeviceAddress, ) -> Self37805     pub fn callable_shader_binding_table_address(
37806         mut self,
37807         callable_shader_binding_table_address: DeviceAddress,
37808     ) -> Self {
37809         self.inner.callable_shader_binding_table_address = callable_shader_binding_table_address;
37810         self
37811     }
37812     #[inline]
callable_shader_binding_table_size( mut self, callable_shader_binding_table_size: DeviceSize, ) -> Self37813     pub fn callable_shader_binding_table_size(
37814         mut self,
37815         callable_shader_binding_table_size: DeviceSize,
37816     ) -> Self {
37817         self.inner.callable_shader_binding_table_size = callable_shader_binding_table_size;
37818         self
37819     }
37820     #[inline]
callable_shader_binding_table_stride( mut self, callable_shader_binding_table_stride: DeviceSize, ) -> Self37821     pub fn callable_shader_binding_table_stride(
37822         mut self,
37823         callable_shader_binding_table_stride: DeviceSize,
37824     ) -> Self {
37825         self.inner.callable_shader_binding_table_stride = callable_shader_binding_table_stride;
37826         self
37827     }
37828     #[inline]
width(mut self, width: u32) -> Self37829     pub fn width(mut self, width: u32) -> Self {
37830         self.inner.width = width;
37831         self
37832     }
37833     #[inline]
height(mut self, height: u32) -> Self37834     pub fn height(mut self, height: u32) -> Self {
37835         self.inner.height = height;
37836         self
37837     }
37838     #[inline]
depth(mut self, depth: u32) -> Self37839     pub fn depth(mut self, depth: u32) -> Self {
37840         self.inner.depth = depth;
37841         self
37842     }
37843     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37844     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37845     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> TraceRaysIndirectCommand2KHR37846     pub fn build(self) -> TraceRaysIndirectCommand2KHR {
37847         self.inner
37848     }
37849 }
37850 #[repr(C)]
37851 #[cfg_attr(feature = "debug", derive(Debug))]
37852 #[derive(Copy, Clone)]
37853 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR.html>"]
37854 pub struct PhysicalDeviceRayTracingMaintenance1FeaturesKHR {
37855     pub s_type: StructureType,
37856     pub p_next: *mut c_void,
37857     pub ray_tracing_maintenance1: Bool32,
37858     pub ray_tracing_pipeline_trace_rays_indirect2: Bool32,
37859 }
37860 impl ::std::default::Default for PhysicalDeviceRayTracingMaintenance1FeaturesKHR {
37861     #[inline]
default() -> Self37862     fn default() -> Self {
37863         Self {
37864             s_type: Self::STRUCTURE_TYPE,
37865             p_next: ::std::ptr::null_mut(),
37866             ray_tracing_maintenance1: Bool32::default(),
37867             ray_tracing_pipeline_trace_rays_indirect2: Bool32::default(),
37868         }
37869     }
37870 }
37871 unsafe impl TaggedStructure for PhysicalDeviceRayTracingMaintenance1FeaturesKHR {
37872     const STRUCTURE_TYPE: StructureType =
37873         StructureType::PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
37874 }
37875 impl PhysicalDeviceRayTracingMaintenance1FeaturesKHR {
builder<'a>() -> PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a>37876     pub fn builder<'a>() -> PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> {
37877         PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder {
37878             inner: Self::default(),
37879             marker: ::std::marker::PhantomData,
37880         }
37881     }
37882 }
37883 #[repr(transparent)]
37884 pub struct PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> {
37885     inner: PhysicalDeviceRayTracingMaintenance1FeaturesKHR,
37886     marker: ::std::marker::PhantomData<&'a ()>,
37887 }
37888 unsafe impl ExtendsPhysicalDeviceFeatures2
37889     for PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'_>
37890 {
37891 }
37892 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingMaintenance1FeaturesKHR {}
37893 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'_> {}
37894 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingMaintenance1FeaturesKHR {}
37895 impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> {
37896     type Target = PhysicalDeviceRayTracingMaintenance1FeaturesKHR;
deref(&self) -> &Self::Target37897     fn deref(&self) -> &Self::Target {
37898         &self.inner
37899     }
37900 }
37901 impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target37902     fn deref_mut(&mut self) -> &mut Self::Target {
37903         &mut self.inner
37904     }
37905 }
37906 impl<'a> PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> {
37907     #[inline]
ray_tracing_maintenance1(mut self, ray_tracing_maintenance1: bool) -> Self37908     pub fn ray_tracing_maintenance1(mut self, ray_tracing_maintenance1: bool) -> Self {
37909         self.inner.ray_tracing_maintenance1 = ray_tracing_maintenance1.into();
37910         self
37911     }
37912     #[inline]
ray_tracing_pipeline_trace_rays_indirect2( mut self, ray_tracing_pipeline_trace_rays_indirect2: bool, ) -> Self37913     pub fn ray_tracing_pipeline_trace_rays_indirect2(
37914         mut self,
37915         ray_tracing_pipeline_trace_rays_indirect2: bool,
37916     ) -> Self {
37917         self.inner.ray_tracing_pipeline_trace_rays_indirect2 =
37918             ray_tracing_pipeline_trace_rays_indirect2.into();
37919         self
37920     }
37921     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37922     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37923     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceRayTracingMaintenance1FeaturesKHR37924     pub fn build(self) -> PhysicalDeviceRayTracingMaintenance1FeaturesKHR {
37925         self.inner
37926     }
37927 }
37928 #[repr(C)]
37929 #[cfg_attr(feature = "debug", derive(Debug))]
37930 #[derive(Copy, Clone)]
37931 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrmFormatModifierPropertiesListEXT.html>"]
37932 pub struct DrmFormatModifierPropertiesListEXT {
37933     pub s_type: StructureType,
37934     pub p_next: *mut c_void,
37935     pub drm_format_modifier_count: u32,
37936     pub p_drm_format_modifier_properties: *mut DrmFormatModifierPropertiesEXT,
37937 }
37938 impl ::std::default::Default for DrmFormatModifierPropertiesListEXT {
37939     #[inline]
default() -> Self37940     fn default() -> Self {
37941         Self {
37942             s_type: Self::STRUCTURE_TYPE,
37943             p_next: ::std::ptr::null_mut(),
37944             drm_format_modifier_count: u32::default(),
37945             p_drm_format_modifier_properties: ::std::ptr::null_mut(),
37946         }
37947     }
37948 }
37949 unsafe impl TaggedStructure for DrmFormatModifierPropertiesListEXT {
37950     const STRUCTURE_TYPE: StructureType = StructureType::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT;
37951 }
37952 impl DrmFormatModifierPropertiesListEXT {
builder<'a>() -> DrmFormatModifierPropertiesListEXTBuilder<'a>37953     pub fn builder<'a>() -> DrmFormatModifierPropertiesListEXTBuilder<'a> {
37954         DrmFormatModifierPropertiesListEXTBuilder {
37955             inner: Self::default(),
37956             marker: ::std::marker::PhantomData,
37957         }
37958     }
37959 }
37960 #[repr(transparent)]
37961 pub struct DrmFormatModifierPropertiesListEXTBuilder<'a> {
37962     inner: DrmFormatModifierPropertiesListEXT,
37963     marker: ::std::marker::PhantomData<&'a ()>,
37964 }
37965 unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesListEXTBuilder<'_> {}
37966 unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesListEXT {}
37967 impl<'a> ::std::ops::Deref for DrmFormatModifierPropertiesListEXTBuilder<'a> {
37968     type Target = DrmFormatModifierPropertiesListEXT;
deref(&self) -> &Self::Target37969     fn deref(&self) -> &Self::Target {
37970         &self.inner
37971     }
37972 }
37973 impl<'a> ::std::ops::DerefMut for DrmFormatModifierPropertiesListEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target37974     fn deref_mut(&mut self) -> &mut Self::Target {
37975         &mut self.inner
37976     }
37977 }
37978 impl<'a> DrmFormatModifierPropertiesListEXTBuilder<'a> {
37979     #[inline]
drm_format_modifier_properties( mut self, drm_format_modifier_properties: &'a mut [DrmFormatModifierPropertiesEXT], ) -> Self37980     pub fn drm_format_modifier_properties(
37981         mut self,
37982         drm_format_modifier_properties: &'a mut [DrmFormatModifierPropertiesEXT],
37983     ) -> Self {
37984         self.inner.drm_format_modifier_count = drm_format_modifier_properties.len() as _;
37985         self.inner.p_drm_format_modifier_properties = drm_format_modifier_properties.as_mut_ptr();
37986         self
37987     }
37988     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37989     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37990     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DrmFormatModifierPropertiesListEXT37991     pub fn build(self) -> DrmFormatModifierPropertiesListEXT {
37992         self.inner
37993     }
37994 }
37995 #[repr(C)]
37996 #[cfg_attr(feature = "debug", derive(Debug))]
37997 #[derive(Copy, Clone, Default)]
37998 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrmFormatModifierPropertiesEXT.html>"]
37999 pub struct DrmFormatModifierPropertiesEXT {
38000     pub drm_format_modifier: u64,
38001     pub drm_format_modifier_plane_count: u32,
38002     pub drm_format_modifier_tiling_features: FormatFeatureFlags,
38003 }
38004 impl DrmFormatModifierPropertiesEXT {
builder<'a>() -> DrmFormatModifierPropertiesEXTBuilder<'a>38005     pub fn builder<'a>() -> DrmFormatModifierPropertiesEXTBuilder<'a> {
38006         DrmFormatModifierPropertiesEXTBuilder {
38007             inner: Self::default(),
38008             marker: ::std::marker::PhantomData,
38009         }
38010     }
38011 }
38012 #[repr(transparent)]
38013 pub struct DrmFormatModifierPropertiesEXTBuilder<'a> {
38014     inner: DrmFormatModifierPropertiesEXT,
38015     marker: ::std::marker::PhantomData<&'a ()>,
38016 }
38017 impl<'a> ::std::ops::Deref for DrmFormatModifierPropertiesEXTBuilder<'a> {
38018     type Target = DrmFormatModifierPropertiesEXT;
deref(&self) -> &Self::Target38019     fn deref(&self) -> &Self::Target {
38020         &self.inner
38021     }
38022 }
38023 impl<'a> ::std::ops::DerefMut for DrmFormatModifierPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target38024     fn deref_mut(&mut self) -> &mut Self::Target {
38025         &mut self.inner
38026     }
38027 }
38028 impl<'a> DrmFormatModifierPropertiesEXTBuilder<'a> {
38029     #[inline]
drm_format_modifier(mut self, drm_format_modifier: u64) -> Self38030     pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self {
38031         self.inner.drm_format_modifier = drm_format_modifier;
38032         self
38033     }
38034     #[inline]
drm_format_modifier_plane_count(mut self, drm_format_modifier_plane_count: u32) -> Self38035     pub fn drm_format_modifier_plane_count(mut self, drm_format_modifier_plane_count: u32) -> Self {
38036         self.inner.drm_format_modifier_plane_count = drm_format_modifier_plane_count;
38037         self
38038     }
38039     #[inline]
drm_format_modifier_tiling_features( mut self, drm_format_modifier_tiling_features: FormatFeatureFlags, ) -> Self38040     pub fn drm_format_modifier_tiling_features(
38041         mut self,
38042         drm_format_modifier_tiling_features: FormatFeatureFlags,
38043     ) -> Self {
38044         self.inner.drm_format_modifier_tiling_features = drm_format_modifier_tiling_features;
38045         self
38046     }
38047     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38048     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38049     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DrmFormatModifierPropertiesEXT38050     pub fn build(self) -> DrmFormatModifierPropertiesEXT {
38051         self.inner
38052     }
38053 }
38054 #[repr(C)]
38055 #[cfg_attr(feature = "debug", derive(Debug))]
38056 #[derive(Copy, Clone)]
38057 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageDrmFormatModifierInfoEXT.html>"]
38058 pub struct PhysicalDeviceImageDrmFormatModifierInfoEXT {
38059     pub s_type: StructureType,
38060     pub p_next: *const c_void,
38061     pub drm_format_modifier: u64,
38062     pub sharing_mode: SharingMode,
38063     pub queue_family_index_count: u32,
38064     pub p_queue_family_indices: *const u32,
38065 }
38066 impl ::std::default::Default for PhysicalDeviceImageDrmFormatModifierInfoEXT {
38067     #[inline]
default() -> Self38068     fn default() -> Self {
38069         Self {
38070             s_type: Self::STRUCTURE_TYPE,
38071             p_next: ::std::ptr::null(),
38072             drm_format_modifier: u64::default(),
38073             sharing_mode: SharingMode::default(),
38074             queue_family_index_count: u32::default(),
38075             p_queue_family_indices: ::std::ptr::null(),
38076         }
38077     }
38078 }
38079 unsafe impl TaggedStructure for PhysicalDeviceImageDrmFormatModifierInfoEXT {
38080     const STRUCTURE_TYPE: StructureType =
38081         StructureType::PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT;
38082 }
38083 impl PhysicalDeviceImageDrmFormatModifierInfoEXT {
builder<'a>() -> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a>38084     pub fn builder<'a>() -> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
38085         PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder {
38086             inner: Self::default(),
38087             marker: ::std::marker::PhantomData,
38088         }
38089     }
38090 }
38091 #[repr(transparent)]
38092 pub struct PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
38093     inner: PhysicalDeviceImageDrmFormatModifierInfoEXT,
38094     marker: ::std::marker::PhantomData<&'a ()>,
38095 }
38096 unsafe impl ExtendsPhysicalDeviceImageFormatInfo2
38097     for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'_>
38098 {
38099 }
38100 unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceImageDrmFormatModifierInfoEXT {}
38101 impl<'a> ::std::ops::Deref for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
38102     type Target = PhysicalDeviceImageDrmFormatModifierInfoEXT;
deref(&self) -> &Self::Target38103     fn deref(&self) -> &Self::Target {
38104         &self.inner
38105     }
38106 }
38107 impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target38108     fn deref_mut(&mut self) -> &mut Self::Target {
38109         &mut self.inner
38110     }
38111 }
38112 impl<'a> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
38113     #[inline]
drm_format_modifier(mut self, drm_format_modifier: u64) -> Self38114     pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self {
38115         self.inner.drm_format_modifier = drm_format_modifier;
38116         self
38117     }
38118     #[inline]
sharing_mode(mut self, sharing_mode: SharingMode) -> Self38119     pub fn sharing_mode(mut self, sharing_mode: SharingMode) -> Self {
38120         self.inner.sharing_mode = sharing_mode;
38121         self
38122     }
38123     #[inline]
queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self38124     pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self {
38125         self.inner.queue_family_index_count = queue_family_indices.len() as _;
38126         self.inner.p_queue_family_indices = queue_family_indices.as_ptr();
38127         self
38128     }
38129     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38130     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38131     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceImageDrmFormatModifierInfoEXT38132     pub fn build(self) -> PhysicalDeviceImageDrmFormatModifierInfoEXT {
38133         self.inner
38134     }
38135 }
38136 #[repr(C)]
38137 #[cfg_attr(feature = "debug", derive(Debug))]
38138 #[derive(Copy, Clone)]
38139 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageDrmFormatModifierListCreateInfoEXT.html>"]
38140 pub struct ImageDrmFormatModifierListCreateInfoEXT {
38141     pub s_type: StructureType,
38142     pub p_next: *const c_void,
38143     pub drm_format_modifier_count: u32,
38144     pub p_drm_format_modifiers: *const u64,
38145 }
38146 impl ::std::default::Default for ImageDrmFormatModifierListCreateInfoEXT {
38147     #[inline]
default() -> Self38148     fn default() -> Self {
38149         Self {
38150             s_type: Self::STRUCTURE_TYPE,
38151             p_next: ::std::ptr::null(),
38152             drm_format_modifier_count: u32::default(),
38153             p_drm_format_modifiers: ::std::ptr::null(),
38154         }
38155     }
38156 }
38157 unsafe impl TaggedStructure for ImageDrmFormatModifierListCreateInfoEXT {
38158     const STRUCTURE_TYPE: StructureType =
38159         StructureType::IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT;
38160 }
38161 impl ImageDrmFormatModifierListCreateInfoEXT {
builder<'a>() -> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a>38162     pub fn builder<'a>() -> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
38163         ImageDrmFormatModifierListCreateInfoEXTBuilder {
38164             inner: Self::default(),
38165             marker: ::std::marker::PhantomData,
38166         }
38167     }
38168 }
38169 #[repr(transparent)]
38170 pub struct ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
38171     inner: ImageDrmFormatModifierListCreateInfoEXT,
38172     marker: ::std::marker::PhantomData<&'a ()>,
38173 }
38174 unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierListCreateInfoEXTBuilder<'_> {}
38175 unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierListCreateInfoEXT {}
38176 impl<'a> ::std::ops::Deref for ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
38177     type Target = ImageDrmFormatModifierListCreateInfoEXT;
deref(&self) -> &Self::Target38178     fn deref(&self) -> &Self::Target {
38179         &self.inner
38180     }
38181 }
38182 impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target38183     fn deref_mut(&mut self) -> &mut Self::Target {
38184         &mut self.inner
38185     }
38186 }
38187 impl<'a> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
38188     #[inline]
drm_format_modifiers(mut self, drm_format_modifiers: &'a [u64]) -> Self38189     pub fn drm_format_modifiers(mut self, drm_format_modifiers: &'a [u64]) -> Self {
38190         self.inner.drm_format_modifier_count = drm_format_modifiers.len() as _;
38191         self.inner.p_drm_format_modifiers = drm_format_modifiers.as_ptr();
38192         self
38193     }
38194     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38195     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38196     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageDrmFormatModifierListCreateInfoEXT38197     pub fn build(self) -> ImageDrmFormatModifierListCreateInfoEXT {
38198         self.inner
38199     }
38200 }
38201 #[repr(C)]
38202 #[cfg_attr(feature = "debug", derive(Debug))]
38203 #[derive(Copy, Clone)]
38204 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageDrmFormatModifierExplicitCreateInfoEXT.html>"]
38205 pub struct ImageDrmFormatModifierExplicitCreateInfoEXT {
38206     pub s_type: StructureType,
38207     pub p_next: *const c_void,
38208     pub drm_format_modifier: u64,
38209     pub drm_format_modifier_plane_count: u32,
38210     pub p_plane_layouts: *const SubresourceLayout,
38211 }
38212 impl ::std::default::Default for ImageDrmFormatModifierExplicitCreateInfoEXT {
38213     #[inline]
default() -> Self38214     fn default() -> Self {
38215         Self {
38216             s_type: Self::STRUCTURE_TYPE,
38217             p_next: ::std::ptr::null(),
38218             drm_format_modifier: u64::default(),
38219             drm_format_modifier_plane_count: u32::default(),
38220             p_plane_layouts: ::std::ptr::null(),
38221         }
38222     }
38223 }
38224 unsafe impl TaggedStructure for ImageDrmFormatModifierExplicitCreateInfoEXT {
38225     const STRUCTURE_TYPE: StructureType =
38226         StructureType::IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT;
38227 }
38228 impl ImageDrmFormatModifierExplicitCreateInfoEXT {
builder<'a>() -> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a>38229     pub fn builder<'a>() -> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
38230         ImageDrmFormatModifierExplicitCreateInfoEXTBuilder {
38231             inner: Self::default(),
38232             marker: ::std::marker::PhantomData,
38233         }
38234     }
38235 }
38236 #[repr(transparent)]
38237 pub struct ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
38238     inner: ImageDrmFormatModifierExplicitCreateInfoEXT,
38239     marker: ::std::marker::PhantomData<&'a ()>,
38240 }
38241 unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'_> {}
38242 unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierExplicitCreateInfoEXT {}
38243 impl<'a> ::std::ops::Deref for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
38244     type Target = ImageDrmFormatModifierExplicitCreateInfoEXT;
deref(&self) -> &Self::Target38245     fn deref(&self) -> &Self::Target {
38246         &self.inner
38247     }
38248 }
38249 impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target38250     fn deref_mut(&mut self) -> &mut Self::Target {
38251         &mut self.inner
38252     }
38253 }
38254 impl<'a> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
38255     #[inline]
drm_format_modifier(mut self, drm_format_modifier: u64) -> Self38256     pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self {
38257         self.inner.drm_format_modifier = drm_format_modifier;
38258         self
38259     }
38260     #[inline]
plane_layouts(mut self, plane_layouts: &'a [SubresourceLayout]) -> Self38261     pub fn plane_layouts(mut self, plane_layouts: &'a [SubresourceLayout]) -> Self {
38262         self.inner.drm_format_modifier_plane_count = plane_layouts.len() as _;
38263         self.inner.p_plane_layouts = plane_layouts.as_ptr();
38264         self
38265     }
38266     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38267     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38268     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageDrmFormatModifierExplicitCreateInfoEXT38269     pub fn build(self) -> ImageDrmFormatModifierExplicitCreateInfoEXT {
38270         self.inner
38271     }
38272 }
38273 #[repr(C)]
38274 #[cfg_attr(feature = "debug", derive(Debug))]
38275 #[derive(Copy, Clone)]
38276 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageDrmFormatModifierPropertiesEXT.html>"]
38277 pub struct ImageDrmFormatModifierPropertiesEXT {
38278     pub s_type: StructureType,
38279     pub p_next: *mut c_void,
38280     pub drm_format_modifier: u64,
38281 }
38282 impl ::std::default::Default for ImageDrmFormatModifierPropertiesEXT {
38283     #[inline]
default() -> Self38284     fn default() -> Self {
38285         Self {
38286             s_type: Self::STRUCTURE_TYPE,
38287             p_next: ::std::ptr::null_mut(),
38288             drm_format_modifier: u64::default(),
38289         }
38290     }
38291 }
38292 unsafe impl TaggedStructure for ImageDrmFormatModifierPropertiesEXT {
38293     const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT;
38294 }
38295 impl ImageDrmFormatModifierPropertiesEXT {
builder<'a>() -> ImageDrmFormatModifierPropertiesEXTBuilder<'a>38296     pub fn builder<'a>() -> ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
38297         ImageDrmFormatModifierPropertiesEXTBuilder {
38298             inner: Self::default(),
38299             marker: ::std::marker::PhantomData,
38300         }
38301     }
38302 }
38303 #[repr(transparent)]
38304 pub struct ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
38305     inner: ImageDrmFormatModifierPropertiesEXT,
38306     marker: ::std::marker::PhantomData<&'a ()>,
38307 }
38308 impl<'a> ::std::ops::Deref for ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
38309     type Target = ImageDrmFormatModifierPropertiesEXT;
deref(&self) -> &Self::Target38310     fn deref(&self) -> &Self::Target {
38311         &self.inner
38312     }
38313 }
38314 impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target38315     fn deref_mut(&mut self) -> &mut Self::Target {
38316         &mut self.inner
38317     }
38318 }
38319 impl<'a> ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
38320     #[inline]
drm_format_modifier(mut self, drm_format_modifier: u64) -> Self38321     pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self {
38322         self.inner.drm_format_modifier = drm_format_modifier;
38323         self
38324     }
38325     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38326     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38327     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageDrmFormatModifierPropertiesEXT38328     pub fn build(self) -> ImageDrmFormatModifierPropertiesEXT {
38329         self.inner
38330     }
38331 }
38332 #[repr(C)]
38333 #[cfg_attr(feature = "debug", derive(Debug))]
38334 #[derive(Copy, Clone)]
38335 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageStencilUsageCreateInfo.html>"]
38336 pub struct ImageStencilUsageCreateInfo {
38337     pub s_type: StructureType,
38338     pub p_next: *const c_void,
38339     pub stencil_usage: ImageUsageFlags,
38340 }
38341 impl ::std::default::Default for ImageStencilUsageCreateInfo {
38342     #[inline]
default() -> Self38343     fn default() -> Self {
38344         Self {
38345             s_type: Self::STRUCTURE_TYPE,
38346             p_next: ::std::ptr::null(),
38347             stencil_usage: ImageUsageFlags::default(),
38348         }
38349     }
38350 }
38351 unsafe impl TaggedStructure for ImageStencilUsageCreateInfo {
38352     const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_STENCIL_USAGE_CREATE_INFO;
38353 }
38354 impl ImageStencilUsageCreateInfo {
builder<'a>() -> ImageStencilUsageCreateInfoBuilder<'a>38355     pub fn builder<'a>() -> ImageStencilUsageCreateInfoBuilder<'a> {
38356         ImageStencilUsageCreateInfoBuilder {
38357             inner: Self::default(),
38358             marker: ::std::marker::PhantomData,
38359         }
38360     }
38361 }
38362 #[repr(transparent)]
38363 pub struct ImageStencilUsageCreateInfoBuilder<'a> {
38364     inner: ImageStencilUsageCreateInfo,
38365     marker: ::std::marker::PhantomData<&'a ()>,
38366 }
38367 unsafe impl ExtendsImageCreateInfo for ImageStencilUsageCreateInfoBuilder<'_> {}
38368 unsafe impl ExtendsImageCreateInfo for ImageStencilUsageCreateInfo {}
38369 unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageStencilUsageCreateInfoBuilder<'_> {}
38370 unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageStencilUsageCreateInfo {}
38371 impl<'a> ::std::ops::Deref for ImageStencilUsageCreateInfoBuilder<'a> {
38372     type Target = ImageStencilUsageCreateInfo;
deref(&self) -> &Self::Target38373     fn deref(&self) -> &Self::Target {
38374         &self.inner
38375     }
38376 }
38377 impl<'a> ::std::ops::DerefMut for ImageStencilUsageCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target38378     fn deref_mut(&mut self) -> &mut Self::Target {
38379         &mut self.inner
38380     }
38381 }
38382 impl<'a> ImageStencilUsageCreateInfoBuilder<'a> {
38383     #[inline]
stencil_usage(mut self, stencil_usage: ImageUsageFlags) -> Self38384     pub fn stencil_usage(mut self, stencil_usage: ImageUsageFlags) -> Self {
38385         self.inner.stencil_usage = stencil_usage;
38386         self
38387     }
38388     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38389     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38390     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageStencilUsageCreateInfo38391     pub fn build(self) -> ImageStencilUsageCreateInfo {
38392         self.inner
38393     }
38394 }
38395 #[repr(C)]
38396 #[cfg_attr(feature = "debug", derive(Debug))]
38397 #[derive(Copy, Clone)]
38398 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceMemoryOverallocationCreateInfoAMD.html>"]
38399 pub struct DeviceMemoryOverallocationCreateInfoAMD {
38400     pub s_type: StructureType,
38401     pub p_next: *const c_void,
38402     pub overallocation_behavior: MemoryOverallocationBehaviorAMD,
38403 }
38404 impl ::std::default::Default for DeviceMemoryOverallocationCreateInfoAMD {
38405     #[inline]
default() -> Self38406     fn default() -> Self {
38407         Self {
38408             s_type: Self::STRUCTURE_TYPE,
38409             p_next: ::std::ptr::null(),
38410             overallocation_behavior: MemoryOverallocationBehaviorAMD::default(),
38411         }
38412     }
38413 }
38414 unsafe impl TaggedStructure for DeviceMemoryOverallocationCreateInfoAMD {
38415     const STRUCTURE_TYPE: StructureType =
38416         StructureType::DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD;
38417 }
38418 impl DeviceMemoryOverallocationCreateInfoAMD {
builder<'a>() -> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a>38419     pub fn builder<'a>() -> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
38420         DeviceMemoryOverallocationCreateInfoAMDBuilder {
38421             inner: Self::default(),
38422             marker: ::std::marker::PhantomData,
38423         }
38424     }
38425 }
38426 #[repr(transparent)]
38427 pub struct DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
38428     inner: DeviceMemoryOverallocationCreateInfoAMD,
38429     marker: ::std::marker::PhantomData<&'a ()>,
38430 }
38431 unsafe impl ExtendsDeviceCreateInfo for DeviceMemoryOverallocationCreateInfoAMDBuilder<'_> {}
38432 unsafe impl ExtendsDeviceCreateInfo for DeviceMemoryOverallocationCreateInfoAMD {}
38433 impl<'a> ::std::ops::Deref for DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
38434     type Target = DeviceMemoryOverallocationCreateInfoAMD;
deref(&self) -> &Self::Target38435     fn deref(&self) -> &Self::Target {
38436         &self.inner
38437     }
38438 }
38439 impl<'a> ::std::ops::DerefMut for DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target38440     fn deref_mut(&mut self) -> &mut Self::Target {
38441         &mut self.inner
38442     }
38443 }
38444 impl<'a> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
38445     #[inline]
overallocation_behavior( mut self, overallocation_behavior: MemoryOverallocationBehaviorAMD, ) -> Self38446     pub fn overallocation_behavior(
38447         mut self,
38448         overallocation_behavior: MemoryOverallocationBehaviorAMD,
38449     ) -> Self {
38450         self.inner.overallocation_behavior = overallocation_behavior;
38451         self
38452     }
38453     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38454     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38455     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceMemoryOverallocationCreateInfoAMD38456     pub fn build(self) -> DeviceMemoryOverallocationCreateInfoAMD {
38457         self.inner
38458     }
38459 }
38460 #[repr(C)]
38461 #[cfg_attr(feature = "debug", derive(Debug))]
38462 #[derive(Copy, Clone)]
38463 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMapFeaturesEXT.html>"]
38464 pub struct PhysicalDeviceFragmentDensityMapFeaturesEXT {
38465     pub s_type: StructureType,
38466     pub p_next: *mut c_void,
38467     pub fragment_density_map: Bool32,
38468     pub fragment_density_map_dynamic: Bool32,
38469     pub fragment_density_map_non_subsampled_images: Bool32,
38470 }
38471 impl ::std::default::Default for PhysicalDeviceFragmentDensityMapFeaturesEXT {
38472     #[inline]
default() -> Self38473     fn default() -> Self {
38474         Self {
38475             s_type: Self::STRUCTURE_TYPE,
38476             p_next: ::std::ptr::null_mut(),
38477             fragment_density_map: Bool32::default(),
38478             fragment_density_map_dynamic: Bool32::default(),
38479             fragment_density_map_non_subsampled_images: Bool32::default(),
38480         }
38481     }
38482 }
38483 unsafe impl TaggedStructure for PhysicalDeviceFragmentDensityMapFeaturesEXT {
38484     const STRUCTURE_TYPE: StructureType =
38485         StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
38486 }
38487 impl PhysicalDeviceFragmentDensityMapFeaturesEXT {
builder<'a>() -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a>38488     pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
38489         PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder {
38490             inner: Self::default(),
38491             marker: ::std::marker::PhantomData,
38492         }
38493     }
38494 }
38495 #[repr(transparent)]
38496 pub struct PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
38497     inner: PhysicalDeviceFragmentDensityMapFeaturesEXT,
38498     marker: ::std::marker::PhantomData<&'a ()>,
38499 }
38500 unsafe impl ExtendsPhysicalDeviceFeatures2
38501     for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'_>
38502 {
38503 }
38504 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMapFeaturesEXT {}
38505 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'_> {}
38506 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXT {}
38507 impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
38508     type Target = PhysicalDeviceFragmentDensityMapFeaturesEXT;
deref(&self) -> &Self::Target38509     fn deref(&self) -> &Self::Target {
38510         &self.inner
38511     }
38512 }
38513 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target38514     fn deref_mut(&mut self) -> &mut Self::Target {
38515         &mut self.inner
38516     }
38517 }
38518 impl<'a> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
38519     #[inline]
fragment_density_map(mut self, fragment_density_map: bool) -> Self38520     pub fn fragment_density_map(mut self, fragment_density_map: bool) -> Self {
38521         self.inner.fragment_density_map = fragment_density_map.into();
38522         self
38523     }
38524     #[inline]
fragment_density_map_dynamic(mut self, fragment_density_map_dynamic: bool) -> Self38525     pub fn fragment_density_map_dynamic(mut self, fragment_density_map_dynamic: bool) -> Self {
38526         self.inner.fragment_density_map_dynamic = fragment_density_map_dynamic.into();
38527         self
38528     }
38529     #[inline]
fragment_density_map_non_subsampled_images( mut self, fragment_density_map_non_subsampled_images: bool, ) -> Self38530     pub fn fragment_density_map_non_subsampled_images(
38531         mut self,
38532         fragment_density_map_non_subsampled_images: bool,
38533     ) -> Self {
38534         self.inner.fragment_density_map_non_subsampled_images =
38535             fragment_density_map_non_subsampled_images.into();
38536         self
38537     }
38538     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38539     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38540     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFragmentDensityMapFeaturesEXT38541     pub fn build(self) -> PhysicalDeviceFragmentDensityMapFeaturesEXT {
38542         self.inner
38543     }
38544 }
38545 #[repr(C)]
38546 #[cfg_attr(feature = "debug", derive(Debug))]
38547 #[derive(Copy, Clone)]
38548 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMap2FeaturesEXT.html>"]
38549 pub struct PhysicalDeviceFragmentDensityMap2FeaturesEXT {
38550     pub s_type: StructureType,
38551     pub p_next: *mut c_void,
38552     pub fragment_density_map_deferred: Bool32,
38553 }
38554 impl ::std::default::Default for PhysicalDeviceFragmentDensityMap2FeaturesEXT {
38555     #[inline]
default() -> Self38556     fn default() -> Self {
38557         Self {
38558             s_type: Self::STRUCTURE_TYPE,
38559             p_next: ::std::ptr::null_mut(),
38560             fragment_density_map_deferred: Bool32::default(),
38561         }
38562     }
38563 }
38564 unsafe impl TaggedStructure for PhysicalDeviceFragmentDensityMap2FeaturesEXT {
38565     const STRUCTURE_TYPE: StructureType =
38566         StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
38567 }
38568 impl PhysicalDeviceFragmentDensityMap2FeaturesEXT {
builder<'a>() -> PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a>38569     pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> {
38570         PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder {
38571             inner: Self::default(),
38572             marker: ::std::marker::PhantomData,
38573         }
38574     }
38575 }
38576 #[repr(transparent)]
38577 pub struct PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> {
38578     inner: PhysicalDeviceFragmentDensityMap2FeaturesEXT,
38579     marker: ::std::marker::PhantomData<&'a ()>,
38580 }
38581 unsafe impl ExtendsPhysicalDeviceFeatures2
38582     for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'_>
38583 {
38584 }
38585 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMap2FeaturesEXT {}
38586 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'_> {}
38587 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMap2FeaturesEXT {}
38588 impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> {
38589     type Target = PhysicalDeviceFragmentDensityMap2FeaturesEXT;
deref(&self) -> &Self::Target38590     fn deref(&self) -> &Self::Target {
38591         &self.inner
38592     }
38593 }
38594 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target38595     fn deref_mut(&mut self) -> &mut Self::Target {
38596         &mut self.inner
38597     }
38598 }
38599 impl<'a> PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> {
38600     #[inline]
fragment_density_map_deferred(mut self, fragment_density_map_deferred: bool) -> Self38601     pub fn fragment_density_map_deferred(mut self, fragment_density_map_deferred: bool) -> Self {
38602         self.inner.fragment_density_map_deferred = fragment_density_map_deferred.into();
38603         self
38604     }
38605     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38606     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38607     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFragmentDensityMap2FeaturesEXT38608     pub fn build(self) -> PhysicalDeviceFragmentDensityMap2FeaturesEXT {
38609         self.inner
38610     }
38611 }
38612 #[repr(C)]
38613 #[cfg_attr(feature = "debug", derive(Debug))]
38614 #[derive(Copy, Clone)]
38615 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM.html>"]
38616 pub struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
38617     pub s_type: StructureType,
38618     pub p_next: *mut c_void,
38619     pub fragment_density_map_offset: Bool32,
38620 }
38621 impl ::std::default::Default for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
38622     #[inline]
default() -> Self38623     fn default() -> Self {
38624         Self {
38625             s_type: Self::STRUCTURE_TYPE,
38626             p_next: ::std::ptr::null_mut(),
38627             fragment_density_map_offset: Bool32::default(),
38628         }
38629     }
38630 }
38631 unsafe impl TaggedStructure for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
38632     const STRUCTURE_TYPE: StructureType =
38633         StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM;
38634 }
38635 impl PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
builder<'a>() -> PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a>38636     pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> {
38637         PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder {
38638             inner: Self::default(),
38639             marker: ::std::marker::PhantomData,
38640         }
38641     }
38642 }
38643 #[repr(transparent)]
38644 pub struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> {
38645     inner: PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM,
38646     marker: ::std::marker::PhantomData<&'a ()>,
38647 }
38648 unsafe impl ExtendsPhysicalDeviceFeatures2
38649     for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'_>
38650 {
38651 }
38652 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {}
38653 unsafe impl ExtendsDeviceCreateInfo
38654     for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'_>
38655 {
38656 }
38657 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {}
38658 impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> {
38659     type Target = PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
deref(&self) -> &Self::Target38660     fn deref(&self) -> &Self::Target {
38661         &self.inner
38662     }
38663 }
38664 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target38665     fn deref_mut(&mut self) -> &mut Self::Target {
38666         &mut self.inner
38667     }
38668 }
38669 impl<'a> PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> {
38670     #[inline]
fragment_density_map_offset(mut self, fragment_density_map_offset: bool) -> Self38671     pub fn fragment_density_map_offset(mut self, fragment_density_map_offset: bool) -> Self {
38672         self.inner.fragment_density_map_offset = fragment_density_map_offset.into();
38673         self
38674     }
38675     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38676     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38677     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM38678     pub fn build(self) -> PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
38679         self.inner
38680     }
38681 }
38682 #[repr(C)]
38683 #[cfg_attr(feature = "debug", derive(Debug))]
38684 #[derive(Copy, Clone)]
38685 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMapPropertiesEXT.html>"]
38686 pub struct PhysicalDeviceFragmentDensityMapPropertiesEXT {
38687     pub s_type: StructureType,
38688     pub p_next: *mut c_void,
38689     pub min_fragment_density_texel_size: Extent2D,
38690     pub max_fragment_density_texel_size: Extent2D,
38691     pub fragment_density_invocations: Bool32,
38692 }
38693 impl ::std::default::Default for PhysicalDeviceFragmentDensityMapPropertiesEXT {
38694     #[inline]
default() -> Self38695     fn default() -> Self {
38696         Self {
38697             s_type: Self::STRUCTURE_TYPE,
38698             p_next: ::std::ptr::null_mut(),
38699             min_fragment_density_texel_size: Extent2D::default(),
38700             max_fragment_density_texel_size: Extent2D::default(),
38701             fragment_density_invocations: Bool32::default(),
38702         }
38703     }
38704 }
38705 unsafe impl TaggedStructure for PhysicalDeviceFragmentDensityMapPropertiesEXT {
38706     const STRUCTURE_TYPE: StructureType =
38707         StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT;
38708 }
38709 impl PhysicalDeviceFragmentDensityMapPropertiesEXT {
builder<'a>() -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a>38710     pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
38711         PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder {
38712             inner: Self::default(),
38713             marker: ::std::marker::PhantomData,
38714         }
38715     }
38716 }
38717 #[repr(transparent)]
38718 pub struct PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
38719     inner: PhysicalDeviceFragmentDensityMapPropertiesEXT,
38720     marker: ::std::marker::PhantomData<&'a ()>,
38721 }
38722 unsafe impl ExtendsPhysicalDeviceProperties2
38723     for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'_>
38724 {
38725 }
38726 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentDensityMapPropertiesEXT {}
38727 impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
38728     type Target = PhysicalDeviceFragmentDensityMapPropertiesEXT;
deref(&self) -> &Self::Target38729     fn deref(&self) -> &Self::Target {
38730         &self.inner
38731     }
38732 }
38733 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target38734     fn deref_mut(&mut self) -> &mut Self::Target {
38735         &mut self.inner
38736     }
38737 }
38738 impl<'a> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
38739     #[inline]
min_fragment_density_texel_size( mut self, min_fragment_density_texel_size: Extent2D, ) -> Self38740     pub fn min_fragment_density_texel_size(
38741         mut self,
38742         min_fragment_density_texel_size: Extent2D,
38743     ) -> Self {
38744         self.inner.min_fragment_density_texel_size = min_fragment_density_texel_size;
38745         self
38746     }
38747     #[inline]
max_fragment_density_texel_size( mut self, max_fragment_density_texel_size: Extent2D, ) -> Self38748     pub fn max_fragment_density_texel_size(
38749         mut self,
38750         max_fragment_density_texel_size: Extent2D,
38751     ) -> Self {
38752         self.inner.max_fragment_density_texel_size = max_fragment_density_texel_size;
38753         self
38754     }
38755     #[inline]
fragment_density_invocations(mut self, fragment_density_invocations: bool) -> Self38756     pub fn fragment_density_invocations(mut self, fragment_density_invocations: bool) -> Self {
38757         self.inner.fragment_density_invocations = fragment_density_invocations.into();
38758         self
38759     }
38760     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38761     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38762     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFragmentDensityMapPropertiesEXT38763     pub fn build(self) -> PhysicalDeviceFragmentDensityMapPropertiesEXT {
38764         self.inner
38765     }
38766 }
38767 #[repr(C)]
38768 #[cfg_attr(feature = "debug", derive(Debug))]
38769 #[derive(Copy, Clone)]
38770 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMap2PropertiesEXT.html>"]
38771 pub struct PhysicalDeviceFragmentDensityMap2PropertiesEXT {
38772     pub s_type: StructureType,
38773     pub p_next: *mut c_void,
38774     pub subsampled_loads: Bool32,
38775     pub subsampled_coarse_reconstruction_early_access: Bool32,
38776     pub max_subsampled_array_layers: u32,
38777     pub max_descriptor_set_subsampled_samplers: u32,
38778 }
38779 impl ::std::default::Default for PhysicalDeviceFragmentDensityMap2PropertiesEXT {
38780     #[inline]
default() -> Self38781     fn default() -> Self {
38782         Self {
38783             s_type: Self::STRUCTURE_TYPE,
38784             p_next: ::std::ptr::null_mut(),
38785             subsampled_loads: Bool32::default(),
38786             subsampled_coarse_reconstruction_early_access: Bool32::default(),
38787             max_subsampled_array_layers: u32::default(),
38788             max_descriptor_set_subsampled_samplers: u32::default(),
38789         }
38790     }
38791 }
38792 unsafe impl TaggedStructure for PhysicalDeviceFragmentDensityMap2PropertiesEXT {
38793     const STRUCTURE_TYPE: StructureType =
38794         StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT;
38795 }
38796 impl PhysicalDeviceFragmentDensityMap2PropertiesEXT {
builder<'a>() -> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a>38797     pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
38798         PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder {
38799             inner: Self::default(),
38800             marker: ::std::marker::PhantomData,
38801         }
38802     }
38803 }
38804 #[repr(transparent)]
38805 pub struct PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
38806     inner: PhysicalDeviceFragmentDensityMap2PropertiesEXT,
38807     marker: ::std::marker::PhantomData<&'a ()>,
38808 }
38809 unsafe impl ExtendsPhysicalDeviceProperties2
38810     for PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'_>
38811 {
38812 }
38813 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentDensityMap2PropertiesEXT {}
38814 impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
38815     type Target = PhysicalDeviceFragmentDensityMap2PropertiesEXT;
deref(&self) -> &Self::Target38816     fn deref(&self) -> &Self::Target {
38817         &self.inner
38818     }
38819 }
38820 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target38821     fn deref_mut(&mut self) -> &mut Self::Target {
38822         &mut self.inner
38823     }
38824 }
38825 impl<'a> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
38826     #[inline]
subsampled_loads(mut self, subsampled_loads: bool) -> Self38827     pub fn subsampled_loads(mut self, subsampled_loads: bool) -> Self {
38828         self.inner.subsampled_loads = subsampled_loads.into();
38829         self
38830     }
38831     #[inline]
subsampled_coarse_reconstruction_early_access( mut self, subsampled_coarse_reconstruction_early_access: bool, ) -> Self38832     pub fn subsampled_coarse_reconstruction_early_access(
38833         mut self,
38834         subsampled_coarse_reconstruction_early_access: bool,
38835     ) -> Self {
38836         self.inner.subsampled_coarse_reconstruction_early_access =
38837             subsampled_coarse_reconstruction_early_access.into();
38838         self
38839     }
38840     #[inline]
max_subsampled_array_layers(mut self, max_subsampled_array_layers: u32) -> Self38841     pub fn max_subsampled_array_layers(mut self, max_subsampled_array_layers: u32) -> Self {
38842         self.inner.max_subsampled_array_layers = max_subsampled_array_layers;
38843         self
38844     }
38845     #[inline]
max_descriptor_set_subsampled_samplers( mut self, max_descriptor_set_subsampled_samplers: u32, ) -> Self38846     pub fn max_descriptor_set_subsampled_samplers(
38847         mut self,
38848         max_descriptor_set_subsampled_samplers: u32,
38849     ) -> Self {
38850         self.inner.max_descriptor_set_subsampled_samplers = max_descriptor_set_subsampled_samplers;
38851         self
38852     }
38853     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38854     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38855     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFragmentDensityMap2PropertiesEXT38856     pub fn build(self) -> PhysicalDeviceFragmentDensityMap2PropertiesEXT {
38857         self.inner
38858     }
38859 }
38860 #[repr(C)]
38861 #[cfg_attr(feature = "debug", derive(Debug))]
38862 #[derive(Copy, Clone)]
38863 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM.html>"]
38864 pub struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
38865     pub s_type: StructureType,
38866     pub p_next: *mut c_void,
38867     pub fragment_density_offset_granularity: Extent2D,
38868 }
38869 impl ::std::default::Default for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
38870     #[inline]
default() -> Self38871     fn default() -> Self {
38872         Self {
38873             s_type: Self::STRUCTURE_TYPE,
38874             p_next: ::std::ptr::null_mut(),
38875             fragment_density_offset_granularity: Extent2D::default(),
38876         }
38877     }
38878 }
38879 unsafe impl TaggedStructure for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
38880     const STRUCTURE_TYPE: StructureType =
38881         StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM;
38882 }
38883 impl PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
builder<'a>() -> PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a>38884     pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> {
38885         PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder {
38886             inner: Self::default(),
38887             marker: ::std::marker::PhantomData,
38888         }
38889     }
38890 }
38891 #[repr(transparent)]
38892 pub struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> {
38893     inner: PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM,
38894     marker: ::std::marker::PhantomData<&'a ()>,
38895 }
38896 unsafe impl ExtendsPhysicalDeviceProperties2
38897     for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'_>
38898 {
38899 }
38900 unsafe impl ExtendsPhysicalDeviceProperties2
38901     for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM
38902 {
38903 }
38904 impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> {
38905     type Target = PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
deref(&self) -> &Self::Target38906     fn deref(&self) -> &Self::Target {
38907         &self.inner
38908     }
38909 }
38910 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target38911     fn deref_mut(&mut self) -> &mut Self::Target {
38912         &mut self.inner
38913     }
38914 }
38915 impl<'a> PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> {
38916     #[inline]
fragment_density_offset_granularity( mut self, fragment_density_offset_granularity: Extent2D, ) -> Self38917     pub fn fragment_density_offset_granularity(
38918         mut self,
38919         fragment_density_offset_granularity: Extent2D,
38920     ) -> Self {
38921         self.inner.fragment_density_offset_granularity = fragment_density_offset_granularity;
38922         self
38923     }
38924     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38925     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38926     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM38927     pub fn build(self) -> PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
38928         self.inner
38929     }
38930 }
38931 #[repr(C)]
38932 #[cfg_attr(feature = "debug", derive(Debug))]
38933 #[derive(Copy, Clone)]
38934 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassFragmentDensityMapCreateInfoEXT.html>"]
38935 pub struct RenderPassFragmentDensityMapCreateInfoEXT {
38936     pub s_type: StructureType,
38937     pub p_next: *const c_void,
38938     pub fragment_density_map_attachment: AttachmentReference,
38939 }
38940 impl ::std::default::Default for RenderPassFragmentDensityMapCreateInfoEXT {
38941     #[inline]
default() -> Self38942     fn default() -> Self {
38943         Self {
38944             s_type: Self::STRUCTURE_TYPE,
38945             p_next: ::std::ptr::null(),
38946             fragment_density_map_attachment: AttachmentReference::default(),
38947         }
38948     }
38949 }
38950 unsafe impl TaggedStructure for RenderPassFragmentDensityMapCreateInfoEXT {
38951     const STRUCTURE_TYPE: StructureType =
38952         StructureType::RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT;
38953 }
38954 impl RenderPassFragmentDensityMapCreateInfoEXT {
builder<'a>() -> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a>38955     pub fn builder<'a>() -> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
38956         RenderPassFragmentDensityMapCreateInfoEXTBuilder {
38957             inner: Self::default(),
38958             marker: ::std::marker::PhantomData,
38959         }
38960     }
38961 }
38962 #[repr(transparent)]
38963 pub struct RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
38964     inner: RenderPassFragmentDensityMapCreateInfoEXT,
38965     marker: ::std::marker::PhantomData<&'a ()>,
38966 }
38967 unsafe impl ExtendsRenderPassCreateInfo for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'_> {}
38968 unsafe impl ExtendsRenderPassCreateInfo for RenderPassFragmentDensityMapCreateInfoEXT {}
38969 unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'_> {}
38970 unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassFragmentDensityMapCreateInfoEXT {}
38971 impl<'a> ::std::ops::Deref for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
38972     type Target = RenderPassFragmentDensityMapCreateInfoEXT;
deref(&self) -> &Self::Target38973     fn deref(&self) -> &Self::Target {
38974         &self.inner
38975     }
38976 }
38977 impl<'a> ::std::ops::DerefMut for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target38978     fn deref_mut(&mut self) -> &mut Self::Target {
38979         &mut self.inner
38980     }
38981 }
38982 impl<'a> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
38983     #[inline]
fragment_density_map_attachment( mut self, fragment_density_map_attachment: AttachmentReference, ) -> Self38984     pub fn fragment_density_map_attachment(
38985         mut self,
38986         fragment_density_map_attachment: AttachmentReference,
38987     ) -> Self {
38988         self.inner.fragment_density_map_attachment = fragment_density_map_attachment;
38989         self
38990     }
38991     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38992     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38993     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RenderPassFragmentDensityMapCreateInfoEXT38994     pub fn build(self) -> RenderPassFragmentDensityMapCreateInfoEXT {
38995         self.inner
38996     }
38997 }
38998 #[repr(C)]
38999 #[cfg_attr(feature = "debug", derive(Debug))]
39000 #[derive(Copy, Clone)]
39001 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassFragmentDensityMapOffsetEndInfoQCOM.html>"]
39002 pub struct SubpassFragmentDensityMapOffsetEndInfoQCOM {
39003     pub s_type: StructureType,
39004     pub p_next: *const c_void,
39005     pub fragment_density_offset_count: u32,
39006     pub p_fragment_density_offsets: *const Offset2D,
39007 }
39008 impl ::std::default::Default for SubpassFragmentDensityMapOffsetEndInfoQCOM {
39009     #[inline]
default() -> Self39010     fn default() -> Self {
39011         Self {
39012             s_type: Self::STRUCTURE_TYPE,
39013             p_next: ::std::ptr::null(),
39014             fragment_density_offset_count: u32::default(),
39015             p_fragment_density_offsets: ::std::ptr::null(),
39016         }
39017     }
39018 }
39019 unsafe impl TaggedStructure for SubpassFragmentDensityMapOffsetEndInfoQCOM {
39020     const STRUCTURE_TYPE: StructureType =
39021         StructureType::SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM;
39022 }
39023 impl SubpassFragmentDensityMapOffsetEndInfoQCOM {
builder<'a>() -> SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a>39024     pub fn builder<'a>() -> SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> {
39025         SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder {
39026             inner: Self::default(),
39027             marker: ::std::marker::PhantomData,
39028         }
39029     }
39030 }
39031 #[repr(transparent)]
39032 pub struct SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> {
39033     inner: SubpassFragmentDensityMapOffsetEndInfoQCOM,
39034     marker: ::std::marker::PhantomData<&'a ()>,
39035 }
39036 unsafe impl ExtendsSubpassEndInfo for SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'_> {}
39037 unsafe impl ExtendsSubpassEndInfo for SubpassFragmentDensityMapOffsetEndInfoQCOM {}
39038 impl<'a> ::std::ops::Deref for SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> {
39039     type Target = SubpassFragmentDensityMapOffsetEndInfoQCOM;
deref(&self) -> &Self::Target39040     fn deref(&self) -> &Self::Target {
39041         &self.inner
39042     }
39043 }
39044 impl<'a> ::std::ops::DerefMut for SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target39045     fn deref_mut(&mut self) -> &mut Self::Target {
39046         &mut self.inner
39047     }
39048 }
39049 impl<'a> SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> {
39050     #[inline]
fragment_density_offsets(mut self, fragment_density_offsets: &'a [Offset2D]) -> Self39051     pub fn fragment_density_offsets(mut self, fragment_density_offsets: &'a [Offset2D]) -> Self {
39052         self.inner.fragment_density_offset_count = fragment_density_offsets.len() as _;
39053         self.inner.p_fragment_density_offsets = fragment_density_offsets.as_ptr();
39054         self
39055     }
39056     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39057     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39058     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SubpassFragmentDensityMapOffsetEndInfoQCOM39059     pub fn build(self) -> SubpassFragmentDensityMapOffsetEndInfoQCOM {
39060         self.inner
39061     }
39062 }
39063 #[repr(C)]
39064 #[cfg_attr(feature = "debug", derive(Debug))]
39065 #[derive(Copy, Clone)]
39066 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceScalarBlockLayoutFeatures.html>"]
39067 pub struct PhysicalDeviceScalarBlockLayoutFeatures {
39068     pub s_type: StructureType,
39069     pub p_next: *mut c_void,
39070     pub scalar_block_layout: Bool32,
39071 }
39072 impl ::std::default::Default for PhysicalDeviceScalarBlockLayoutFeatures {
39073     #[inline]
default() -> Self39074     fn default() -> Self {
39075         Self {
39076             s_type: Self::STRUCTURE_TYPE,
39077             p_next: ::std::ptr::null_mut(),
39078             scalar_block_layout: Bool32::default(),
39079         }
39080     }
39081 }
39082 unsafe impl TaggedStructure for PhysicalDeviceScalarBlockLayoutFeatures {
39083     const STRUCTURE_TYPE: StructureType =
39084         StructureType::PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
39085 }
39086 impl PhysicalDeviceScalarBlockLayoutFeatures {
builder<'a>() -> PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a>39087     pub fn builder<'a>() -> PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
39088         PhysicalDeviceScalarBlockLayoutFeaturesBuilder {
39089             inner: Self::default(),
39090             marker: ::std::marker::PhantomData,
39091         }
39092     }
39093 }
39094 #[repr(transparent)]
39095 pub struct PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
39096     inner: PhysicalDeviceScalarBlockLayoutFeatures,
39097     marker: ::std::marker::PhantomData<&'a ()>,
39098 }
39099 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'_> {}
39100 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceScalarBlockLayoutFeatures {}
39101 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'_> {}
39102 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeatures {}
39103 impl<'a> ::std::ops::Deref for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
39104     type Target = PhysicalDeviceScalarBlockLayoutFeatures;
deref(&self) -> &Self::Target39105     fn deref(&self) -> &Self::Target {
39106         &self.inner
39107     }
39108 }
39109 impl<'a> ::std::ops::DerefMut for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target39110     fn deref_mut(&mut self) -> &mut Self::Target {
39111         &mut self.inner
39112     }
39113 }
39114 impl<'a> PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
39115     #[inline]
scalar_block_layout(mut self, scalar_block_layout: bool) -> Self39116     pub fn scalar_block_layout(mut self, scalar_block_layout: bool) -> Self {
39117         self.inner.scalar_block_layout = scalar_block_layout.into();
39118         self
39119     }
39120     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39121     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39122     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceScalarBlockLayoutFeatures39123     pub fn build(self) -> PhysicalDeviceScalarBlockLayoutFeatures {
39124         self.inner
39125     }
39126 }
39127 #[repr(C)]
39128 #[cfg_attr(feature = "debug", derive(Debug))]
39129 #[derive(Copy, Clone)]
39130 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceProtectedCapabilitiesKHR.html>"]
39131 pub struct SurfaceProtectedCapabilitiesKHR {
39132     pub s_type: StructureType,
39133     pub p_next: *const c_void,
39134     pub supports_protected: Bool32,
39135 }
39136 impl ::std::default::Default for SurfaceProtectedCapabilitiesKHR {
39137     #[inline]
default() -> Self39138     fn default() -> Self {
39139         Self {
39140             s_type: Self::STRUCTURE_TYPE,
39141             p_next: ::std::ptr::null(),
39142             supports_protected: Bool32::default(),
39143         }
39144     }
39145 }
39146 unsafe impl TaggedStructure for SurfaceProtectedCapabilitiesKHR {
39147     const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_PROTECTED_CAPABILITIES_KHR;
39148 }
39149 impl SurfaceProtectedCapabilitiesKHR {
builder<'a>() -> SurfaceProtectedCapabilitiesKHRBuilder<'a>39150     pub fn builder<'a>() -> SurfaceProtectedCapabilitiesKHRBuilder<'a> {
39151         SurfaceProtectedCapabilitiesKHRBuilder {
39152             inner: Self::default(),
39153             marker: ::std::marker::PhantomData,
39154         }
39155     }
39156 }
39157 #[repr(transparent)]
39158 pub struct SurfaceProtectedCapabilitiesKHRBuilder<'a> {
39159     inner: SurfaceProtectedCapabilitiesKHR,
39160     marker: ::std::marker::PhantomData<&'a ()>,
39161 }
39162 unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceProtectedCapabilitiesKHRBuilder<'_> {}
39163 unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceProtectedCapabilitiesKHR {}
39164 impl<'a> ::std::ops::Deref for SurfaceProtectedCapabilitiesKHRBuilder<'a> {
39165     type Target = SurfaceProtectedCapabilitiesKHR;
deref(&self) -> &Self::Target39166     fn deref(&self) -> &Self::Target {
39167         &self.inner
39168     }
39169 }
39170 impl<'a> ::std::ops::DerefMut for SurfaceProtectedCapabilitiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target39171     fn deref_mut(&mut self) -> &mut Self::Target {
39172         &mut self.inner
39173     }
39174 }
39175 impl<'a> SurfaceProtectedCapabilitiesKHRBuilder<'a> {
39176     #[inline]
supports_protected(mut self, supports_protected: bool) -> Self39177     pub fn supports_protected(mut self, supports_protected: bool) -> Self {
39178         self.inner.supports_protected = supports_protected.into();
39179         self
39180     }
39181     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39182     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39183     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SurfaceProtectedCapabilitiesKHR39184     pub fn build(self) -> SurfaceProtectedCapabilitiesKHR {
39185         self.inner
39186     }
39187 }
39188 #[repr(C)]
39189 #[cfg_attr(feature = "debug", derive(Debug))]
39190 #[derive(Copy, Clone)]
39191 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceUniformBufferStandardLayoutFeatures.html>"]
39192 pub struct PhysicalDeviceUniformBufferStandardLayoutFeatures {
39193     pub s_type: StructureType,
39194     pub p_next: *mut c_void,
39195     pub uniform_buffer_standard_layout: Bool32,
39196 }
39197 impl ::std::default::Default for PhysicalDeviceUniformBufferStandardLayoutFeatures {
39198     #[inline]
default() -> Self39199     fn default() -> Self {
39200         Self {
39201             s_type: Self::STRUCTURE_TYPE,
39202             p_next: ::std::ptr::null_mut(),
39203             uniform_buffer_standard_layout: Bool32::default(),
39204         }
39205     }
39206 }
39207 unsafe impl TaggedStructure for PhysicalDeviceUniformBufferStandardLayoutFeatures {
39208     const STRUCTURE_TYPE: StructureType =
39209         StructureType::PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
39210 }
39211 impl PhysicalDeviceUniformBufferStandardLayoutFeatures {
builder<'a>() -> PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a>39212     pub fn builder<'a>() -> PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
39213         PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder {
39214             inner: Self::default(),
39215             marker: ::std::marker::PhantomData,
39216         }
39217     }
39218 }
39219 #[repr(transparent)]
39220 pub struct PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
39221     inner: PhysicalDeviceUniformBufferStandardLayoutFeatures,
39222     marker: ::std::marker::PhantomData<&'a ()>,
39223 }
39224 unsafe impl ExtendsPhysicalDeviceFeatures2
39225     for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'_>
39226 {
39227 }
39228 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceUniformBufferStandardLayoutFeatures {}
39229 unsafe impl ExtendsDeviceCreateInfo
39230     for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'_>
39231 {
39232 }
39233 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceUniformBufferStandardLayoutFeatures {}
39234 impl<'a> ::std::ops::Deref for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
39235     type Target = PhysicalDeviceUniformBufferStandardLayoutFeatures;
deref(&self) -> &Self::Target39236     fn deref(&self) -> &Self::Target {
39237         &self.inner
39238     }
39239 }
39240 impl<'a> ::std::ops::DerefMut for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target39241     fn deref_mut(&mut self) -> &mut Self::Target {
39242         &mut self.inner
39243     }
39244 }
39245 impl<'a> PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
39246     #[inline]
uniform_buffer_standard_layout(mut self, uniform_buffer_standard_layout: bool) -> Self39247     pub fn uniform_buffer_standard_layout(mut self, uniform_buffer_standard_layout: bool) -> Self {
39248         self.inner.uniform_buffer_standard_layout = uniform_buffer_standard_layout.into();
39249         self
39250     }
39251     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39252     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39253     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceUniformBufferStandardLayoutFeatures39254     pub fn build(self) -> PhysicalDeviceUniformBufferStandardLayoutFeatures {
39255         self.inner
39256     }
39257 }
39258 #[repr(C)]
39259 #[cfg_attr(feature = "debug", derive(Debug))]
39260 #[derive(Copy, Clone)]
39261 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDepthClipEnableFeaturesEXT.html>"]
39262 pub struct PhysicalDeviceDepthClipEnableFeaturesEXT {
39263     pub s_type: StructureType,
39264     pub p_next: *mut c_void,
39265     pub depth_clip_enable: Bool32,
39266 }
39267 impl ::std::default::Default for PhysicalDeviceDepthClipEnableFeaturesEXT {
39268     #[inline]
default() -> Self39269     fn default() -> Self {
39270         Self {
39271             s_type: Self::STRUCTURE_TYPE,
39272             p_next: ::std::ptr::null_mut(),
39273             depth_clip_enable: Bool32::default(),
39274         }
39275     }
39276 }
39277 unsafe impl TaggedStructure for PhysicalDeviceDepthClipEnableFeaturesEXT {
39278     const STRUCTURE_TYPE: StructureType =
39279         StructureType::PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
39280 }
39281 impl PhysicalDeviceDepthClipEnableFeaturesEXT {
builder<'a>() -> PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a>39282     pub fn builder<'a>() -> PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
39283         PhysicalDeviceDepthClipEnableFeaturesEXTBuilder {
39284             inner: Self::default(),
39285             marker: ::std::marker::PhantomData,
39286         }
39287     }
39288 }
39289 #[repr(transparent)]
39290 pub struct PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
39291     inner: PhysicalDeviceDepthClipEnableFeaturesEXT,
39292     marker: ::std::marker::PhantomData<&'a ()>,
39293 }
39294 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'_> {}
39295 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClipEnableFeaturesEXT {}
39296 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'_> {}
39297 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipEnableFeaturesEXT {}
39298 impl<'a> ::std::ops::Deref for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
39299     type Target = PhysicalDeviceDepthClipEnableFeaturesEXT;
deref(&self) -> &Self::Target39300     fn deref(&self) -> &Self::Target {
39301         &self.inner
39302     }
39303 }
39304 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target39305     fn deref_mut(&mut self) -> &mut Self::Target {
39306         &mut self.inner
39307     }
39308 }
39309 impl<'a> PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
39310     #[inline]
depth_clip_enable(mut self, depth_clip_enable: bool) -> Self39311     pub fn depth_clip_enable(mut self, depth_clip_enable: bool) -> Self {
39312         self.inner.depth_clip_enable = depth_clip_enable.into();
39313         self
39314     }
39315     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39316     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39317     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDepthClipEnableFeaturesEXT39318     pub fn build(self) -> PhysicalDeviceDepthClipEnableFeaturesEXT {
39319         self.inner
39320     }
39321 }
39322 #[repr(C)]
39323 #[cfg_attr(feature = "debug", derive(Debug))]
39324 #[derive(Copy, Clone)]
39325 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationDepthClipStateCreateInfoEXT.html>"]
39326 pub struct PipelineRasterizationDepthClipStateCreateInfoEXT {
39327     pub s_type: StructureType,
39328     pub p_next: *const c_void,
39329     pub flags: PipelineRasterizationDepthClipStateCreateFlagsEXT,
39330     pub depth_clip_enable: Bool32,
39331 }
39332 impl ::std::default::Default for PipelineRasterizationDepthClipStateCreateInfoEXT {
39333     #[inline]
default() -> Self39334     fn default() -> Self {
39335         Self {
39336             s_type: Self::STRUCTURE_TYPE,
39337             p_next: ::std::ptr::null(),
39338             flags: PipelineRasterizationDepthClipStateCreateFlagsEXT::default(),
39339             depth_clip_enable: Bool32::default(),
39340         }
39341     }
39342 }
39343 unsafe impl TaggedStructure for PipelineRasterizationDepthClipStateCreateInfoEXT {
39344     const STRUCTURE_TYPE: StructureType =
39345         StructureType::PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT;
39346 }
39347 impl PipelineRasterizationDepthClipStateCreateInfoEXT {
builder<'a>() -> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a>39348     pub fn builder<'a>() -> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
39349         PipelineRasterizationDepthClipStateCreateInfoEXTBuilder {
39350             inner: Self::default(),
39351             marker: ::std::marker::PhantomData,
39352         }
39353     }
39354 }
39355 #[repr(transparent)]
39356 pub struct PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
39357     inner: PipelineRasterizationDepthClipStateCreateInfoEXT,
39358     marker: ::std::marker::PhantomData<&'a ()>,
39359 }
39360 unsafe impl ExtendsPipelineRasterizationStateCreateInfo
39361     for PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'_>
39362 {
39363 }
39364 unsafe impl ExtendsPipelineRasterizationStateCreateInfo
39365     for PipelineRasterizationDepthClipStateCreateInfoEXT
39366 {
39367 }
39368 impl<'a> ::std::ops::Deref for PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
39369     type Target = PipelineRasterizationDepthClipStateCreateInfoEXT;
deref(&self) -> &Self::Target39370     fn deref(&self) -> &Self::Target {
39371         &self.inner
39372     }
39373 }
39374 impl<'a> ::std::ops::DerefMut for PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target39375     fn deref_mut(&mut self) -> &mut Self::Target {
39376         &mut self.inner
39377     }
39378 }
39379 impl<'a> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
39380     #[inline]
flags(mut self, flags: PipelineRasterizationDepthClipStateCreateFlagsEXT) -> Self39381     pub fn flags(mut self, flags: PipelineRasterizationDepthClipStateCreateFlagsEXT) -> Self {
39382         self.inner.flags = flags;
39383         self
39384     }
39385     #[inline]
depth_clip_enable(mut self, depth_clip_enable: bool) -> Self39386     pub fn depth_clip_enable(mut self, depth_clip_enable: bool) -> Self {
39387         self.inner.depth_clip_enable = depth_clip_enable.into();
39388         self
39389     }
39390     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39391     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39392     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineRasterizationDepthClipStateCreateInfoEXT39393     pub fn build(self) -> PipelineRasterizationDepthClipStateCreateInfoEXT {
39394         self.inner
39395     }
39396 }
39397 #[repr(C)]
39398 #[cfg_attr(feature = "debug", derive(Debug))]
39399 #[derive(Copy, Clone)]
39400 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMemoryBudgetPropertiesEXT.html>"]
39401 pub struct PhysicalDeviceMemoryBudgetPropertiesEXT {
39402     pub s_type: StructureType,
39403     pub p_next: *mut c_void,
39404     pub heap_budget: [DeviceSize; MAX_MEMORY_HEAPS],
39405     pub heap_usage: [DeviceSize; MAX_MEMORY_HEAPS],
39406 }
39407 impl ::std::default::Default for PhysicalDeviceMemoryBudgetPropertiesEXT {
39408     #[inline]
default() -> Self39409     fn default() -> Self {
39410         Self {
39411             s_type: Self::STRUCTURE_TYPE,
39412             p_next: ::std::ptr::null_mut(),
39413             heap_budget: unsafe { ::std::mem::zeroed() },
39414             heap_usage: unsafe { ::std::mem::zeroed() },
39415         }
39416     }
39417 }
39418 unsafe impl TaggedStructure for PhysicalDeviceMemoryBudgetPropertiesEXT {
39419     const STRUCTURE_TYPE: StructureType =
39420         StructureType::PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
39421 }
39422 impl PhysicalDeviceMemoryBudgetPropertiesEXT {
builder<'a>() -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a>39423     pub fn builder<'a>() -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
39424         PhysicalDeviceMemoryBudgetPropertiesEXTBuilder {
39425             inner: Self::default(),
39426             marker: ::std::marker::PhantomData,
39427         }
39428     }
39429 }
39430 #[repr(transparent)]
39431 pub struct PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
39432     inner: PhysicalDeviceMemoryBudgetPropertiesEXT,
39433     marker: ::std::marker::PhantomData<&'a ()>,
39434 }
39435 unsafe impl ExtendsPhysicalDeviceMemoryProperties2
39436     for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'_>
39437 {
39438 }
39439 unsafe impl ExtendsPhysicalDeviceMemoryProperties2 for PhysicalDeviceMemoryBudgetPropertiesEXT {}
39440 impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
39441     type Target = PhysicalDeviceMemoryBudgetPropertiesEXT;
deref(&self) -> &Self::Target39442     fn deref(&self) -> &Self::Target {
39443         &self.inner
39444     }
39445 }
39446 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target39447     fn deref_mut(&mut self) -> &mut Self::Target {
39448         &mut self.inner
39449     }
39450 }
39451 impl<'a> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
39452     #[inline]
heap_budget(mut self, heap_budget: [DeviceSize; MAX_MEMORY_HEAPS]) -> Self39453     pub fn heap_budget(mut self, heap_budget: [DeviceSize; MAX_MEMORY_HEAPS]) -> Self {
39454         self.inner.heap_budget = heap_budget;
39455         self
39456     }
39457     #[inline]
heap_usage(mut self, heap_usage: [DeviceSize; MAX_MEMORY_HEAPS]) -> Self39458     pub fn heap_usage(mut self, heap_usage: [DeviceSize; MAX_MEMORY_HEAPS]) -> Self {
39459         self.inner.heap_usage = heap_usage;
39460         self
39461     }
39462     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39463     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39464     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMemoryBudgetPropertiesEXT39465     pub fn build(self) -> PhysicalDeviceMemoryBudgetPropertiesEXT {
39466         self.inner
39467     }
39468 }
39469 #[repr(C)]
39470 #[cfg_attr(feature = "debug", derive(Debug))]
39471 #[derive(Copy, Clone)]
39472 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMemoryPriorityFeaturesEXT.html>"]
39473 pub struct PhysicalDeviceMemoryPriorityFeaturesEXT {
39474     pub s_type: StructureType,
39475     pub p_next: *mut c_void,
39476     pub memory_priority: Bool32,
39477 }
39478 impl ::std::default::Default for PhysicalDeviceMemoryPriorityFeaturesEXT {
39479     #[inline]
default() -> Self39480     fn default() -> Self {
39481         Self {
39482             s_type: Self::STRUCTURE_TYPE,
39483             p_next: ::std::ptr::null_mut(),
39484             memory_priority: Bool32::default(),
39485         }
39486     }
39487 }
39488 unsafe impl TaggedStructure for PhysicalDeviceMemoryPriorityFeaturesEXT {
39489     const STRUCTURE_TYPE: StructureType =
39490         StructureType::PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
39491 }
39492 impl PhysicalDeviceMemoryPriorityFeaturesEXT {
builder<'a>() -> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a>39493     pub fn builder<'a>() -> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
39494         PhysicalDeviceMemoryPriorityFeaturesEXTBuilder {
39495             inner: Self::default(),
39496             marker: ::std::marker::PhantomData,
39497         }
39498     }
39499 }
39500 #[repr(transparent)]
39501 pub struct PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
39502     inner: PhysicalDeviceMemoryPriorityFeaturesEXT,
39503     marker: ::std::marker::PhantomData<&'a ()>,
39504 }
39505 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'_> {}
39506 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMemoryPriorityFeaturesEXT {}
39507 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'_> {}
39508 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXT {}
39509 impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
39510     type Target = PhysicalDeviceMemoryPriorityFeaturesEXT;
deref(&self) -> &Self::Target39511     fn deref(&self) -> &Self::Target {
39512         &self.inner
39513     }
39514 }
39515 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target39516     fn deref_mut(&mut self) -> &mut Self::Target {
39517         &mut self.inner
39518     }
39519 }
39520 impl<'a> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
39521     #[inline]
memory_priority(mut self, memory_priority: bool) -> Self39522     pub fn memory_priority(mut self, memory_priority: bool) -> Self {
39523         self.inner.memory_priority = memory_priority.into();
39524         self
39525     }
39526     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39527     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39528     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMemoryPriorityFeaturesEXT39529     pub fn build(self) -> PhysicalDeviceMemoryPriorityFeaturesEXT {
39530         self.inner
39531     }
39532 }
39533 #[repr(C)]
39534 #[cfg_attr(feature = "debug", derive(Debug))]
39535 #[derive(Copy, Clone)]
39536 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryPriorityAllocateInfoEXT.html>"]
39537 pub struct MemoryPriorityAllocateInfoEXT {
39538     pub s_type: StructureType,
39539     pub p_next: *const c_void,
39540     pub priority: f32,
39541 }
39542 impl ::std::default::Default for MemoryPriorityAllocateInfoEXT {
39543     #[inline]
default() -> Self39544     fn default() -> Self {
39545         Self {
39546             s_type: Self::STRUCTURE_TYPE,
39547             p_next: ::std::ptr::null(),
39548             priority: f32::default(),
39549         }
39550     }
39551 }
39552 unsafe impl TaggedStructure for MemoryPriorityAllocateInfoEXT {
39553     const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_PRIORITY_ALLOCATE_INFO_EXT;
39554 }
39555 impl MemoryPriorityAllocateInfoEXT {
builder<'a>() -> MemoryPriorityAllocateInfoEXTBuilder<'a>39556     pub fn builder<'a>() -> MemoryPriorityAllocateInfoEXTBuilder<'a> {
39557         MemoryPriorityAllocateInfoEXTBuilder {
39558             inner: Self::default(),
39559             marker: ::std::marker::PhantomData,
39560         }
39561     }
39562 }
39563 #[repr(transparent)]
39564 pub struct MemoryPriorityAllocateInfoEXTBuilder<'a> {
39565     inner: MemoryPriorityAllocateInfoEXT,
39566     marker: ::std::marker::PhantomData<&'a ()>,
39567 }
39568 unsafe impl ExtendsMemoryAllocateInfo for MemoryPriorityAllocateInfoEXTBuilder<'_> {}
39569 unsafe impl ExtendsMemoryAllocateInfo for MemoryPriorityAllocateInfoEXT {}
39570 impl<'a> ::std::ops::Deref for MemoryPriorityAllocateInfoEXTBuilder<'a> {
39571     type Target = MemoryPriorityAllocateInfoEXT;
deref(&self) -> &Self::Target39572     fn deref(&self) -> &Self::Target {
39573         &self.inner
39574     }
39575 }
39576 impl<'a> ::std::ops::DerefMut for MemoryPriorityAllocateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target39577     fn deref_mut(&mut self) -> &mut Self::Target {
39578         &mut self.inner
39579     }
39580 }
39581 impl<'a> MemoryPriorityAllocateInfoEXTBuilder<'a> {
39582     #[inline]
priority(mut self, priority: f32) -> Self39583     pub fn priority(mut self, priority: f32) -> Self {
39584         self.inner.priority = priority;
39585         self
39586     }
39587     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39588     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39589     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryPriorityAllocateInfoEXT39590     pub fn build(self) -> MemoryPriorityAllocateInfoEXT {
39591         self.inner
39592     }
39593 }
39594 #[repr(C)]
39595 #[cfg_attr(feature = "debug", derive(Debug))]
39596 #[derive(Copy, Clone)]
39597 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT.html>"]
39598 pub struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
39599     pub s_type: StructureType,
39600     pub p_next: *mut c_void,
39601     pub pageable_device_local_memory: Bool32,
39602 }
39603 impl ::std::default::Default for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
39604     #[inline]
default() -> Self39605     fn default() -> Self {
39606         Self {
39607             s_type: Self::STRUCTURE_TYPE,
39608             p_next: ::std::ptr::null_mut(),
39609             pageable_device_local_memory: Bool32::default(),
39610         }
39611     }
39612 }
39613 unsafe impl TaggedStructure for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
39614     const STRUCTURE_TYPE: StructureType =
39615         StructureType::PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
39616 }
39617 impl PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
builder<'a>() -> PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a>39618     pub fn builder<'a>() -> PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> {
39619         PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder {
39620             inner: Self::default(),
39621             marker: ::std::marker::PhantomData,
39622         }
39623     }
39624 }
39625 #[repr(transparent)]
39626 pub struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> {
39627     inner: PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT,
39628     marker: ::std::marker::PhantomData<&'a ()>,
39629 }
39630 unsafe impl ExtendsPhysicalDeviceFeatures2
39631     for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'_>
39632 {
39633 }
39634 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {}
39635 unsafe impl ExtendsDeviceCreateInfo
39636     for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'_>
39637 {
39638 }
39639 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {}
39640 impl<'a> ::std::ops::Deref for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> {
39641     type Target = PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT;
deref(&self) -> &Self::Target39642     fn deref(&self) -> &Self::Target {
39643         &self.inner
39644     }
39645 }
39646 impl<'a> ::std::ops::DerefMut for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target39647     fn deref_mut(&mut self) -> &mut Self::Target {
39648         &mut self.inner
39649     }
39650 }
39651 impl<'a> PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> {
39652     #[inline]
pageable_device_local_memory(mut self, pageable_device_local_memory: bool) -> Self39653     pub fn pageable_device_local_memory(mut self, pageable_device_local_memory: bool) -> Self {
39654         self.inner.pageable_device_local_memory = pageable_device_local_memory.into();
39655         self
39656     }
39657     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39658     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39659     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT39660     pub fn build(self) -> PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
39661         self.inner
39662     }
39663 }
39664 #[repr(C)]
39665 #[cfg_attr(feature = "debug", derive(Debug))]
39666 #[derive(Copy, Clone)]
39667 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceBufferDeviceAddressFeatures.html>"]
39668 pub struct PhysicalDeviceBufferDeviceAddressFeatures {
39669     pub s_type: StructureType,
39670     pub p_next: *mut c_void,
39671     pub buffer_device_address: Bool32,
39672     pub buffer_device_address_capture_replay: Bool32,
39673     pub buffer_device_address_multi_device: Bool32,
39674 }
39675 impl ::std::default::Default for PhysicalDeviceBufferDeviceAddressFeatures {
39676     #[inline]
default() -> Self39677     fn default() -> Self {
39678         Self {
39679             s_type: Self::STRUCTURE_TYPE,
39680             p_next: ::std::ptr::null_mut(),
39681             buffer_device_address: Bool32::default(),
39682             buffer_device_address_capture_replay: Bool32::default(),
39683             buffer_device_address_multi_device: Bool32::default(),
39684         }
39685     }
39686 }
39687 unsafe impl TaggedStructure for PhysicalDeviceBufferDeviceAddressFeatures {
39688     const STRUCTURE_TYPE: StructureType =
39689         StructureType::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
39690 }
39691 impl PhysicalDeviceBufferDeviceAddressFeatures {
builder<'a>() -> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a>39692     pub fn builder<'a>() -> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
39693         PhysicalDeviceBufferDeviceAddressFeaturesBuilder {
39694             inner: Self::default(),
39695             marker: ::std::marker::PhantomData,
39696         }
39697     }
39698 }
39699 #[repr(transparent)]
39700 pub struct PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
39701     inner: PhysicalDeviceBufferDeviceAddressFeatures,
39702     marker: ::std::marker::PhantomData<&'a ()>,
39703 }
39704 unsafe impl ExtendsPhysicalDeviceFeatures2
39705     for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'_>
39706 {
39707 }
39708 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBufferDeviceAddressFeatures {}
39709 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'_> {}
39710 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeatures {}
39711 impl<'a> ::std::ops::Deref for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
39712     type Target = PhysicalDeviceBufferDeviceAddressFeatures;
deref(&self) -> &Self::Target39713     fn deref(&self) -> &Self::Target {
39714         &self.inner
39715     }
39716 }
39717 impl<'a> ::std::ops::DerefMut for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target39718     fn deref_mut(&mut self) -> &mut Self::Target {
39719         &mut self.inner
39720     }
39721 }
39722 impl<'a> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
39723     #[inline]
buffer_device_address(mut self, buffer_device_address: bool) -> Self39724     pub fn buffer_device_address(mut self, buffer_device_address: bool) -> Self {
39725         self.inner.buffer_device_address = buffer_device_address.into();
39726         self
39727     }
39728     #[inline]
buffer_device_address_capture_replay( mut self, buffer_device_address_capture_replay: bool, ) -> Self39729     pub fn buffer_device_address_capture_replay(
39730         mut self,
39731         buffer_device_address_capture_replay: bool,
39732     ) -> Self {
39733         self.inner.buffer_device_address_capture_replay =
39734             buffer_device_address_capture_replay.into();
39735         self
39736     }
39737     #[inline]
buffer_device_address_multi_device( mut self, buffer_device_address_multi_device: bool, ) -> Self39738     pub fn buffer_device_address_multi_device(
39739         mut self,
39740         buffer_device_address_multi_device: bool,
39741     ) -> Self {
39742         self.inner.buffer_device_address_multi_device = buffer_device_address_multi_device.into();
39743         self
39744     }
39745     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39746     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39747     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceBufferDeviceAddressFeatures39748     pub fn build(self) -> PhysicalDeviceBufferDeviceAddressFeatures {
39749         self.inner
39750     }
39751 }
39752 #[repr(C)]
39753 #[cfg_attr(feature = "debug", derive(Debug))]
39754 #[derive(Copy, Clone)]
39755 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceBufferDeviceAddressFeaturesEXT.html>"]
39756 pub struct PhysicalDeviceBufferDeviceAddressFeaturesEXT {
39757     pub s_type: StructureType,
39758     pub p_next: *mut c_void,
39759     pub buffer_device_address: Bool32,
39760     pub buffer_device_address_capture_replay: Bool32,
39761     pub buffer_device_address_multi_device: Bool32,
39762 }
39763 impl ::std::default::Default for PhysicalDeviceBufferDeviceAddressFeaturesEXT {
39764     #[inline]
default() -> Self39765     fn default() -> Self {
39766         Self {
39767             s_type: Self::STRUCTURE_TYPE,
39768             p_next: ::std::ptr::null_mut(),
39769             buffer_device_address: Bool32::default(),
39770             buffer_device_address_capture_replay: Bool32::default(),
39771             buffer_device_address_multi_device: Bool32::default(),
39772         }
39773     }
39774 }
39775 unsafe impl TaggedStructure for PhysicalDeviceBufferDeviceAddressFeaturesEXT {
39776     const STRUCTURE_TYPE: StructureType =
39777         StructureType::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
39778 }
39779 impl PhysicalDeviceBufferDeviceAddressFeaturesEXT {
builder<'a>() -> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a>39780     pub fn builder<'a>() -> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
39781         PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder {
39782             inner: Self::default(),
39783             marker: ::std::marker::PhantomData,
39784         }
39785     }
39786 }
39787 #[repr(transparent)]
39788 pub struct PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
39789     inner: PhysicalDeviceBufferDeviceAddressFeaturesEXT,
39790     marker: ::std::marker::PhantomData<&'a ()>,
39791 }
39792 unsafe impl ExtendsPhysicalDeviceFeatures2
39793     for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'_>
39794 {
39795 }
39796 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBufferDeviceAddressFeaturesEXT {}
39797 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'_> {}
39798 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeaturesEXT {}
39799 impl<'a> ::std::ops::Deref for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
39800     type Target = PhysicalDeviceBufferDeviceAddressFeaturesEXT;
deref(&self) -> &Self::Target39801     fn deref(&self) -> &Self::Target {
39802         &self.inner
39803     }
39804 }
39805 impl<'a> ::std::ops::DerefMut for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target39806     fn deref_mut(&mut self) -> &mut Self::Target {
39807         &mut self.inner
39808     }
39809 }
39810 impl<'a> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
39811     #[inline]
buffer_device_address(mut self, buffer_device_address: bool) -> Self39812     pub fn buffer_device_address(mut self, buffer_device_address: bool) -> Self {
39813         self.inner.buffer_device_address = buffer_device_address.into();
39814         self
39815     }
39816     #[inline]
buffer_device_address_capture_replay( mut self, buffer_device_address_capture_replay: bool, ) -> Self39817     pub fn buffer_device_address_capture_replay(
39818         mut self,
39819         buffer_device_address_capture_replay: bool,
39820     ) -> Self {
39821         self.inner.buffer_device_address_capture_replay =
39822             buffer_device_address_capture_replay.into();
39823         self
39824     }
39825     #[inline]
buffer_device_address_multi_device( mut self, buffer_device_address_multi_device: bool, ) -> Self39826     pub fn buffer_device_address_multi_device(
39827         mut self,
39828         buffer_device_address_multi_device: bool,
39829     ) -> Self {
39830         self.inner.buffer_device_address_multi_device = buffer_device_address_multi_device.into();
39831         self
39832     }
39833     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39834     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39835     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceBufferDeviceAddressFeaturesEXT39836     pub fn build(self) -> PhysicalDeviceBufferDeviceAddressFeaturesEXT {
39837         self.inner
39838     }
39839 }
39840 #[repr(C)]
39841 #[cfg_attr(feature = "debug", derive(Debug))]
39842 #[derive(Copy, Clone)]
39843 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferDeviceAddressInfo.html>"]
39844 pub struct BufferDeviceAddressInfo {
39845     pub s_type: StructureType,
39846     pub p_next: *const c_void,
39847     pub buffer: Buffer,
39848 }
39849 impl ::std::default::Default for BufferDeviceAddressInfo {
39850     #[inline]
default() -> Self39851     fn default() -> Self {
39852         Self {
39853             s_type: Self::STRUCTURE_TYPE,
39854             p_next: ::std::ptr::null(),
39855             buffer: Buffer::default(),
39856         }
39857     }
39858 }
39859 unsafe impl TaggedStructure for BufferDeviceAddressInfo {
39860     const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_DEVICE_ADDRESS_INFO;
39861 }
39862 impl BufferDeviceAddressInfo {
builder<'a>() -> BufferDeviceAddressInfoBuilder<'a>39863     pub fn builder<'a>() -> BufferDeviceAddressInfoBuilder<'a> {
39864         BufferDeviceAddressInfoBuilder {
39865             inner: Self::default(),
39866             marker: ::std::marker::PhantomData,
39867         }
39868     }
39869 }
39870 #[repr(transparent)]
39871 pub struct BufferDeviceAddressInfoBuilder<'a> {
39872     inner: BufferDeviceAddressInfo,
39873     marker: ::std::marker::PhantomData<&'a ()>,
39874 }
39875 impl<'a> ::std::ops::Deref for BufferDeviceAddressInfoBuilder<'a> {
39876     type Target = BufferDeviceAddressInfo;
deref(&self) -> &Self::Target39877     fn deref(&self) -> &Self::Target {
39878         &self.inner
39879     }
39880 }
39881 impl<'a> ::std::ops::DerefMut for BufferDeviceAddressInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target39882     fn deref_mut(&mut self) -> &mut Self::Target {
39883         &mut self.inner
39884     }
39885 }
39886 impl<'a> BufferDeviceAddressInfoBuilder<'a> {
39887     #[inline]
buffer(mut self, buffer: Buffer) -> Self39888     pub fn buffer(mut self, buffer: Buffer) -> Self {
39889         self.inner.buffer = buffer;
39890         self
39891     }
39892     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39893     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39894     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferDeviceAddressInfo39895     pub fn build(self) -> BufferDeviceAddressInfo {
39896         self.inner
39897     }
39898 }
39899 #[repr(C)]
39900 #[cfg_attr(feature = "debug", derive(Debug))]
39901 #[derive(Copy, Clone)]
39902 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferOpaqueCaptureAddressCreateInfo.html>"]
39903 pub struct BufferOpaqueCaptureAddressCreateInfo {
39904     pub s_type: StructureType,
39905     pub p_next: *const c_void,
39906     pub opaque_capture_address: u64,
39907 }
39908 impl ::std::default::Default for BufferOpaqueCaptureAddressCreateInfo {
39909     #[inline]
default() -> Self39910     fn default() -> Self {
39911         Self {
39912             s_type: Self::STRUCTURE_TYPE,
39913             p_next: ::std::ptr::null(),
39914             opaque_capture_address: u64::default(),
39915         }
39916     }
39917 }
39918 unsafe impl TaggedStructure for BufferOpaqueCaptureAddressCreateInfo {
39919     const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO;
39920 }
39921 impl BufferOpaqueCaptureAddressCreateInfo {
builder<'a>() -> BufferOpaqueCaptureAddressCreateInfoBuilder<'a>39922     pub fn builder<'a>() -> BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
39923         BufferOpaqueCaptureAddressCreateInfoBuilder {
39924             inner: Self::default(),
39925             marker: ::std::marker::PhantomData,
39926         }
39927     }
39928 }
39929 #[repr(transparent)]
39930 pub struct BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
39931     inner: BufferOpaqueCaptureAddressCreateInfo,
39932     marker: ::std::marker::PhantomData<&'a ()>,
39933 }
39934 unsafe impl ExtendsBufferCreateInfo for BufferOpaqueCaptureAddressCreateInfoBuilder<'_> {}
39935 unsafe impl ExtendsBufferCreateInfo for BufferOpaqueCaptureAddressCreateInfo {}
39936 impl<'a> ::std::ops::Deref for BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
39937     type Target = BufferOpaqueCaptureAddressCreateInfo;
deref(&self) -> &Self::Target39938     fn deref(&self) -> &Self::Target {
39939         &self.inner
39940     }
39941 }
39942 impl<'a> ::std::ops::DerefMut for BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target39943     fn deref_mut(&mut self) -> &mut Self::Target {
39944         &mut self.inner
39945     }
39946 }
39947 impl<'a> BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
39948     #[inline]
opaque_capture_address(mut self, opaque_capture_address: u64) -> Self39949     pub fn opaque_capture_address(mut self, opaque_capture_address: u64) -> Self {
39950         self.inner.opaque_capture_address = opaque_capture_address;
39951         self
39952     }
39953     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39954     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39955     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferOpaqueCaptureAddressCreateInfo39956     pub fn build(self) -> BufferOpaqueCaptureAddressCreateInfo {
39957         self.inner
39958     }
39959 }
39960 #[repr(C)]
39961 #[cfg_attr(feature = "debug", derive(Debug))]
39962 #[derive(Copy, Clone)]
39963 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferDeviceAddressCreateInfoEXT.html>"]
39964 pub struct BufferDeviceAddressCreateInfoEXT {
39965     pub s_type: StructureType,
39966     pub p_next: *const c_void,
39967     pub device_address: DeviceAddress,
39968 }
39969 impl ::std::default::Default for BufferDeviceAddressCreateInfoEXT {
39970     #[inline]
default() -> Self39971     fn default() -> Self {
39972         Self {
39973             s_type: Self::STRUCTURE_TYPE,
39974             p_next: ::std::ptr::null(),
39975             device_address: DeviceAddress::default(),
39976         }
39977     }
39978 }
39979 unsafe impl TaggedStructure for BufferDeviceAddressCreateInfoEXT {
39980     const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT;
39981 }
39982 impl BufferDeviceAddressCreateInfoEXT {
builder<'a>() -> BufferDeviceAddressCreateInfoEXTBuilder<'a>39983     pub fn builder<'a>() -> BufferDeviceAddressCreateInfoEXTBuilder<'a> {
39984         BufferDeviceAddressCreateInfoEXTBuilder {
39985             inner: Self::default(),
39986             marker: ::std::marker::PhantomData,
39987         }
39988     }
39989 }
39990 #[repr(transparent)]
39991 pub struct BufferDeviceAddressCreateInfoEXTBuilder<'a> {
39992     inner: BufferDeviceAddressCreateInfoEXT,
39993     marker: ::std::marker::PhantomData<&'a ()>,
39994 }
39995 unsafe impl ExtendsBufferCreateInfo for BufferDeviceAddressCreateInfoEXTBuilder<'_> {}
39996 unsafe impl ExtendsBufferCreateInfo for BufferDeviceAddressCreateInfoEXT {}
39997 impl<'a> ::std::ops::Deref for BufferDeviceAddressCreateInfoEXTBuilder<'a> {
39998     type Target = BufferDeviceAddressCreateInfoEXT;
deref(&self) -> &Self::Target39999     fn deref(&self) -> &Self::Target {
40000         &self.inner
40001     }
40002 }
40003 impl<'a> ::std::ops::DerefMut for BufferDeviceAddressCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target40004     fn deref_mut(&mut self) -> &mut Self::Target {
40005         &mut self.inner
40006     }
40007 }
40008 impl<'a> BufferDeviceAddressCreateInfoEXTBuilder<'a> {
40009     #[inline]
device_address(mut self, device_address: DeviceAddress) -> Self40010     pub fn device_address(mut self, device_address: DeviceAddress) -> Self {
40011         self.inner.device_address = device_address;
40012         self
40013     }
40014     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40015     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40016     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferDeviceAddressCreateInfoEXT40017     pub fn build(self) -> BufferDeviceAddressCreateInfoEXT {
40018         self.inner
40019     }
40020 }
40021 #[repr(C)]
40022 #[cfg_attr(feature = "debug", derive(Debug))]
40023 #[derive(Copy, Clone)]
40024 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageViewImageFormatInfoEXT.html>"]
40025 pub struct PhysicalDeviceImageViewImageFormatInfoEXT {
40026     pub s_type: StructureType,
40027     pub p_next: *mut c_void,
40028     pub image_view_type: ImageViewType,
40029 }
40030 impl ::std::default::Default for PhysicalDeviceImageViewImageFormatInfoEXT {
40031     #[inline]
default() -> Self40032     fn default() -> Self {
40033         Self {
40034             s_type: Self::STRUCTURE_TYPE,
40035             p_next: ::std::ptr::null_mut(),
40036             image_view_type: ImageViewType::default(),
40037         }
40038     }
40039 }
40040 unsafe impl TaggedStructure for PhysicalDeviceImageViewImageFormatInfoEXT {
40041     const STRUCTURE_TYPE: StructureType =
40042         StructureType::PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT;
40043 }
40044 impl PhysicalDeviceImageViewImageFormatInfoEXT {
builder<'a>() -> PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a>40045     pub fn builder<'a>() -> PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
40046         PhysicalDeviceImageViewImageFormatInfoEXTBuilder {
40047             inner: Self::default(),
40048             marker: ::std::marker::PhantomData,
40049         }
40050     }
40051 }
40052 #[repr(transparent)]
40053 pub struct PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
40054     inner: PhysicalDeviceImageViewImageFormatInfoEXT,
40055     marker: ::std::marker::PhantomData<&'a ()>,
40056 }
40057 unsafe impl ExtendsPhysicalDeviceImageFormatInfo2
40058     for PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'_>
40059 {
40060 }
40061 unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceImageViewImageFormatInfoEXT {}
40062 impl<'a> ::std::ops::Deref for PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
40063     type Target = PhysicalDeviceImageViewImageFormatInfoEXT;
deref(&self) -> &Self::Target40064     fn deref(&self) -> &Self::Target {
40065         &self.inner
40066     }
40067 }
40068 impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target40069     fn deref_mut(&mut self) -> &mut Self::Target {
40070         &mut self.inner
40071     }
40072 }
40073 impl<'a> PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
40074     #[inline]
image_view_type(mut self, image_view_type: ImageViewType) -> Self40075     pub fn image_view_type(mut self, image_view_type: ImageViewType) -> Self {
40076         self.inner.image_view_type = image_view_type;
40077         self
40078     }
40079     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40080     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40081     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceImageViewImageFormatInfoEXT40082     pub fn build(self) -> PhysicalDeviceImageViewImageFormatInfoEXT {
40083         self.inner
40084     }
40085 }
40086 #[repr(C)]
40087 #[cfg_attr(feature = "debug", derive(Debug))]
40088 #[derive(Copy, Clone)]
40089 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFilterCubicImageViewImageFormatPropertiesEXT.html>"]
40090 pub struct FilterCubicImageViewImageFormatPropertiesEXT {
40091     pub s_type: StructureType,
40092     pub p_next: *mut c_void,
40093     pub filter_cubic: Bool32,
40094     pub filter_cubic_minmax: Bool32,
40095 }
40096 impl ::std::default::Default for FilterCubicImageViewImageFormatPropertiesEXT {
40097     #[inline]
default() -> Self40098     fn default() -> Self {
40099         Self {
40100             s_type: Self::STRUCTURE_TYPE,
40101             p_next: ::std::ptr::null_mut(),
40102             filter_cubic: Bool32::default(),
40103             filter_cubic_minmax: Bool32::default(),
40104         }
40105     }
40106 }
40107 unsafe impl TaggedStructure for FilterCubicImageViewImageFormatPropertiesEXT {
40108     const STRUCTURE_TYPE: StructureType =
40109         StructureType::FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT;
40110 }
40111 impl FilterCubicImageViewImageFormatPropertiesEXT {
builder<'a>() -> FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a>40112     pub fn builder<'a>() -> FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
40113         FilterCubicImageViewImageFormatPropertiesEXTBuilder {
40114             inner: Self::default(),
40115             marker: ::std::marker::PhantomData,
40116         }
40117     }
40118 }
40119 #[repr(transparent)]
40120 pub struct FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
40121     inner: FilterCubicImageViewImageFormatPropertiesEXT,
40122     marker: ::std::marker::PhantomData<&'a ()>,
40123 }
40124 unsafe impl ExtendsImageFormatProperties2
40125     for FilterCubicImageViewImageFormatPropertiesEXTBuilder<'_>
40126 {
40127 }
40128 unsafe impl ExtendsImageFormatProperties2 for FilterCubicImageViewImageFormatPropertiesEXT {}
40129 impl<'a> ::std::ops::Deref for FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
40130     type Target = FilterCubicImageViewImageFormatPropertiesEXT;
deref(&self) -> &Self::Target40131     fn deref(&self) -> &Self::Target {
40132         &self.inner
40133     }
40134 }
40135 impl<'a> ::std::ops::DerefMut for FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target40136     fn deref_mut(&mut self) -> &mut Self::Target {
40137         &mut self.inner
40138     }
40139 }
40140 impl<'a> FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
40141     #[inline]
filter_cubic(mut self, filter_cubic: bool) -> Self40142     pub fn filter_cubic(mut self, filter_cubic: bool) -> Self {
40143         self.inner.filter_cubic = filter_cubic.into();
40144         self
40145     }
40146     #[inline]
filter_cubic_minmax(mut self, filter_cubic_minmax: bool) -> Self40147     pub fn filter_cubic_minmax(mut self, filter_cubic_minmax: bool) -> Self {
40148         self.inner.filter_cubic_minmax = filter_cubic_minmax.into();
40149         self
40150     }
40151     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40152     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40153     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> FilterCubicImageViewImageFormatPropertiesEXT40154     pub fn build(self) -> FilterCubicImageViewImageFormatPropertiesEXT {
40155         self.inner
40156     }
40157 }
40158 #[repr(C)]
40159 #[cfg_attr(feature = "debug", derive(Debug))]
40160 #[derive(Copy, Clone)]
40161 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImagelessFramebufferFeatures.html>"]
40162 pub struct PhysicalDeviceImagelessFramebufferFeatures {
40163     pub s_type: StructureType,
40164     pub p_next: *mut c_void,
40165     pub imageless_framebuffer: Bool32,
40166 }
40167 impl ::std::default::Default for PhysicalDeviceImagelessFramebufferFeatures {
40168     #[inline]
default() -> Self40169     fn default() -> Self {
40170         Self {
40171             s_type: Self::STRUCTURE_TYPE,
40172             p_next: ::std::ptr::null_mut(),
40173             imageless_framebuffer: Bool32::default(),
40174         }
40175     }
40176 }
40177 unsafe impl TaggedStructure for PhysicalDeviceImagelessFramebufferFeatures {
40178     const STRUCTURE_TYPE: StructureType =
40179         StructureType::PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
40180 }
40181 impl PhysicalDeviceImagelessFramebufferFeatures {
builder<'a>() -> PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a>40182     pub fn builder<'a>() -> PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
40183         PhysicalDeviceImagelessFramebufferFeaturesBuilder {
40184             inner: Self::default(),
40185             marker: ::std::marker::PhantomData,
40186         }
40187     }
40188 }
40189 #[repr(transparent)]
40190 pub struct PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
40191     inner: PhysicalDeviceImagelessFramebufferFeatures,
40192     marker: ::std::marker::PhantomData<&'a ()>,
40193 }
40194 unsafe impl ExtendsPhysicalDeviceFeatures2
40195     for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'_>
40196 {
40197 }
40198 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImagelessFramebufferFeatures {}
40199 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'_> {}
40200 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImagelessFramebufferFeatures {}
40201 impl<'a> ::std::ops::Deref for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
40202     type Target = PhysicalDeviceImagelessFramebufferFeatures;
deref(&self) -> &Self::Target40203     fn deref(&self) -> &Self::Target {
40204         &self.inner
40205     }
40206 }
40207 impl<'a> ::std::ops::DerefMut for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target40208     fn deref_mut(&mut self) -> &mut Self::Target {
40209         &mut self.inner
40210     }
40211 }
40212 impl<'a> PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
40213     #[inline]
imageless_framebuffer(mut self, imageless_framebuffer: bool) -> Self40214     pub fn imageless_framebuffer(mut self, imageless_framebuffer: bool) -> Self {
40215         self.inner.imageless_framebuffer = imageless_framebuffer.into();
40216         self
40217     }
40218     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40219     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40220     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceImagelessFramebufferFeatures40221     pub fn build(self) -> PhysicalDeviceImagelessFramebufferFeatures {
40222         self.inner
40223     }
40224 }
40225 #[repr(C)]
40226 #[cfg_attr(feature = "debug", derive(Debug))]
40227 #[derive(Copy, Clone)]
40228 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebufferAttachmentsCreateInfo.html>"]
40229 pub struct FramebufferAttachmentsCreateInfo {
40230     pub s_type: StructureType,
40231     pub p_next: *const c_void,
40232     pub attachment_image_info_count: u32,
40233     pub p_attachment_image_infos: *const FramebufferAttachmentImageInfo,
40234 }
40235 impl ::std::default::Default for FramebufferAttachmentsCreateInfo {
40236     #[inline]
default() -> Self40237     fn default() -> Self {
40238         Self {
40239             s_type: Self::STRUCTURE_TYPE,
40240             p_next: ::std::ptr::null(),
40241             attachment_image_info_count: u32::default(),
40242             p_attachment_image_infos: ::std::ptr::null(),
40243         }
40244     }
40245 }
40246 unsafe impl TaggedStructure for FramebufferAttachmentsCreateInfo {
40247     const STRUCTURE_TYPE: StructureType = StructureType::FRAMEBUFFER_ATTACHMENTS_CREATE_INFO;
40248 }
40249 impl FramebufferAttachmentsCreateInfo {
builder<'a>() -> FramebufferAttachmentsCreateInfoBuilder<'a>40250     pub fn builder<'a>() -> FramebufferAttachmentsCreateInfoBuilder<'a> {
40251         FramebufferAttachmentsCreateInfoBuilder {
40252             inner: Self::default(),
40253             marker: ::std::marker::PhantomData,
40254         }
40255     }
40256 }
40257 #[repr(transparent)]
40258 pub struct FramebufferAttachmentsCreateInfoBuilder<'a> {
40259     inner: FramebufferAttachmentsCreateInfo,
40260     marker: ::std::marker::PhantomData<&'a ()>,
40261 }
40262 unsafe impl ExtendsFramebufferCreateInfo for FramebufferAttachmentsCreateInfoBuilder<'_> {}
40263 unsafe impl ExtendsFramebufferCreateInfo for FramebufferAttachmentsCreateInfo {}
40264 impl<'a> ::std::ops::Deref for FramebufferAttachmentsCreateInfoBuilder<'a> {
40265     type Target = FramebufferAttachmentsCreateInfo;
deref(&self) -> &Self::Target40266     fn deref(&self) -> &Self::Target {
40267         &self.inner
40268     }
40269 }
40270 impl<'a> ::std::ops::DerefMut for FramebufferAttachmentsCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target40271     fn deref_mut(&mut self) -> &mut Self::Target {
40272         &mut self.inner
40273     }
40274 }
40275 impl<'a> FramebufferAttachmentsCreateInfoBuilder<'a> {
40276     #[inline]
attachment_image_infos( mut self, attachment_image_infos: &'a [FramebufferAttachmentImageInfo], ) -> Self40277     pub fn attachment_image_infos(
40278         mut self,
40279         attachment_image_infos: &'a [FramebufferAttachmentImageInfo],
40280     ) -> Self {
40281         self.inner.attachment_image_info_count = attachment_image_infos.len() as _;
40282         self.inner.p_attachment_image_infos = attachment_image_infos.as_ptr();
40283         self
40284     }
40285     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40286     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40287     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> FramebufferAttachmentsCreateInfo40288     pub fn build(self) -> FramebufferAttachmentsCreateInfo {
40289         self.inner
40290     }
40291 }
40292 #[repr(C)]
40293 #[cfg_attr(feature = "debug", derive(Debug))]
40294 #[derive(Copy, Clone)]
40295 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebufferAttachmentImageInfo.html>"]
40296 pub struct FramebufferAttachmentImageInfo {
40297     pub s_type: StructureType,
40298     pub p_next: *const c_void,
40299     pub flags: ImageCreateFlags,
40300     pub usage: ImageUsageFlags,
40301     pub width: u32,
40302     pub height: u32,
40303     pub layer_count: u32,
40304     pub view_format_count: u32,
40305     pub p_view_formats: *const Format,
40306 }
40307 impl ::std::default::Default for FramebufferAttachmentImageInfo {
40308     #[inline]
default() -> Self40309     fn default() -> Self {
40310         Self {
40311             s_type: Self::STRUCTURE_TYPE,
40312             p_next: ::std::ptr::null(),
40313             flags: ImageCreateFlags::default(),
40314             usage: ImageUsageFlags::default(),
40315             width: u32::default(),
40316             height: u32::default(),
40317             layer_count: u32::default(),
40318             view_format_count: u32::default(),
40319             p_view_formats: ::std::ptr::null(),
40320         }
40321     }
40322 }
40323 unsafe impl TaggedStructure for FramebufferAttachmentImageInfo {
40324     const STRUCTURE_TYPE: StructureType = StructureType::FRAMEBUFFER_ATTACHMENT_IMAGE_INFO;
40325 }
40326 impl FramebufferAttachmentImageInfo {
builder<'a>() -> FramebufferAttachmentImageInfoBuilder<'a>40327     pub fn builder<'a>() -> FramebufferAttachmentImageInfoBuilder<'a> {
40328         FramebufferAttachmentImageInfoBuilder {
40329             inner: Self::default(),
40330             marker: ::std::marker::PhantomData,
40331         }
40332     }
40333 }
40334 #[repr(transparent)]
40335 pub struct FramebufferAttachmentImageInfoBuilder<'a> {
40336     inner: FramebufferAttachmentImageInfo,
40337     marker: ::std::marker::PhantomData<&'a ()>,
40338 }
40339 impl<'a> ::std::ops::Deref for FramebufferAttachmentImageInfoBuilder<'a> {
40340     type Target = FramebufferAttachmentImageInfo;
deref(&self) -> &Self::Target40341     fn deref(&self) -> &Self::Target {
40342         &self.inner
40343     }
40344 }
40345 impl<'a> ::std::ops::DerefMut for FramebufferAttachmentImageInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target40346     fn deref_mut(&mut self) -> &mut Self::Target {
40347         &mut self.inner
40348     }
40349 }
40350 impl<'a> FramebufferAttachmentImageInfoBuilder<'a> {
40351     #[inline]
flags(mut self, flags: ImageCreateFlags) -> Self40352     pub fn flags(mut self, flags: ImageCreateFlags) -> Self {
40353         self.inner.flags = flags;
40354         self
40355     }
40356     #[inline]
usage(mut self, usage: ImageUsageFlags) -> Self40357     pub fn usage(mut self, usage: ImageUsageFlags) -> Self {
40358         self.inner.usage = usage;
40359         self
40360     }
40361     #[inline]
width(mut self, width: u32) -> Self40362     pub fn width(mut self, width: u32) -> Self {
40363         self.inner.width = width;
40364         self
40365     }
40366     #[inline]
height(mut self, height: u32) -> Self40367     pub fn height(mut self, height: u32) -> Self {
40368         self.inner.height = height;
40369         self
40370     }
40371     #[inline]
layer_count(mut self, layer_count: u32) -> Self40372     pub fn layer_count(mut self, layer_count: u32) -> Self {
40373         self.inner.layer_count = layer_count;
40374         self
40375     }
40376     #[inline]
view_formats(mut self, view_formats: &'a [Format]) -> Self40377     pub fn view_formats(mut self, view_formats: &'a [Format]) -> Self {
40378         self.inner.view_format_count = view_formats.len() as _;
40379         self.inner.p_view_formats = view_formats.as_ptr();
40380         self
40381     }
40382     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40383     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40384     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> FramebufferAttachmentImageInfo40385     pub fn build(self) -> FramebufferAttachmentImageInfo {
40386         self.inner
40387     }
40388 }
40389 #[repr(C)]
40390 #[cfg_attr(feature = "debug", derive(Debug))]
40391 #[derive(Copy, Clone)]
40392 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassAttachmentBeginInfo.html>"]
40393 pub struct RenderPassAttachmentBeginInfo {
40394     pub s_type: StructureType,
40395     pub p_next: *const c_void,
40396     pub attachment_count: u32,
40397     pub p_attachments: *const ImageView,
40398 }
40399 impl ::std::default::Default for RenderPassAttachmentBeginInfo {
40400     #[inline]
default() -> Self40401     fn default() -> Self {
40402         Self {
40403             s_type: Self::STRUCTURE_TYPE,
40404             p_next: ::std::ptr::null(),
40405             attachment_count: u32::default(),
40406             p_attachments: ::std::ptr::null(),
40407         }
40408     }
40409 }
40410 unsafe impl TaggedStructure for RenderPassAttachmentBeginInfo {
40411     const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_ATTACHMENT_BEGIN_INFO;
40412 }
40413 impl RenderPassAttachmentBeginInfo {
builder<'a>() -> RenderPassAttachmentBeginInfoBuilder<'a>40414     pub fn builder<'a>() -> RenderPassAttachmentBeginInfoBuilder<'a> {
40415         RenderPassAttachmentBeginInfoBuilder {
40416             inner: Self::default(),
40417             marker: ::std::marker::PhantomData,
40418         }
40419     }
40420 }
40421 #[repr(transparent)]
40422 pub struct RenderPassAttachmentBeginInfoBuilder<'a> {
40423     inner: RenderPassAttachmentBeginInfo,
40424     marker: ::std::marker::PhantomData<&'a ()>,
40425 }
40426 unsafe impl ExtendsRenderPassBeginInfo for RenderPassAttachmentBeginInfoBuilder<'_> {}
40427 unsafe impl ExtendsRenderPassBeginInfo for RenderPassAttachmentBeginInfo {}
40428 impl<'a> ::std::ops::Deref for RenderPassAttachmentBeginInfoBuilder<'a> {
40429     type Target = RenderPassAttachmentBeginInfo;
deref(&self) -> &Self::Target40430     fn deref(&self) -> &Self::Target {
40431         &self.inner
40432     }
40433 }
40434 impl<'a> ::std::ops::DerefMut for RenderPassAttachmentBeginInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target40435     fn deref_mut(&mut self) -> &mut Self::Target {
40436         &mut self.inner
40437     }
40438 }
40439 impl<'a> RenderPassAttachmentBeginInfoBuilder<'a> {
40440     #[inline]
attachments(mut self, attachments: &'a [ImageView]) -> Self40441     pub fn attachments(mut self, attachments: &'a [ImageView]) -> Self {
40442         self.inner.attachment_count = attachments.len() as _;
40443         self.inner.p_attachments = attachments.as_ptr();
40444         self
40445     }
40446     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40447     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40448     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RenderPassAttachmentBeginInfo40449     pub fn build(self) -> RenderPassAttachmentBeginInfo {
40450         self.inner
40451     }
40452 }
40453 #[repr(C)]
40454 #[cfg_attr(feature = "debug", derive(Debug))]
40455 #[derive(Copy, Clone)]
40456 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTextureCompressionASTCHDRFeatures.html>"]
40457 pub struct PhysicalDeviceTextureCompressionASTCHDRFeatures {
40458     pub s_type: StructureType,
40459     pub p_next: *mut c_void,
40460     pub texture_compression_astc_hdr: Bool32,
40461 }
40462 impl ::std::default::Default for PhysicalDeviceTextureCompressionASTCHDRFeatures {
40463     #[inline]
default() -> Self40464     fn default() -> Self {
40465         Self {
40466             s_type: Self::STRUCTURE_TYPE,
40467             p_next: ::std::ptr::null_mut(),
40468             texture_compression_astc_hdr: Bool32::default(),
40469         }
40470     }
40471 }
40472 unsafe impl TaggedStructure for PhysicalDeviceTextureCompressionASTCHDRFeatures {
40473     const STRUCTURE_TYPE: StructureType =
40474         StructureType::PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
40475 }
40476 impl PhysicalDeviceTextureCompressionASTCHDRFeatures {
builder<'a>() -> PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a>40477     pub fn builder<'a>() -> PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> {
40478         PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder {
40479             inner: Self::default(),
40480             marker: ::std::marker::PhantomData,
40481         }
40482     }
40483 }
40484 #[repr(transparent)]
40485 pub struct PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> {
40486     inner: PhysicalDeviceTextureCompressionASTCHDRFeatures,
40487     marker: ::std::marker::PhantomData<&'a ()>,
40488 }
40489 unsafe impl ExtendsPhysicalDeviceFeatures2
40490     for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'_>
40491 {
40492 }
40493 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTextureCompressionASTCHDRFeatures {}
40494 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'_> {}
40495 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTextureCompressionASTCHDRFeatures {}
40496 impl<'a> ::std::ops::Deref for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> {
40497     type Target = PhysicalDeviceTextureCompressionASTCHDRFeatures;
deref(&self) -> &Self::Target40498     fn deref(&self) -> &Self::Target {
40499         &self.inner
40500     }
40501 }
40502 impl<'a> ::std::ops::DerefMut for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target40503     fn deref_mut(&mut self) -> &mut Self::Target {
40504         &mut self.inner
40505     }
40506 }
40507 impl<'a> PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> {
40508     #[inline]
texture_compression_astc_hdr(mut self, texture_compression_astc_hdr: bool) -> Self40509     pub fn texture_compression_astc_hdr(mut self, texture_compression_astc_hdr: bool) -> Self {
40510         self.inner.texture_compression_astc_hdr = texture_compression_astc_hdr.into();
40511         self
40512     }
40513     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40514     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40515     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceTextureCompressionASTCHDRFeatures40516     pub fn build(self) -> PhysicalDeviceTextureCompressionASTCHDRFeatures {
40517         self.inner
40518     }
40519 }
40520 #[repr(C)]
40521 #[cfg_attr(feature = "debug", derive(Debug))]
40522 #[derive(Copy, Clone)]
40523 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCooperativeMatrixFeaturesNV.html>"]
40524 pub struct PhysicalDeviceCooperativeMatrixFeaturesNV {
40525     pub s_type: StructureType,
40526     pub p_next: *mut c_void,
40527     pub cooperative_matrix: Bool32,
40528     pub cooperative_matrix_robust_buffer_access: Bool32,
40529 }
40530 impl ::std::default::Default for PhysicalDeviceCooperativeMatrixFeaturesNV {
40531     #[inline]
default() -> Self40532     fn default() -> Self {
40533         Self {
40534             s_type: Self::STRUCTURE_TYPE,
40535             p_next: ::std::ptr::null_mut(),
40536             cooperative_matrix: Bool32::default(),
40537             cooperative_matrix_robust_buffer_access: Bool32::default(),
40538         }
40539     }
40540 }
40541 unsafe impl TaggedStructure for PhysicalDeviceCooperativeMatrixFeaturesNV {
40542     const STRUCTURE_TYPE: StructureType =
40543         StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
40544 }
40545 impl PhysicalDeviceCooperativeMatrixFeaturesNV {
builder<'a>() -> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a>40546     pub fn builder<'a>() -> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
40547         PhysicalDeviceCooperativeMatrixFeaturesNVBuilder {
40548             inner: Self::default(),
40549             marker: ::std::marker::PhantomData,
40550         }
40551     }
40552 }
40553 #[repr(transparent)]
40554 pub struct PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
40555     inner: PhysicalDeviceCooperativeMatrixFeaturesNV,
40556     marker: ::std::marker::PhantomData<&'a ()>,
40557 }
40558 unsafe impl ExtendsPhysicalDeviceFeatures2
40559     for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'_>
40560 {
40561 }
40562 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCooperativeMatrixFeaturesNV {}
40563 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'_> {}
40564 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCooperativeMatrixFeaturesNV {}
40565 impl<'a> ::std::ops::Deref for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
40566     type Target = PhysicalDeviceCooperativeMatrixFeaturesNV;
deref(&self) -> &Self::Target40567     fn deref(&self) -> &Self::Target {
40568         &self.inner
40569     }
40570 }
40571 impl<'a> ::std::ops::DerefMut for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target40572     fn deref_mut(&mut self) -> &mut Self::Target {
40573         &mut self.inner
40574     }
40575 }
40576 impl<'a> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
40577     #[inline]
cooperative_matrix(mut self, cooperative_matrix: bool) -> Self40578     pub fn cooperative_matrix(mut self, cooperative_matrix: bool) -> Self {
40579         self.inner.cooperative_matrix = cooperative_matrix.into();
40580         self
40581     }
40582     #[inline]
cooperative_matrix_robust_buffer_access( mut self, cooperative_matrix_robust_buffer_access: bool, ) -> Self40583     pub fn cooperative_matrix_robust_buffer_access(
40584         mut self,
40585         cooperative_matrix_robust_buffer_access: bool,
40586     ) -> Self {
40587         self.inner.cooperative_matrix_robust_buffer_access =
40588             cooperative_matrix_robust_buffer_access.into();
40589         self
40590     }
40591     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40592     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40593     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceCooperativeMatrixFeaturesNV40594     pub fn build(self) -> PhysicalDeviceCooperativeMatrixFeaturesNV {
40595         self.inner
40596     }
40597 }
40598 #[repr(C)]
40599 #[cfg_attr(feature = "debug", derive(Debug))]
40600 #[derive(Copy, Clone)]
40601 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCooperativeMatrixPropertiesNV.html>"]
40602 pub struct PhysicalDeviceCooperativeMatrixPropertiesNV {
40603     pub s_type: StructureType,
40604     pub p_next: *mut c_void,
40605     pub cooperative_matrix_supported_stages: ShaderStageFlags,
40606 }
40607 impl ::std::default::Default for PhysicalDeviceCooperativeMatrixPropertiesNV {
40608     #[inline]
default() -> Self40609     fn default() -> Self {
40610         Self {
40611             s_type: Self::STRUCTURE_TYPE,
40612             p_next: ::std::ptr::null_mut(),
40613             cooperative_matrix_supported_stages: ShaderStageFlags::default(),
40614         }
40615     }
40616 }
40617 unsafe impl TaggedStructure for PhysicalDeviceCooperativeMatrixPropertiesNV {
40618     const STRUCTURE_TYPE: StructureType =
40619         StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV;
40620 }
40621 impl PhysicalDeviceCooperativeMatrixPropertiesNV {
builder<'a>() -> PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a>40622     pub fn builder<'a>() -> PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
40623         PhysicalDeviceCooperativeMatrixPropertiesNVBuilder {
40624             inner: Self::default(),
40625             marker: ::std::marker::PhantomData,
40626         }
40627     }
40628 }
40629 #[repr(transparent)]
40630 pub struct PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
40631     inner: PhysicalDeviceCooperativeMatrixPropertiesNV,
40632     marker: ::std::marker::PhantomData<&'a ()>,
40633 }
40634 unsafe impl ExtendsPhysicalDeviceProperties2
40635     for PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'_>
40636 {
40637 }
40638 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCooperativeMatrixPropertiesNV {}
40639 impl<'a> ::std::ops::Deref for PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
40640     type Target = PhysicalDeviceCooperativeMatrixPropertiesNV;
deref(&self) -> &Self::Target40641     fn deref(&self) -> &Self::Target {
40642         &self.inner
40643     }
40644 }
40645 impl<'a> ::std::ops::DerefMut for PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target40646     fn deref_mut(&mut self) -> &mut Self::Target {
40647         &mut self.inner
40648     }
40649 }
40650 impl<'a> PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
40651     #[inline]
cooperative_matrix_supported_stages( mut self, cooperative_matrix_supported_stages: ShaderStageFlags, ) -> Self40652     pub fn cooperative_matrix_supported_stages(
40653         mut self,
40654         cooperative_matrix_supported_stages: ShaderStageFlags,
40655     ) -> Self {
40656         self.inner.cooperative_matrix_supported_stages = cooperative_matrix_supported_stages;
40657         self
40658     }
40659     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40660     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40661     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceCooperativeMatrixPropertiesNV40662     pub fn build(self) -> PhysicalDeviceCooperativeMatrixPropertiesNV {
40663         self.inner
40664     }
40665 }
40666 #[repr(C)]
40667 #[cfg_attr(feature = "debug", derive(Debug))]
40668 #[derive(Copy, Clone)]
40669 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCooperativeMatrixPropertiesNV.html>"]
40670 pub struct CooperativeMatrixPropertiesNV {
40671     pub s_type: StructureType,
40672     pub p_next: *mut c_void,
40673     pub m_size: u32,
40674     pub n_size: u32,
40675     pub k_size: u32,
40676     pub a_type: ComponentTypeNV,
40677     pub b_type: ComponentTypeNV,
40678     pub c_type: ComponentTypeNV,
40679     pub d_type: ComponentTypeNV,
40680     pub scope: ScopeNV,
40681 }
40682 impl ::std::default::Default for CooperativeMatrixPropertiesNV {
40683     #[inline]
default() -> Self40684     fn default() -> Self {
40685         Self {
40686             s_type: Self::STRUCTURE_TYPE,
40687             p_next: ::std::ptr::null_mut(),
40688             m_size: u32::default(),
40689             n_size: u32::default(),
40690             k_size: u32::default(),
40691             a_type: ComponentTypeNV::default(),
40692             b_type: ComponentTypeNV::default(),
40693             c_type: ComponentTypeNV::default(),
40694             d_type: ComponentTypeNV::default(),
40695             scope: ScopeNV::default(),
40696         }
40697     }
40698 }
40699 unsafe impl TaggedStructure for CooperativeMatrixPropertiesNV {
40700     const STRUCTURE_TYPE: StructureType = StructureType::COOPERATIVE_MATRIX_PROPERTIES_NV;
40701 }
40702 impl CooperativeMatrixPropertiesNV {
builder<'a>() -> CooperativeMatrixPropertiesNVBuilder<'a>40703     pub fn builder<'a>() -> CooperativeMatrixPropertiesNVBuilder<'a> {
40704         CooperativeMatrixPropertiesNVBuilder {
40705             inner: Self::default(),
40706             marker: ::std::marker::PhantomData,
40707         }
40708     }
40709 }
40710 #[repr(transparent)]
40711 pub struct CooperativeMatrixPropertiesNVBuilder<'a> {
40712     inner: CooperativeMatrixPropertiesNV,
40713     marker: ::std::marker::PhantomData<&'a ()>,
40714 }
40715 impl<'a> ::std::ops::Deref for CooperativeMatrixPropertiesNVBuilder<'a> {
40716     type Target = CooperativeMatrixPropertiesNV;
deref(&self) -> &Self::Target40717     fn deref(&self) -> &Self::Target {
40718         &self.inner
40719     }
40720 }
40721 impl<'a> ::std::ops::DerefMut for CooperativeMatrixPropertiesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target40722     fn deref_mut(&mut self) -> &mut Self::Target {
40723         &mut self.inner
40724     }
40725 }
40726 impl<'a> CooperativeMatrixPropertiesNVBuilder<'a> {
40727     #[inline]
m_size(mut self, m_size: u32) -> Self40728     pub fn m_size(mut self, m_size: u32) -> Self {
40729         self.inner.m_size = m_size;
40730         self
40731     }
40732     #[inline]
n_size(mut self, n_size: u32) -> Self40733     pub fn n_size(mut self, n_size: u32) -> Self {
40734         self.inner.n_size = n_size;
40735         self
40736     }
40737     #[inline]
k_size(mut self, k_size: u32) -> Self40738     pub fn k_size(mut self, k_size: u32) -> Self {
40739         self.inner.k_size = k_size;
40740         self
40741     }
40742     #[inline]
a_type(mut self, a_type: ComponentTypeNV) -> Self40743     pub fn a_type(mut self, a_type: ComponentTypeNV) -> Self {
40744         self.inner.a_type = a_type;
40745         self
40746     }
40747     #[inline]
b_type(mut self, b_type: ComponentTypeNV) -> Self40748     pub fn b_type(mut self, b_type: ComponentTypeNV) -> Self {
40749         self.inner.b_type = b_type;
40750         self
40751     }
40752     #[inline]
c_type(mut self, c_type: ComponentTypeNV) -> Self40753     pub fn c_type(mut self, c_type: ComponentTypeNV) -> Self {
40754         self.inner.c_type = c_type;
40755         self
40756     }
40757     #[inline]
d_type(mut self, d_type: ComponentTypeNV) -> Self40758     pub fn d_type(mut self, d_type: ComponentTypeNV) -> Self {
40759         self.inner.d_type = d_type;
40760         self
40761     }
40762     #[inline]
scope(mut self, scope: ScopeNV) -> Self40763     pub fn scope(mut self, scope: ScopeNV) -> Self {
40764         self.inner.scope = scope;
40765         self
40766     }
40767     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40768     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40769     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CooperativeMatrixPropertiesNV40770     pub fn build(self) -> CooperativeMatrixPropertiesNV {
40771         self.inner
40772     }
40773 }
40774 #[repr(C)]
40775 #[cfg_attr(feature = "debug", derive(Debug))]
40776 #[derive(Copy, Clone)]
40777 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceYcbcrImageArraysFeaturesEXT.html>"]
40778 pub struct PhysicalDeviceYcbcrImageArraysFeaturesEXT {
40779     pub s_type: StructureType,
40780     pub p_next: *mut c_void,
40781     pub ycbcr_image_arrays: Bool32,
40782 }
40783 impl ::std::default::Default for PhysicalDeviceYcbcrImageArraysFeaturesEXT {
40784     #[inline]
default() -> Self40785     fn default() -> Self {
40786         Self {
40787             s_type: Self::STRUCTURE_TYPE,
40788             p_next: ::std::ptr::null_mut(),
40789             ycbcr_image_arrays: Bool32::default(),
40790         }
40791     }
40792 }
40793 unsafe impl TaggedStructure for PhysicalDeviceYcbcrImageArraysFeaturesEXT {
40794     const STRUCTURE_TYPE: StructureType =
40795         StructureType::PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
40796 }
40797 impl PhysicalDeviceYcbcrImageArraysFeaturesEXT {
builder<'a>() -> PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a>40798     pub fn builder<'a>() -> PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
40799         PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder {
40800             inner: Self::default(),
40801             marker: ::std::marker::PhantomData,
40802         }
40803     }
40804 }
40805 #[repr(transparent)]
40806 pub struct PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
40807     inner: PhysicalDeviceYcbcrImageArraysFeaturesEXT,
40808     marker: ::std::marker::PhantomData<&'a ()>,
40809 }
40810 unsafe impl ExtendsPhysicalDeviceFeatures2
40811     for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'_>
40812 {
40813 }
40814 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceYcbcrImageArraysFeaturesEXT {}
40815 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'_> {}
40816 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcrImageArraysFeaturesEXT {}
40817 impl<'a> ::std::ops::Deref for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
40818     type Target = PhysicalDeviceYcbcrImageArraysFeaturesEXT;
deref(&self) -> &Self::Target40819     fn deref(&self) -> &Self::Target {
40820         &self.inner
40821     }
40822 }
40823 impl<'a> ::std::ops::DerefMut for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target40824     fn deref_mut(&mut self) -> &mut Self::Target {
40825         &mut self.inner
40826     }
40827 }
40828 impl<'a> PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
40829     #[inline]
ycbcr_image_arrays(mut self, ycbcr_image_arrays: bool) -> Self40830     pub fn ycbcr_image_arrays(mut self, ycbcr_image_arrays: bool) -> Self {
40831         self.inner.ycbcr_image_arrays = ycbcr_image_arrays.into();
40832         self
40833     }
40834     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40835     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40836     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceYcbcrImageArraysFeaturesEXT40837     pub fn build(self) -> PhysicalDeviceYcbcrImageArraysFeaturesEXT {
40838         self.inner
40839     }
40840 }
40841 #[repr(C)]
40842 #[cfg_attr(feature = "debug", derive(Debug))]
40843 #[derive(Copy, Clone)]
40844 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewHandleInfoNVX.html>"]
40845 pub struct ImageViewHandleInfoNVX {
40846     pub s_type: StructureType,
40847     pub p_next: *const c_void,
40848     pub image_view: ImageView,
40849     pub descriptor_type: DescriptorType,
40850     pub sampler: Sampler,
40851 }
40852 impl ::std::default::Default for ImageViewHandleInfoNVX {
40853     #[inline]
default() -> Self40854     fn default() -> Self {
40855         Self {
40856             s_type: Self::STRUCTURE_TYPE,
40857             p_next: ::std::ptr::null(),
40858             image_view: ImageView::default(),
40859             descriptor_type: DescriptorType::default(),
40860             sampler: Sampler::default(),
40861         }
40862     }
40863 }
40864 unsafe impl TaggedStructure for ImageViewHandleInfoNVX {
40865     const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_HANDLE_INFO_NVX;
40866 }
40867 impl ImageViewHandleInfoNVX {
builder<'a>() -> ImageViewHandleInfoNVXBuilder<'a>40868     pub fn builder<'a>() -> ImageViewHandleInfoNVXBuilder<'a> {
40869         ImageViewHandleInfoNVXBuilder {
40870             inner: Self::default(),
40871             marker: ::std::marker::PhantomData,
40872         }
40873     }
40874 }
40875 #[repr(transparent)]
40876 pub struct ImageViewHandleInfoNVXBuilder<'a> {
40877     inner: ImageViewHandleInfoNVX,
40878     marker: ::std::marker::PhantomData<&'a ()>,
40879 }
40880 impl<'a> ::std::ops::Deref for ImageViewHandleInfoNVXBuilder<'a> {
40881     type Target = ImageViewHandleInfoNVX;
deref(&self) -> &Self::Target40882     fn deref(&self) -> &Self::Target {
40883         &self.inner
40884     }
40885 }
40886 impl<'a> ::std::ops::DerefMut for ImageViewHandleInfoNVXBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target40887     fn deref_mut(&mut self) -> &mut Self::Target {
40888         &mut self.inner
40889     }
40890 }
40891 impl<'a> ImageViewHandleInfoNVXBuilder<'a> {
40892     #[inline]
image_view(mut self, image_view: ImageView) -> Self40893     pub fn image_view(mut self, image_view: ImageView) -> Self {
40894         self.inner.image_view = image_view;
40895         self
40896     }
40897     #[inline]
descriptor_type(mut self, descriptor_type: DescriptorType) -> Self40898     pub fn descriptor_type(mut self, descriptor_type: DescriptorType) -> Self {
40899         self.inner.descriptor_type = descriptor_type;
40900         self
40901     }
40902     #[inline]
sampler(mut self, sampler: Sampler) -> Self40903     pub fn sampler(mut self, sampler: Sampler) -> Self {
40904         self.inner.sampler = sampler;
40905         self
40906     }
40907     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40908     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40909     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageViewHandleInfoNVX40910     pub fn build(self) -> ImageViewHandleInfoNVX {
40911         self.inner
40912     }
40913 }
40914 #[repr(C)]
40915 #[cfg_attr(feature = "debug", derive(Debug))]
40916 #[derive(Copy, Clone)]
40917 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewAddressPropertiesNVX.html>"]
40918 pub struct ImageViewAddressPropertiesNVX {
40919     pub s_type: StructureType,
40920     pub p_next: *mut c_void,
40921     pub device_address: DeviceAddress,
40922     pub size: DeviceSize,
40923 }
40924 impl ::std::default::Default for ImageViewAddressPropertiesNVX {
40925     #[inline]
default() -> Self40926     fn default() -> Self {
40927         Self {
40928             s_type: Self::STRUCTURE_TYPE,
40929             p_next: ::std::ptr::null_mut(),
40930             device_address: DeviceAddress::default(),
40931             size: DeviceSize::default(),
40932         }
40933     }
40934 }
40935 unsafe impl TaggedStructure for ImageViewAddressPropertiesNVX {
40936     const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_ADDRESS_PROPERTIES_NVX;
40937 }
40938 impl ImageViewAddressPropertiesNVX {
builder<'a>() -> ImageViewAddressPropertiesNVXBuilder<'a>40939     pub fn builder<'a>() -> ImageViewAddressPropertiesNVXBuilder<'a> {
40940         ImageViewAddressPropertiesNVXBuilder {
40941             inner: Self::default(),
40942             marker: ::std::marker::PhantomData,
40943         }
40944     }
40945 }
40946 #[repr(transparent)]
40947 pub struct ImageViewAddressPropertiesNVXBuilder<'a> {
40948     inner: ImageViewAddressPropertiesNVX,
40949     marker: ::std::marker::PhantomData<&'a ()>,
40950 }
40951 impl<'a> ::std::ops::Deref for ImageViewAddressPropertiesNVXBuilder<'a> {
40952     type Target = ImageViewAddressPropertiesNVX;
deref(&self) -> &Self::Target40953     fn deref(&self) -> &Self::Target {
40954         &self.inner
40955     }
40956 }
40957 impl<'a> ::std::ops::DerefMut for ImageViewAddressPropertiesNVXBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target40958     fn deref_mut(&mut self) -> &mut Self::Target {
40959         &mut self.inner
40960     }
40961 }
40962 impl<'a> ImageViewAddressPropertiesNVXBuilder<'a> {
40963     #[inline]
device_address(mut self, device_address: DeviceAddress) -> Self40964     pub fn device_address(mut self, device_address: DeviceAddress) -> Self {
40965         self.inner.device_address = device_address;
40966         self
40967     }
40968     #[inline]
size(mut self, size: DeviceSize) -> Self40969     pub fn size(mut self, size: DeviceSize) -> Self {
40970         self.inner.size = size;
40971         self
40972     }
40973     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40974     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40975     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageViewAddressPropertiesNVX40976     pub fn build(self) -> ImageViewAddressPropertiesNVX {
40977         self.inner
40978     }
40979 }
40980 #[repr(C)]
40981 #[cfg_attr(feature = "debug", derive(Debug))]
40982 #[derive(Copy, Clone)]
40983 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentFrameTokenGGP.html>"]
40984 pub struct PresentFrameTokenGGP {
40985     pub s_type: StructureType,
40986     pub p_next: *const c_void,
40987     pub frame_token: GgpFrameToken,
40988 }
40989 impl ::std::default::Default for PresentFrameTokenGGP {
40990     #[inline]
default() -> Self40991     fn default() -> Self {
40992         Self {
40993             s_type: Self::STRUCTURE_TYPE,
40994             p_next: ::std::ptr::null(),
40995             frame_token: GgpFrameToken::default(),
40996         }
40997     }
40998 }
40999 unsafe impl TaggedStructure for PresentFrameTokenGGP {
41000     const STRUCTURE_TYPE: StructureType = StructureType::PRESENT_FRAME_TOKEN_GGP;
41001 }
41002 impl PresentFrameTokenGGP {
builder<'a>() -> PresentFrameTokenGGPBuilder<'a>41003     pub fn builder<'a>() -> PresentFrameTokenGGPBuilder<'a> {
41004         PresentFrameTokenGGPBuilder {
41005             inner: Self::default(),
41006             marker: ::std::marker::PhantomData,
41007         }
41008     }
41009 }
41010 #[repr(transparent)]
41011 pub struct PresentFrameTokenGGPBuilder<'a> {
41012     inner: PresentFrameTokenGGP,
41013     marker: ::std::marker::PhantomData<&'a ()>,
41014 }
41015 unsafe impl ExtendsPresentInfoKHR for PresentFrameTokenGGPBuilder<'_> {}
41016 unsafe impl ExtendsPresentInfoKHR for PresentFrameTokenGGP {}
41017 impl<'a> ::std::ops::Deref for PresentFrameTokenGGPBuilder<'a> {
41018     type Target = PresentFrameTokenGGP;
deref(&self) -> &Self::Target41019     fn deref(&self) -> &Self::Target {
41020         &self.inner
41021     }
41022 }
41023 impl<'a> ::std::ops::DerefMut for PresentFrameTokenGGPBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target41024     fn deref_mut(&mut self) -> &mut Self::Target {
41025         &mut self.inner
41026     }
41027 }
41028 impl<'a> PresentFrameTokenGGPBuilder<'a> {
41029     #[inline]
frame_token(mut self, frame_token: GgpFrameToken) -> Self41030     pub fn frame_token(mut self, frame_token: GgpFrameToken) -> Self {
41031         self.inner.frame_token = frame_token;
41032         self
41033     }
41034     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
41035     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
41036     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PresentFrameTokenGGP41037     pub fn build(self) -> PresentFrameTokenGGP {
41038         self.inner
41039     }
41040 }
41041 #[repr(C)]
41042 #[cfg_attr(feature = "debug", derive(Debug))]
41043 #[derive(Copy, Clone, Default)]
41044 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCreationFeedback.html>"]
41045 pub struct PipelineCreationFeedback {
41046     pub flags: PipelineCreationFeedbackFlags,
41047     pub duration: u64,
41048 }
41049 impl PipelineCreationFeedback {
builder<'a>() -> PipelineCreationFeedbackBuilder<'a>41050     pub fn builder<'a>() -> PipelineCreationFeedbackBuilder<'a> {
41051         PipelineCreationFeedbackBuilder {
41052             inner: Self::default(),
41053             marker: ::std::marker::PhantomData,
41054         }
41055     }
41056 }
41057 #[repr(transparent)]
41058 pub struct PipelineCreationFeedbackBuilder<'a> {
41059     inner: PipelineCreationFeedback,
41060     marker: ::std::marker::PhantomData<&'a ()>,
41061 }
41062 impl<'a> ::std::ops::Deref for PipelineCreationFeedbackBuilder<'a> {
41063     type Target = PipelineCreationFeedback;
deref(&self) -> &Self::Target41064     fn deref(&self) -> &Self::Target {
41065         &self.inner
41066     }
41067 }
41068 impl<'a> ::std::ops::DerefMut for PipelineCreationFeedbackBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target41069     fn deref_mut(&mut self) -> &mut Self::Target {
41070         &mut self.inner
41071     }
41072 }
41073 impl<'a> PipelineCreationFeedbackBuilder<'a> {
41074     #[inline]
flags(mut self, flags: PipelineCreationFeedbackFlags) -> Self41075     pub fn flags(mut self, flags: PipelineCreationFeedbackFlags) -> Self {
41076         self.inner.flags = flags;
41077         self
41078     }
41079     #[inline]
duration(mut self, duration: u64) -> Self41080     pub fn duration(mut self, duration: u64) -> Self {
41081         self.inner.duration = duration;
41082         self
41083     }
41084     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
41085     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
41086     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineCreationFeedback41087     pub fn build(self) -> PipelineCreationFeedback {
41088         self.inner
41089     }
41090 }
41091 #[repr(C)]
41092 #[cfg_attr(feature = "debug", derive(Debug))]
41093 #[derive(Copy, Clone)]
41094 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCreationFeedbackCreateInfo.html>"]
41095 pub struct PipelineCreationFeedbackCreateInfo {
41096     pub s_type: StructureType,
41097     pub p_next: *const c_void,
41098     pub p_pipeline_creation_feedback: *mut PipelineCreationFeedback,
41099     pub pipeline_stage_creation_feedback_count: u32,
41100     pub p_pipeline_stage_creation_feedbacks: *mut PipelineCreationFeedback,
41101 }
41102 impl ::std::default::Default for PipelineCreationFeedbackCreateInfo {
41103     #[inline]
default() -> Self41104     fn default() -> Self {
41105         Self {
41106             s_type: Self::STRUCTURE_TYPE,
41107             p_next: ::std::ptr::null(),
41108             p_pipeline_creation_feedback: ::std::ptr::null_mut(),
41109             pipeline_stage_creation_feedback_count: u32::default(),
41110             p_pipeline_stage_creation_feedbacks: ::std::ptr::null_mut(),
41111         }
41112     }
41113 }
41114 unsafe impl TaggedStructure for PipelineCreationFeedbackCreateInfo {
41115     const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
41116 }
41117 impl PipelineCreationFeedbackCreateInfo {
builder<'a>() -> PipelineCreationFeedbackCreateInfoBuilder<'a>41118     pub fn builder<'a>() -> PipelineCreationFeedbackCreateInfoBuilder<'a> {
41119         PipelineCreationFeedbackCreateInfoBuilder {
41120             inner: Self::default(),
41121             marker: ::std::marker::PhantomData,
41122         }
41123     }
41124 }
41125 #[repr(transparent)]
41126 pub struct PipelineCreationFeedbackCreateInfoBuilder<'a> {
41127     inner: PipelineCreationFeedbackCreateInfo,
41128     marker: ::std::marker::PhantomData<&'a ()>,
41129 }
41130 unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCreationFeedbackCreateInfoBuilder<'_> {}
41131 unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCreationFeedbackCreateInfo {}
41132 unsafe impl ExtendsComputePipelineCreateInfo for PipelineCreationFeedbackCreateInfoBuilder<'_> {}
41133 unsafe impl ExtendsComputePipelineCreateInfo for PipelineCreationFeedbackCreateInfo {}
41134 unsafe impl ExtendsRayTracingPipelineCreateInfoNV
41135     for PipelineCreationFeedbackCreateInfoBuilder<'_>
41136 {
41137 }
41138 unsafe impl ExtendsRayTracingPipelineCreateInfoNV for PipelineCreationFeedbackCreateInfo {}
41139 unsafe impl ExtendsRayTracingPipelineCreateInfoKHR
41140     for PipelineCreationFeedbackCreateInfoBuilder<'_>
41141 {
41142 }
41143 unsafe impl ExtendsRayTracingPipelineCreateInfoKHR for PipelineCreationFeedbackCreateInfo {}
41144 impl<'a> ::std::ops::Deref for PipelineCreationFeedbackCreateInfoBuilder<'a> {
41145     type Target = PipelineCreationFeedbackCreateInfo;
deref(&self) -> &Self::Target41146     fn deref(&self) -> &Self::Target {
41147         &self.inner
41148     }
41149 }
41150 impl<'a> ::std::ops::DerefMut for PipelineCreationFeedbackCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target41151     fn deref_mut(&mut self) -> &mut Self::Target {
41152         &mut self.inner
41153     }
41154 }
41155 impl<'a> PipelineCreationFeedbackCreateInfoBuilder<'a> {
41156     #[inline]
pipeline_creation_feedback( mut self, pipeline_creation_feedback: &'a mut PipelineCreationFeedback, ) -> Self41157     pub fn pipeline_creation_feedback(
41158         mut self,
41159         pipeline_creation_feedback: &'a mut PipelineCreationFeedback,
41160     ) -> Self {
41161         self.inner.p_pipeline_creation_feedback = pipeline_creation_feedback;
41162         self
41163     }
41164     #[inline]
pipeline_stage_creation_feedbacks( mut self, pipeline_stage_creation_feedbacks: &'a mut [PipelineCreationFeedback], ) -> Self41165     pub fn pipeline_stage_creation_feedbacks(
41166         mut self,
41167         pipeline_stage_creation_feedbacks: &'a mut [PipelineCreationFeedback],
41168     ) -> Self {
41169         self.inner.pipeline_stage_creation_feedback_count =
41170             pipeline_stage_creation_feedbacks.len() as _;
41171         self.inner.p_pipeline_stage_creation_feedbacks =
41172             pipeline_stage_creation_feedbacks.as_mut_ptr();
41173         self
41174     }
41175     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
41176     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
41177     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineCreationFeedbackCreateInfo41178     pub fn build(self) -> PipelineCreationFeedbackCreateInfo {
41179         self.inner
41180     }
41181 }
41182 #[repr(C)]
41183 #[cfg_attr(feature = "debug", derive(Debug))]
41184 #[derive(Copy, Clone)]
41185 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceFullScreenExclusiveInfoEXT.html>"]
41186 pub struct SurfaceFullScreenExclusiveInfoEXT {
41187     pub s_type: StructureType,
41188     pub p_next: *mut c_void,
41189     pub full_screen_exclusive: FullScreenExclusiveEXT,
41190 }
41191 impl ::std::default::Default for SurfaceFullScreenExclusiveInfoEXT {
41192     #[inline]
default() -> Self41193     fn default() -> Self {
41194         Self {
41195             s_type: Self::STRUCTURE_TYPE,
41196             p_next: ::std::ptr::null_mut(),
41197             full_screen_exclusive: FullScreenExclusiveEXT::default(),
41198         }
41199     }
41200 }
41201 unsafe impl TaggedStructure for SurfaceFullScreenExclusiveInfoEXT {
41202     const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT;
41203 }
41204 impl SurfaceFullScreenExclusiveInfoEXT {
builder<'a>() -> SurfaceFullScreenExclusiveInfoEXTBuilder<'a>41205     pub fn builder<'a>() -> SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
41206         SurfaceFullScreenExclusiveInfoEXTBuilder {
41207             inner: Self::default(),
41208             marker: ::std::marker::PhantomData,
41209         }
41210     }
41211 }
41212 #[repr(transparent)]
41213 pub struct SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
41214     inner: SurfaceFullScreenExclusiveInfoEXT,
41215     marker: ::std::marker::PhantomData<&'a ()>,
41216 }
41217 unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfaceFullScreenExclusiveInfoEXTBuilder<'_> {}
41218 unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfaceFullScreenExclusiveInfoEXT {}
41219 unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveInfoEXTBuilder<'_> {}
41220 unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveInfoEXT {}
41221 impl<'a> ::std::ops::Deref for SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
41222     type Target = SurfaceFullScreenExclusiveInfoEXT;
deref(&self) -> &Self::Target41223     fn deref(&self) -> &Self::Target {
41224         &self.inner
41225     }
41226 }
41227 impl<'a> ::std::ops::DerefMut for SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target41228     fn deref_mut(&mut self) -> &mut Self::Target {
41229         &mut self.inner
41230     }
41231 }
41232 impl<'a> SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
41233     #[inline]
full_screen_exclusive(mut self, full_screen_exclusive: FullScreenExclusiveEXT) -> Self41234     pub fn full_screen_exclusive(mut self, full_screen_exclusive: FullScreenExclusiveEXT) -> Self {
41235         self.inner.full_screen_exclusive = full_screen_exclusive;
41236         self
41237     }
41238     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
41239     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
41240     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SurfaceFullScreenExclusiveInfoEXT41241     pub fn build(self) -> SurfaceFullScreenExclusiveInfoEXT {
41242         self.inner
41243     }
41244 }
41245 #[repr(C)]
41246 #[cfg_attr(feature = "debug", derive(Debug))]
41247 #[derive(Copy, Clone)]
41248 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceFullScreenExclusiveWin32InfoEXT.html>"]
41249 pub struct SurfaceFullScreenExclusiveWin32InfoEXT {
41250     pub s_type: StructureType,
41251     pub p_next: *const c_void,
41252     pub hmonitor: HMONITOR,
41253 }
41254 impl ::std::default::Default for SurfaceFullScreenExclusiveWin32InfoEXT {
41255     #[inline]
default() -> Self41256     fn default() -> Self {
41257         Self {
41258             s_type: Self::STRUCTURE_TYPE,
41259             p_next: ::std::ptr::null(),
41260             hmonitor: unsafe { ::std::mem::zeroed() },
41261         }
41262     }
41263 }
41264 unsafe impl TaggedStructure for SurfaceFullScreenExclusiveWin32InfoEXT {
41265     const STRUCTURE_TYPE: StructureType =
41266         StructureType::SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT;
41267 }
41268 impl SurfaceFullScreenExclusiveWin32InfoEXT {
builder<'a>() -> SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a>41269     pub fn builder<'a>() -> SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
41270         SurfaceFullScreenExclusiveWin32InfoEXTBuilder {
41271             inner: Self::default(),
41272             marker: ::std::marker::PhantomData,
41273         }
41274     }
41275 }
41276 #[repr(transparent)]
41277 pub struct SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
41278     inner: SurfaceFullScreenExclusiveWin32InfoEXT,
41279     marker: ::std::marker::PhantomData<&'a ()>,
41280 }
41281 unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR
41282     for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'_>
41283 {
41284 }
41285 unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfaceFullScreenExclusiveWin32InfoEXT {}
41286 unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'_> {}
41287 unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveWin32InfoEXT {}
41288 impl<'a> ::std::ops::Deref for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
41289     type Target = SurfaceFullScreenExclusiveWin32InfoEXT;
deref(&self) -> &Self::Target41290     fn deref(&self) -> &Self::Target {
41291         &self.inner
41292     }
41293 }
41294 impl<'a> ::std::ops::DerefMut for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target41295     fn deref_mut(&mut self) -> &mut Self::Target {
41296         &mut self.inner
41297     }
41298 }
41299 impl<'a> SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
41300     #[inline]
hmonitor(mut self, hmonitor: HMONITOR) -> Self41301     pub fn hmonitor(mut self, hmonitor: HMONITOR) -> Self {
41302         self.inner.hmonitor = hmonitor;
41303         self
41304     }
41305     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
41306     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
41307     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SurfaceFullScreenExclusiveWin32InfoEXT41308     pub fn build(self) -> SurfaceFullScreenExclusiveWin32InfoEXT {
41309         self.inner
41310     }
41311 }
41312 #[repr(C)]
41313 #[cfg_attr(feature = "debug", derive(Debug))]
41314 #[derive(Copy, Clone)]
41315 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceCapabilitiesFullScreenExclusiveEXT.html>"]
41316 pub struct SurfaceCapabilitiesFullScreenExclusiveEXT {
41317     pub s_type: StructureType,
41318     pub p_next: *mut c_void,
41319     pub full_screen_exclusive_supported: Bool32,
41320 }
41321 impl ::std::default::Default for SurfaceCapabilitiesFullScreenExclusiveEXT {
41322     #[inline]
default() -> Self41323     fn default() -> Self {
41324         Self {
41325             s_type: Self::STRUCTURE_TYPE,
41326             p_next: ::std::ptr::null_mut(),
41327             full_screen_exclusive_supported: Bool32::default(),
41328         }
41329     }
41330 }
41331 unsafe impl TaggedStructure for SurfaceCapabilitiesFullScreenExclusiveEXT {
41332     const STRUCTURE_TYPE: StructureType =
41333         StructureType::SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT;
41334 }
41335 impl SurfaceCapabilitiesFullScreenExclusiveEXT {
builder<'a>() -> SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a>41336     pub fn builder<'a>() -> SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
41337         SurfaceCapabilitiesFullScreenExclusiveEXTBuilder {
41338             inner: Self::default(),
41339             marker: ::std::marker::PhantomData,
41340         }
41341     }
41342 }
41343 #[repr(transparent)]
41344 pub struct SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
41345     inner: SurfaceCapabilitiesFullScreenExclusiveEXT,
41346     marker: ::std::marker::PhantomData<&'a ()>,
41347 }
41348 unsafe impl ExtendsSurfaceCapabilities2KHR
41349     for SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'_>
41350 {
41351 }
41352 unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceCapabilitiesFullScreenExclusiveEXT {}
41353 impl<'a> ::std::ops::Deref for SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
41354     type Target = SurfaceCapabilitiesFullScreenExclusiveEXT;
deref(&self) -> &Self::Target41355     fn deref(&self) -> &Self::Target {
41356         &self.inner
41357     }
41358 }
41359 impl<'a> ::std::ops::DerefMut for SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target41360     fn deref_mut(&mut self) -> &mut Self::Target {
41361         &mut self.inner
41362     }
41363 }
41364 impl<'a> SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
41365     #[inline]
full_screen_exclusive_supported( mut self, full_screen_exclusive_supported: bool, ) -> Self41366     pub fn full_screen_exclusive_supported(
41367         mut self,
41368         full_screen_exclusive_supported: bool,
41369     ) -> Self {
41370         self.inner.full_screen_exclusive_supported = full_screen_exclusive_supported.into();
41371         self
41372     }
41373     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
41374     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
41375     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SurfaceCapabilitiesFullScreenExclusiveEXT41376     pub fn build(self) -> SurfaceCapabilitiesFullScreenExclusiveEXT {
41377         self.inner
41378     }
41379 }
41380 #[repr(C)]
41381 #[cfg_attr(feature = "debug", derive(Debug))]
41382 #[derive(Copy, Clone)]
41383 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePresentBarrierFeaturesNV.html>"]
41384 pub struct PhysicalDevicePresentBarrierFeaturesNV {
41385     pub s_type: StructureType,
41386     pub p_next: *mut c_void,
41387     pub present_barrier: Bool32,
41388 }
41389 impl ::std::default::Default for PhysicalDevicePresentBarrierFeaturesNV {
41390     #[inline]
default() -> Self41391     fn default() -> Self {
41392         Self {
41393             s_type: Self::STRUCTURE_TYPE,
41394             p_next: ::std::ptr::null_mut(),
41395             present_barrier: Bool32::default(),
41396         }
41397     }
41398 }
41399 unsafe impl TaggedStructure for PhysicalDevicePresentBarrierFeaturesNV {
41400     const STRUCTURE_TYPE: StructureType =
41401         StructureType::PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
41402 }
41403 impl PhysicalDevicePresentBarrierFeaturesNV {
builder<'a>() -> PhysicalDevicePresentBarrierFeaturesNVBuilder<'a>41404     pub fn builder<'a>() -> PhysicalDevicePresentBarrierFeaturesNVBuilder<'a> {
41405         PhysicalDevicePresentBarrierFeaturesNVBuilder {
41406             inner: Self::default(),
41407             marker: ::std::marker::PhantomData,
41408         }
41409     }
41410 }
41411 #[repr(transparent)]
41412 pub struct PhysicalDevicePresentBarrierFeaturesNVBuilder<'a> {
41413     inner: PhysicalDevicePresentBarrierFeaturesNV,
41414     marker: ::std::marker::PhantomData<&'a ()>,
41415 }
41416 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentBarrierFeaturesNVBuilder<'_> {}
41417 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentBarrierFeaturesNV {}
41418 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentBarrierFeaturesNVBuilder<'_> {}
41419 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentBarrierFeaturesNV {}
41420 impl<'a> ::std::ops::Deref for PhysicalDevicePresentBarrierFeaturesNVBuilder<'a> {
41421     type Target = PhysicalDevicePresentBarrierFeaturesNV;
deref(&self) -> &Self::Target41422     fn deref(&self) -> &Self::Target {
41423         &self.inner
41424     }
41425 }
41426 impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentBarrierFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target41427     fn deref_mut(&mut self) -> &mut Self::Target {
41428         &mut self.inner
41429     }
41430 }
41431 impl<'a> PhysicalDevicePresentBarrierFeaturesNVBuilder<'a> {
41432     #[inline]
present_barrier(mut self, present_barrier: bool) -> Self41433     pub fn present_barrier(mut self, present_barrier: bool) -> Self {
41434         self.inner.present_barrier = present_barrier.into();
41435         self
41436     }
41437     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
41438     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
41439     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePresentBarrierFeaturesNV41440     pub fn build(self) -> PhysicalDevicePresentBarrierFeaturesNV {
41441         self.inner
41442     }
41443 }
41444 #[repr(C)]
41445 #[cfg_attr(feature = "debug", derive(Debug))]
41446 #[derive(Copy, Clone)]
41447 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceCapabilitiesPresentBarrierNV.html>"]
41448 pub struct SurfaceCapabilitiesPresentBarrierNV {
41449     pub s_type: StructureType,
41450     pub p_next: *mut c_void,
41451     pub present_barrier_supported: Bool32,
41452 }
41453 impl ::std::default::Default for SurfaceCapabilitiesPresentBarrierNV {
41454     #[inline]
default() -> Self41455     fn default() -> Self {
41456         Self {
41457             s_type: Self::STRUCTURE_TYPE,
41458             p_next: ::std::ptr::null_mut(),
41459             present_barrier_supported: Bool32::default(),
41460         }
41461     }
41462 }
41463 unsafe impl TaggedStructure for SurfaceCapabilitiesPresentBarrierNV {
41464     const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_CAPABILITIES_PRESENT_BARRIER_NV;
41465 }
41466 impl SurfaceCapabilitiesPresentBarrierNV {
builder<'a>() -> SurfaceCapabilitiesPresentBarrierNVBuilder<'a>41467     pub fn builder<'a>() -> SurfaceCapabilitiesPresentBarrierNVBuilder<'a> {
41468         SurfaceCapabilitiesPresentBarrierNVBuilder {
41469             inner: Self::default(),
41470             marker: ::std::marker::PhantomData,
41471         }
41472     }
41473 }
41474 #[repr(transparent)]
41475 pub struct SurfaceCapabilitiesPresentBarrierNVBuilder<'a> {
41476     inner: SurfaceCapabilitiesPresentBarrierNV,
41477     marker: ::std::marker::PhantomData<&'a ()>,
41478 }
41479 unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceCapabilitiesPresentBarrierNVBuilder<'_> {}
41480 unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceCapabilitiesPresentBarrierNV {}
41481 impl<'a> ::std::ops::Deref for SurfaceCapabilitiesPresentBarrierNVBuilder<'a> {
41482     type Target = SurfaceCapabilitiesPresentBarrierNV;
deref(&self) -> &Self::Target41483     fn deref(&self) -> &Self::Target {
41484         &self.inner
41485     }
41486 }
41487 impl<'a> ::std::ops::DerefMut for SurfaceCapabilitiesPresentBarrierNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target41488     fn deref_mut(&mut self) -> &mut Self::Target {
41489         &mut self.inner
41490     }
41491 }
41492 impl<'a> SurfaceCapabilitiesPresentBarrierNVBuilder<'a> {
41493     #[inline]
present_barrier_supported(mut self, present_barrier_supported: bool) -> Self41494     pub fn present_barrier_supported(mut self, present_barrier_supported: bool) -> Self {
41495         self.inner.present_barrier_supported = present_barrier_supported.into();
41496         self
41497     }
41498     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
41499     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
41500     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SurfaceCapabilitiesPresentBarrierNV41501     pub fn build(self) -> SurfaceCapabilitiesPresentBarrierNV {
41502         self.inner
41503     }
41504 }
41505 #[repr(C)]
41506 #[cfg_attr(feature = "debug", derive(Debug))]
41507 #[derive(Copy, Clone)]
41508 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainPresentBarrierCreateInfoNV.html>"]
41509 pub struct SwapchainPresentBarrierCreateInfoNV {
41510     pub s_type: StructureType,
41511     pub p_next: *mut c_void,
41512     pub present_barrier_enable: Bool32,
41513 }
41514 impl ::std::default::Default for SwapchainPresentBarrierCreateInfoNV {
41515     #[inline]
default() -> Self41516     fn default() -> Self {
41517         Self {
41518             s_type: Self::STRUCTURE_TYPE,
41519             p_next: ::std::ptr::null_mut(),
41520             present_barrier_enable: Bool32::default(),
41521         }
41522     }
41523 }
41524 unsafe impl TaggedStructure for SwapchainPresentBarrierCreateInfoNV {
41525     const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV;
41526 }
41527 impl SwapchainPresentBarrierCreateInfoNV {
builder<'a>() -> SwapchainPresentBarrierCreateInfoNVBuilder<'a>41528     pub fn builder<'a>() -> SwapchainPresentBarrierCreateInfoNVBuilder<'a> {
41529         SwapchainPresentBarrierCreateInfoNVBuilder {
41530             inner: Self::default(),
41531             marker: ::std::marker::PhantomData,
41532         }
41533     }
41534 }
41535 #[repr(transparent)]
41536 pub struct SwapchainPresentBarrierCreateInfoNVBuilder<'a> {
41537     inner: SwapchainPresentBarrierCreateInfoNV,
41538     marker: ::std::marker::PhantomData<&'a ()>,
41539 }
41540 unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentBarrierCreateInfoNVBuilder<'_> {}
41541 unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentBarrierCreateInfoNV {}
41542 impl<'a> ::std::ops::Deref for SwapchainPresentBarrierCreateInfoNVBuilder<'a> {
41543     type Target = SwapchainPresentBarrierCreateInfoNV;
deref(&self) -> &Self::Target41544     fn deref(&self) -> &Self::Target {
41545         &self.inner
41546     }
41547 }
41548 impl<'a> ::std::ops::DerefMut for SwapchainPresentBarrierCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target41549     fn deref_mut(&mut self) -> &mut Self::Target {
41550         &mut self.inner
41551     }
41552 }
41553 impl<'a> SwapchainPresentBarrierCreateInfoNVBuilder<'a> {
41554     #[inline]
present_barrier_enable(mut self, present_barrier_enable: bool) -> Self41555     pub fn present_barrier_enable(mut self, present_barrier_enable: bool) -> Self {
41556         self.inner.present_barrier_enable = present_barrier_enable.into();
41557         self
41558     }
41559     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
41560     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
41561     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SwapchainPresentBarrierCreateInfoNV41562     pub fn build(self) -> SwapchainPresentBarrierCreateInfoNV {
41563         self.inner
41564     }
41565 }
41566 #[repr(C)]
41567 #[cfg_attr(feature = "debug", derive(Debug))]
41568 #[derive(Copy, Clone)]
41569 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePerformanceQueryFeaturesKHR.html>"]
41570 pub struct PhysicalDevicePerformanceQueryFeaturesKHR {
41571     pub s_type: StructureType,
41572     pub p_next: *mut c_void,
41573     pub performance_counter_query_pools: Bool32,
41574     pub performance_counter_multiple_query_pools: Bool32,
41575 }
41576 impl ::std::default::Default for PhysicalDevicePerformanceQueryFeaturesKHR {
41577     #[inline]
default() -> Self41578     fn default() -> Self {
41579         Self {
41580             s_type: Self::STRUCTURE_TYPE,
41581             p_next: ::std::ptr::null_mut(),
41582             performance_counter_query_pools: Bool32::default(),
41583             performance_counter_multiple_query_pools: Bool32::default(),
41584         }
41585     }
41586 }
41587 unsafe impl TaggedStructure for PhysicalDevicePerformanceQueryFeaturesKHR {
41588     const STRUCTURE_TYPE: StructureType =
41589         StructureType::PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
41590 }
41591 impl PhysicalDevicePerformanceQueryFeaturesKHR {
builder<'a>() -> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a>41592     pub fn builder<'a>() -> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
41593         PhysicalDevicePerformanceQueryFeaturesKHRBuilder {
41594             inner: Self::default(),
41595             marker: ::std::marker::PhantomData,
41596         }
41597     }
41598 }
41599 #[repr(transparent)]
41600 pub struct PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
41601     inner: PhysicalDevicePerformanceQueryFeaturesKHR,
41602     marker: ::std::marker::PhantomData<&'a ()>,
41603 }
41604 unsafe impl ExtendsPhysicalDeviceFeatures2
41605     for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'_>
41606 {
41607 }
41608 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePerformanceQueryFeaturesKHR {}
41609 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'_> {}
41610 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePerformanceQueryFeaturesKHR {}
41611 impl<'a> ::std::ops::Deref for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
41612     type Target = PhysicalDevicePerformanceQueryFeaturesKHR;
deref(&self) -> &Self::Target41613     fn deref(&self) -> &Self::Target {
41614         &self.inner
41615     }
41616 }
41617 impl<'a> ::std::ops::DerefMut for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target41618     fn deref_mut(&mut self) -> &mut Self::Target {
41619         &mut self.inner
41620     }
41621 }
41622 impl<'a> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
41623     #[inline]
performance_counter_query_pools( mut self, performance_counter_query_pools: bool, ) -> Self41624     pub fn performance_counter_query_pools(
41625         mut self,
41626         performance_counter_query_pools: bool,
41627     ) -> Self {
41628         self.inner.performance_counter_query_pools = performance_counter_query_pools.into();
41629         self
41630     }
41631     #[inline]
performance_counter_multiple_query_pools( mut self, performance_counter_multiple_query_pools: bool, ) -> Self41632     pub fn performance_counter_multiple_query_pools(
41633         mut self,
41634         performance_counter_multiple_query_pools: bool,
41635     ) -> Self {
41636         self.inner.performance_counter_multiple_query_pools =
41637             performance_counter_multiple_query_pools.into();
41638         self
41639     }
41640     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
41641     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
41642     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePerformanceQueryFeaturesKHR41643     pub fn build(self) -> PhysicalDevicePerformanceQueryFeaturesKHR {
41644         self.inner
41645     }
41646 }
41647 #[repr(C)]
41648 #[cfg_attr(feature = "debug", derive(Debug))]
41649 #[derive(Copy, Clone)]
41650 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePerformanceQueryPropertiesKHR.html>"]
41651 pub struct PhysicalDevicePerformanceQueryPropertiesKHR {
41652     pub s_type: StructureType,
41653     pub p_next: *mut c_void,
41654     pub allow_command_buffer_query_copies: Bool32,
41655 }
41656 impl ::std::default::Default for PhysicalDevicePerformanceQueryPropertiesKHR {
41657     #[inline]
default() -> Self41658     fn default() -> Self {
41659         Self {
41660             s_type: Self::STRUCTURE_TYPE,
41661             p_next: ::std::ptr::null_mut(),
41662             allow_command_buffer_query_copies: Bool32::default(),
41663         }
41664     }
41665 }
41666 unsafe impl TaggedStructure for PhysicalDevicePerformanceQueryPropertiesKHR {
41667     const STRUCTURE_TYPE: StructureType =
41668         StructureType::PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR;
41669 }
41670 impl PhysicalDevicePerformanceQueryPropertiesKHR {
builder<'a>() -> PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a>41671     pub fn builder<'a>() -> PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
41672         PhysicalDevicePerformanceQueryPropertiesKHRBuilder {
41673             inner: Self::default(),
41674             marker: ::std::marker::PhantomData,
41675         }
41676     }
41677 }
41678 #[repr(transparent)]
41679 pub struct PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
41680     inner: PhysicalDevicePerformanceQueryPropertiesKHR,
41681     marker: ::std::marker::PhantomData<&'a ()>,
41682 }
41683 unsafe impl ExtendsPhysicalDeviceProperties2
41684     for PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'_>
41685 {
41686 }
41687 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePerformanceQueryPropertiesKHR {}
41688 impl<'a> ::std::ops::Deref for PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
41689     type Target = PhysicalDevicePerformanceQueryPropertiesKHR;
deref(&self) -> &Self::Target41690     fn deref(&self) -> &Self::Target {
41691         &self.inner
41692     }
41693 }
41694 impl<'a> ::std::ops::DerefMut for PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target41695     fn deref_mut(&mut self) -> &mut Self::Target {
41696         &mut self.inner
41697     }
41698 }
41699 impl<'a> PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
41700     #[inline]
allow_command_buffer_query_copies( mut self, allow_command_buffer_query_copies: bool, ) -> Self41701     pub fn allow_command_buffer_query_copies(
41702         mut self,
41703         allow_command_buffer_query_copies: bool,
41704     ) -> Self {
41705         self.inner.allow_command_buffer_query_copies = allow_command_buffer_query_copies.into();
41706         self
41707     }
41708     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
41709     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
41710     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePerformanceQueryPropertiesKHR41711     pub fn build(self) -> PhysicalDevicePerformanceQueryPropertiesKHR {
41712         self.inner
41713     }
41714 }
41715 #[repr(C)]
41716 #[cfg_attr(feature = "debug", derive(Debug))]
41717 #[derive(Copy, Clone)]
41718 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceCounterKHR.html>"]
41719 pub struct PerformanceCounterKHR {
41720     pub s_type: StructureType,
41721     pub p_next: *mut c_void,
41722     pub unit: PerformanceCounterUnitKHR,
41723     pub scope: PerformanceCounterScopeKHR,
41724     pub storage: PerformanceCounterStorageKHR,
41725     pub uuid: [u8; UUID_SIZE],
41726 }
41727 impl ::std::default::Default for PerformanceCounterKHR {
41728     #[inline]
default() -> Self41729     fn default() -> Self {
41730         Self {
41731             s_type: Self::STRUCTURE_TYPE,
41732             p_next: ::std::ptr::null_mut(),
41733             unit: PerformanceCounterUnitKHR::default(),
41734             scope: PerformanceCounterScopeKHR::default(),
41735             storage: PerformanceCounterStorageKHR::default(),
41736             uuid: unsafe { ::std::mem::zeroed() },
41737         }
41738     }
41739 }
41740 unsafe impl TaggedStructure for PerformanceCounterKHR {
41741     const STRUCTURE_TYPE: StructureType = StructureType::PERFORMANCE_COUNTER_KHR;
41742 }
41743 impl PerformanceCounterKHR {
builder<'a>() -> PerformanceCounterKHRBuilder<'a>41744     pub fn builder<'a>() -> PerformanceCounterKHRBuilder<'a> {
41745         PerformanceCounterKHRBuilder {
41746             inner: Self::default(),
41747             marker: ::std::marker::PhantomData,
41748         }
41749     }
41750 }
41751 #[repr(transparent)]
41752 pub struct PerformanceCounterKHRBuilder<'a> {
41753     inner: PerformanceCounterKHR,
41754     marker: ::std::marker::PhantomData<&'a ()>,
41755 }
41756 impl<'a> ::std::ops::Deref for PerformanceCounterKHRBuilder<'a> {
41757     type Target = PerformanceCounterKHR;
deref(&self) -> &Self::Target41758     fn deref(&self) -> &Self::Target {
41759         &self.inner
41760     }
41761 }
41762 impl<'a> ::std::ops::DerefMut for PerformanceCounterKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target41763     fn deref_mut(&mut self) -> &mut Self::Target {
41764         &mut self.inner
41765     }
41766 }
41767 impl<'a> PerformanceCounterKHRBuilder<'a> {
41768     #[inline]
unit(mut self, unit: PerformanceCounterUnitKHR) -> Self41769     pub fn unit(mut self, unit: PerformanceCounterUnitKHR) -> Self {
41770         self.inner.unit = unit;
41771         self
41772     }
41773     #[inline]
scope(mut self, scope: PerformanceCounterScopeKHR) -> Self41774     pub fn scope(mut self, scope: PerformanceCounterScopeKHR) -> Self {
41775         self.inner.scope = scope;
41776         self
41777     }
41778     #[inline]
storage(mut self, storage: PerformanceCounterStorageKHR) -> Self41779     pub fn storage(mut self, storage: PerformanceCounterStorageKHR) -> Self {
41780         self.inner.storage = storage;
41781         self
41782     }
41783     #[inline]
uuid(mut self, uuid: [u8; UUID_SIZE]) -> Self41784     pub fn uuid(mut self, uuid: [u8; UUID_SIZE]) -> Self {
41785         self.inner.uuid = uuid;
41786         self
41787     }
41788     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
41789     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
41790     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PerformanceCounterKHR41791     pub fn build(self) -> PerformanceCounterKHR {
41792         self.inner
41793     }
41794 }
41795 #[repr(C)]
41796 #[derive(Copy, Clone)]
41797 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceCounterDescriptionKHR.html>"]
41798 pub struct PerformanceCounterDescriptionKHR {
41799     pub s_type: StructureType,
41800     pub p_next: *mut c_void,
41801     pub flags: PerformanceCounterDescriptionFlagsKHR,
41802     pub name: [c_char; MAX_DESCRIPTION_SIZE],
41803     pub category: [c_char; MAX_DESCRIPTION_SIZE],
41804     pub description: [c_char; MAX_DESCRIPTION_SIZE],
41805 }
41806 #[cfg(feature = "debug")]
41807 impl fmt::Debug for PerformanceCounterDescriptionKHR {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result41808     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
41809         fmt.debug_struct("PerformanceCounterDescriptionKHR")
41810             .field("s_type", &self.s_type)
41811             .field("p_next", &self.p_next)
41812             .field("flags", &self.flags)
41813             .field("name", &unsafe {
41814                 ::std::ffi::CStr::from_ptr(self.name.as_ptr())
41815             })
41816             .field("category", &unsafe {
41817                 ::std::ffi::CStr::from_ptr(self.category.as_ptr())
41818             })
41819             .field("description", &unsafe {
41820                 ::std::ffi::CStr::from_ptr(self.description.as_ptr())
41821             })
41822             .finish()
41823     }
41824 }
41825 impl ::std::default::Default for PerformanceCounterDescriptionKHR {
41826     #[inline]
default() -> Self41827     fn default() -> Self {
41828         Self {
41829             s_type: Self::STRUCTURE_TYPE,
41830             p_next: ::std::ptr::null_mut(),
41831             flags: PerformanceCounterDescriptionFlagsKHR::default(),
41832             name: unsafe { ::std::mem::zeroed() },
41833             category: unsafe { ::std::mem::zeroed() },
41834             description: unsafe { ::std::mem::zeroed() },
41835         }
41836     }
41837 }
41838 unsafe impl TaggedStructure for PerformanceCounterDescriptionKHR {
41839     const STRUCTURE_TYPE: StructureType = StructureType::PERFORMANCE_COUNTER_DESCRIPTION_KHR;
41840 }
41841 impl PerformanceCounterDescriptionKHR {
builder<'a>() -> PerformanceCounterDescriptionKHRBuilder<'a>41842     pub fn builder<'a>() -> PerformanceCounterDescriptionKHRBuilder<'a> {
41843         PerformanceCounterDescriptionKHRBuilder {
41844             inner: Self::default(),
41845             marker: ::std::marker::PhantomData,
41846         }
41847     }
41848 }
41849 #[repr(transparent)]
41850 pub struct PerformanceCounterDescriptionKHRBuilder<'a> {
41851     inner: PerformanceCounterDescriptionKHR,
41852     marker: ::std::marker::PhantomData<&'a ()>,
41853 }
41854 impl<'a> ::std::ops::Deref for PerformanceCounterDescriptionKHRBuilder<'a> {
41855     type Target = PerformanceCounterDescriptionKHR;
deref(&self) -> &Self::Target41856     fn deref(&self) -> &Self::Target {
41857         &self.inner
41858     }
41859 }
41860 impl<'a> ::std::ops::DerefMut for PerformanceCounterDescriptionKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target41861     fn deref_mut(&mut self) -> &mut Self::Target {
41862         &mut self.inner
41863     }
41864 }
41865 impl<'a> PerformanceCounterDescriptionKHRBuilder<'a> {
41866     #[inline]
flags(mut self, flags: PerformanceCounterDescriptionFlagsKHR) -> Self41867     pub fn flags(mut self, flags: PerformanceCounterDescriptionFlagsKHR) -> Self {
41868         self.inner.flags = flags;
41869         self
41870     }
41871     #[inline]
name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self41872     pub fn name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
41873         self.inner.name = name;
41874         self
41875     }
41876     #[inline]
category(mut self, category: [c_char; MAX_DESCRIPTION_SIZE]) -> Self41877     pub fn category(mut self, category: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
41878         self.inner.category = category;
41879         self
41880     }
41881     #[inline]
description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self41882     pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
41883         self.inner.description = description;
41884         self
41885     }
41886     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
41887     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
41888     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PerformanceCounterDescriptionKHR41889     pub fn build(self) -> PerformanceCounterDescriptionKHR {
41890         self.inner
41891     }
41892 }
41893 #[repr(C)]
41894 #[cfg_attr(feature = "debug", derive(Debug))]
41895 #[derive(Copy, Clone)]
41896 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPoolPerformanceCreateInfoKHR.html>"]
41897 pub struct QueryPoolPerformanceCreateInfoKHR {
41898     pub s_type: StructureType,
41899     pub p_next: *const c_void,
41900     pub queue_family_index: u32,
41901     pub counter_index_count: u32,
41902     pub p_counter_indices: *const u32,
41903 }
41904 impl ::std::default::Default for QueryPoolPerformanceCreateInfoKHR {
41905     #[inline]
default() -> Self41906     fn default() -> Self {
41907         Self {
41908             s_type: Self::STRUCTURE_TYPE,
41909             p_next: ::std::ptr::null(),
41910             queue_family_index: u32::default(),
41911             counter_index_count: u32::default(),
41912             p_counter_indices: ::std::ptr::null(),
41913         }
41914     }
41915 }
41916 unsafe impl TaggedStructure for QueryPoolPerformanceCreateInfoKHR {
41917     const STRUCTURE_TYPE: StructureType = StructureType::QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR;
41918 }
41919 impl QueryPoolPerformanceCreateInfoKHR {
builder<'a>() -> QueryPoolPerformanceCreateInfoKHRBuilder<'a>41920     pub fn builder<'a>() -> QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
41921         QueryPoolPerformanceCreateInfoKHRBuilder {
41922             inner: Self::default(),
41923             marker: ::std::marker::PhantomData,
41924         }
41925     }
41926 }
41927 #[repr(transparent)]
41928 pub struct QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
41929     inner: QueryPoolPerformanceCreateInfoKHR,
41930     marker: ::std::marker::PhantomData<&'a ()>,
41931 }
41932 unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceCreateInfoKHRBuilder<'_> {}
41933 unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceCreateInfoKHR {}
41934 impl<'a> ::std::ops::Deref for QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
41935     type Target = QueryPoolPerformanceCreateInfoKHR;
deref(&self) -> &Self::Target41936     fn deref(&self) -> &Self::Target {
41937         &self.inner
41938     }
41939 }
41940 impl<'a> ::std::ops::DerefMut for QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target41941     fn deref_mut(&mut self) -> &mut Self::Target {
41942         &mut self.inner
41943     }
41944 }
41945 impl<'a> QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
41946     #[inline]
queue_family_index(mut self, queue_family_index: u32) -> Self41947     pub fn queue_family_index(mut self, queue_family_index: u32) -> Self {
41948         self.inner.queue_family_index = queue_family_index;
41949         self
41950     }
41951     #[inline]
counter_indices(mut self, counter_indices: &'a [u32]) -> Self41952     pub fn counter_indices(mut self, counter_indices: &'a [u32]) -> Self {
41953         self.inner.counter_index_count = counter_indices.len() as _;
41954         self.inner.p_counter_indices = counter_indices.as_ptr();
41955         self
41956     }
41957     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
41958     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
41959     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> QueryPoolPerformanceCreateInfoKHR41960     pub fn build(self) -> QueryPoolPerformanceCreateInfoKHR {
41961         self.inner
41962     }
41963 }
41964 #[repr(C)]
41965 #[derive(Copy, Clone)]
41966 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceCounterResultKHR.html>"]
41967 pub union PerformanceCounterResultKHR {
41968     pub int32: i32,
41969     pub int64: i64,
41970     pub uint32: u32,
41971     pub uint64: u64,
41972     pub float32: f32,
41973     pub float64: f64,
41974 }
41975 impl ::std::default::Default for PerformanceCounterResultKHR {
41976     #[inline]
default() -> Self41977     fn default() -> Self {
41978         unsafe { ::std::mem::zeroed() }
41979     }
41980 }
41981 #[repr(C)]
41982 #[cfg_attr(feature = "debug", derive(Debug))]
41983 #[derive(Copy, Clone)]
41984 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAcquireProfilingLockInfoKHR.html>"]
41985 pub struct AcquireProfilingLockInfoKHR {
41986     pub s_type: StructureType,
41987     pub p_next: *const c_void,
41988     pub flags: AcquireProfilingLockFlagsKHR,
41989     pub timeout: u64,
41990 }
41991 impl ::std::default::Default for AcquireProfilingLockInfoKHR {
41992     #[inline]
default() -> Self41993     fn default() -> Self {
41994         Self {
41995             s_type: Self::STRUCTURE_TYPE,
41996             p_next: ::std::ptr::null(),
41997             flags: AcquireProfilingLockFlagsKHR::default(),
41998             timeout: u64::default(),
41999         }
42000     }
42001 }
42002 unsafe impl TaggedStructure for AcquireProfilingLockInfoKHR {
42003     const STRUCTURE_TYPE: StructureType = StructureType::ACQUIRE_PROFILING_LOCK_INFO_KHR;
42004 }
42005 impl AcquireProfilingLockInfoKHR {
builder<'a>() -> AcquireProfilingLockInfoKHRBuilder<'a>42006     pub fn builder<'a>() -> AcquireProfilingLockInfoKHRBuilder<'a> {
42007         AcquireProfilingLockInfoKHRBuilder {
42008             inner: Self::default(),
42009             marker: ::std::marker::PhantomData,
42010         }
42011     }
42012 }
42013 #[repr(transparent)]
42014 pub struct AcquireProfilingLockInfoKHRBuilder<'a> {
42015     inner: AcquireProfilingLockInfoKHR,
42016     marker: ::std::marker::PhantomData<&'a ()>,
42017 }
42018 impl<'a> ::std::ops::Deref for AcquireProfilingLockInfoKHRBuilder<'a> {
42019     type Target = AcquireProfilingLockInfoKHR;
deref(&self) -> &Self::Target42020     fn deref(&self) -> &Self::Target {
42021         &self.inner
42022     }
42023 }
42024 impl<'a> ::std::ops::DerefMut for AcquireProfilingLockInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target42025     fn deref_mut(&mut self) -> &mut Self::Target {
42026         &mut self.inner
42027     }
42028 }
42029 impl<'a> AcquireProfilingLockInfoKHRBuilder<'a> {
42030     #[inline]
flags(mut self, flags: AcquireProfilingLockFlagsKHR) -> Self42031     pub fn flags(mut self, flags: AcquireProfilingLockFlagsKHR) -> Self {
42032         self.inner.flags = flags;
42033         self
42034     }
42035     #[inline]
timeout(mut self, timeout: u64) -> Self42036     pub fn timeout(mut self, timeout: u64) -> Self {
42037         self.inner.timeout = timeout;
42038         self
42039     }
42040     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42041     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42042     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AcquireProfilingLockInfoKHR42043     pub fn build(self) -> AcquireProfilingLockInfoKHR {
42044         self.inner
42045     }
42046 }
42047 #[repr(C)]
42048 #[cfg_attr(feature = "debug", derive(Debug))]
42049 #[derive(Copy, Clone)]
42050 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceQuerySubmitInfoKHR.html>"]
42051 pub struct PerformanceQuerySubmitInfoKHR {
42052     pub s_type: StructureType,
42053     pub p_next: *const c_void,
42054     pub counter_pass_index: u32,
42055 }
42056 impl ::std::default::Default for PerformanceQuerySubmitInfoKHR {
42057     #[inline]
default() -> Self42058     fn default() -> Self {
42059         Self {
42060             s_type: Self::STRUCTURE_TYPE,
42061             p_next: ::std::ptr::null(),
42062             counter_pass_index: u32::default(),
42063         }
42064     }
42065 }
42066 unsafe impl TaggedStructure for PerformanceQuerySubmitInfoKHR {
42067     const STRUCTURE_TYPE: StructureType = StructureType::PERFORMANCE_QUERY_SUBMIT_INFO_KHR;
42068 }
42069 impl PerformanceQuerySubmitInfoKHR {
builder<'a>() -> PerformanceQuerySubmitInfoKHRBuilder<'a>42070     pub fn builder<'a>() -> PerformanceQuerySubmitInfoKHRBuilder<'a> {
42071         PerformanceQuerySubmitInfoKHRBuilder {
42072             inner: Self::default(),
42073             marker: ::std::marker::PhantomData,
42074         }
42075     }
42076 }
42077 #[repr(transparent)]
42078 pub struct PerformanceQuerySubmitInfoKHRBuilder<'a> {
42079     inner: PerformanceQuerySubmitInfoKHR,
42080     marker: ::std::marker::PhantomData<&'a ()>,
42081 }
42082 unsafe impl ExtendsSubmitInfo for PerformanceQuerySubmitInfoKHRBuilder<'_> {}
42083 unsafe impl ExtendsSubmitInfo for PerformanceQuerySubmitInfoKHR {}
42084 unsafe impl ExtendsSubmitInfo2 for PerformanceQuerySubmitInfoKHRBuilder<'_> {}
42085 unsafe impl ExtendsSubmitInfo2 for PerformanceQuerySubmitInfoKHR {}
42086 impl<'a> ::std::ops::Deref for PerformanceQuerySubmitInfoKHRBuilder<'a> {
42087     type Target = PerformanceQuerySubmitInfoKHR;
deref(&self) -> &Self::Target42088     fn deref(&self) -> &Self::Target {
42089         &self.inner
42090     }
42091 }
42092 impl<'a> ::std::ops::DerefMut for PerformanceQuerySubmitInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target42093     fn deref_mut(&mut self) -> &mut Self::Target {
42094         &mut self.inner
42095     }
42096 }
42097 impl<'a> PerformanceQuerySubmitInfoKHRBuilder<'a> {
42098     #[inline]
counter_pass_index(mut self, counter_pass_index: u32) -> Self42099     pub fn counter_pass_index(mut self, counter_pass_index: u32) -> Self {
42100         self.inner.counter_pass_index = counter_pass_index;
42101         self
42102     }
42103     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42104     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42105     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PerformanceQuerySubmitInfoKHR42106     pub fn build(self) -> PerformanceQuerySubmitInfoKHR {
42107         self.inner
42108     }
42109 }
42110 #[repr(C)]
42111 #[cfg_attr(feature = "debug", derive(Debug))]
42112 #[derive(Copy, Clone)]
42113 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkHeadlessSurfaceCreateInfoEXT.html>"]
42114 pub struct HeadlessSurfaceCreateInfoEXT {
42115     pub s_type: StructureType,
42116     pub p_next: *const c_void,
42117     pub flags: HeadlessSurfaceCreateFlagsEXT,
42118 }
42119 impl ::std::default::Default for HeadlessSurfaceCreateInfoEXT {
42120     #[inline]
default() -> Self42121     fn default() -> Self {
42122         Self {
42123             s_type: Self::STRUCTURE_TYPE,
42124             p_next: ::std::ptr::null(),
42125             flags: HeadlessSurfaceCreateFlagsEXT::default(),
42126         }
42127     }
42128 }
42129 unsafe impl TaggedStructure for HeadlessSurfaceCreateInfoEXT {
42130     const STRUCTURE_TYPE: StructureType = StructureType::HEADLESS_SURFACE_CREATE_INFO_EXT;
42131 }
42132 impl HeadlessSurfaceCreateInfoEXT {
builder<'a>() -> HeadlessSurfaceCreateInfoEXTBuilder<'a>42133     pub fn builder<'a>() -> HeadlessSurfaceCreateInfoEXTBuilder<'a> {
42134         HeadlessSurfaceCreateInfoEXTBuilder {
42135             inner: Self::default(),
42136             marker: ::std::marker::PhantomData,
42137         }
42138     }
42139 }
42140 #[repr(transparent)]
42141 pub struct HeadlessSurfaceCreateInfoEXTBuilder<'a> {
42142     inner: HeadlessSurfaceCreateInfoEXT,
42143     marker: ::std::marker::PhantomData<&'a ()>,
42144 }
42145 impl<'a> ::std::ops::Deref for HeadlessSurfaceCreateInfoEXTBuilder<'a> {
42146     type Target = HeadlessSurfaceCreateInfoEXT;
deref(&self) -> &Self::Target42147     fn deref(&self) -> &Self::Target {
42148         &self.inner
42149     }
42150 }
42151 impl<'a> ::std::ops::DerefMut for HeadlessSurfaceCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target42152     fn deref_mut(&mut self) -> &mut Self::Target {
42153         &mut self.inner
42154     }
42155 }
42156 impl<'a> HeadlessSurfaceCreateInfoEXTBuilder<'a> {
42157     #[inline]
flags(mut self, flags: HeadlessSurfaceCreateFlagsEXT) -> Self42158     pub fn flags(mut self, flags: HeadlessSurfaceCreateFlagsEXT) -> Self {
42159         self.inner.flags = flags;
42160         self
42161     }
42162     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42163     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42164     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> HeadlessSurfaceCreateInfoEXT42165     pub fn build(self) -> HeadlessSurfaceCreateInfoEXT {
42166         self.inner
42167     }
42168 }
42169 #[repr(C)]
42170 #[cfg_attr(feature = "debug", derive(Debug))]
42171 #[derive(Copy, Clone)]
42172 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCoverageReductionModeFeaturesNV.html>"]
42173 pub struct PhysicalDeviceCoverageReductionModeFeaturesNV {
42174     pub s_type: StructureType,
42175     pub p_next: *mut c_void,
42176     pub coverage_reduction_mode: Bool32,
42177 }
42178 impl ::std::default::Default for PhysicalDeviceCoverageReductionModeFeaturesNV {
42179     #[inline]
default() -> Self42180     fn default() -> Self {
42181         Self {
42182             s_type: Self::STRUCTURE_TYPE,
42183             p_next: ::std::ptr::null_mut(),
42184             coverage_reduction_mode: Bool32::default(),
42185         }
42186     }
42187 }
42188 unsafe impl TaggedStructure for PhysicalDeviceCoverageReductionModeFeaturesNV {
42189     const STRUCTURE_TYPE: StructureType =
42190         StructureType::PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
42191 }
42192 impl PhysicalDeviceCoverageReductionModeFeaturesNV {
builder<'a>() -> PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a>42193     pub fn builder<'a>() -> PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
42194         PhysicalDeviceCoverageReductionModeFeaturesNVBuilder {
42195             inner: Self::default(),
42196             marker: ::std::marker::PhantomData,
42197         }
42198     }
42199 }
42200 #[repr(transparent)]
42201 pub struct PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
42202     inner: PhysicalDeviceCoverageReductionModeFeaturesNV,
42203     marker: ::std::marker::PhantomData<&'a ()>,
42204 }
42205 unsafe impl ExtendsPhysicalDeviceFeatures2
42206     for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'_>
42207 {
42208 }
42209 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCoverageReductionModeFeaturesNV {}
42210 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'_> {}
42211 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoverageReductionModeFeaturesNV {}
42212 impl<'a> ::std::ops::Deref for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
42213     type Target = PhysicalDeviceCoverageReductionModeFeaturesNV;
deref(&self) -> &Self::Target42214     fn deref(&self) -> &Self::Target {
42215         &self.inner
42216     }
42217 }
42218 impl<'a> ::std::ops::DerefMut for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target42219     fn deref_mut(&mut self) -> &mut Self::Target {
42220         &mut self.inner
42221     }
42222 }
42223 impl<'a> PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
42224     #[inline]
coverage_reduction_mode(mut self, coverage_reduction_mode: bool) -> Self42225     pub fn coverage_reduction_mode(mut self, coverage_reduction_mode: bool) -> Self {
42226         self.inner.coverage_reduction_mode = coverage_reduction_mode.into();
42227         self
42228     }
42229     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42230     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42231     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceCoverageReductionModeFeaturesNV42232     pub fn build(self) -> PhysicalDeviceCoverageReductionModeFeaturesNV {
42233         self.inner
42234     }
42235 }
42236 #[repr(C)]
42237 #[cfg_attr(feature = "debug", derive(Debug))]
42238 #[derive(Copy, Clone)]
42239 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageReductionStateCreateInfoNV.html>"]
42240 pub struct PipelineCoverageReductionStateCreateInfoNV {
42241     pub s_type: StructureType,
42242     pub p_next: *const c_void,
42243     pub flags: PipelineCoverageReductionStateCreateFlagsNV,
42244     pub coverage_reduction_mode: CoverageReductionModeNV,
42245 }
42246 impl ::std::default::Default for PipelineCoverageReductionStateCreateInfoNV {
42247     #[inline]
default() -> Self42248     fn default() -> Self {
42249         Self {
42250             s_type: Self::STRUCTURE_TYPE,
42251             p_next: ::std::ptr::null(),
42252             flags: PipelineCoverageReductionStateCreateFlagsNV::default(),
42253             coverage_reduction_mode: CoverageReductionModeNV::default(),
42254         }
42255     }
42256 }
42257 unsafe impl TaggedStructure for PipelineCoverageReductionStateCreateInfoNV {
42258     const STRUCTURE_TYPE: StructureType =
42259         StructureType::PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV;
42260 }
42261 impl PipelineCoverageReductionStateCreateInfoNV {
builder<'a>() -> PipelineCoverageReductionStateCreateInfoNVBuilder<'a>42262     pub fn builder<'a>() -> PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
42263         PipelineCoverageReductionStateCreateInfoNVBuilder {
42264             inner: Self::default(),
42265             marker: ::std::marker::PhantomData,
42266         }
42267     }
42268 }
42269 #[repr(transparent)]
42270 pub struct PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
42271     inner: PipelineCoverageReductionStateCreateInfoNV,
42272     marker: ::std::marker::PhantomData<&'a ()>,
42273 }
42274 unsafe impl ExtendsPipelineMultisampleStateCreateInfo
42275     for PipelineCoverageReductionStateCreateInfoNVBuilder<'_>
42276 {
42277 }
42278 unsafe impl ExtendsPipelineMultisampleStateCreateInfo
42279     for PipelineCoverageReductionStateCreateInfoNV
42280 {
42281 }
42282 impl<'a> ::std::ops::Deref for PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
42283     type Target = PipelineCoverageReductionStateCreateInfoNV;
deref(&self) -> &Self::Target42284     fn deref(&self) -> &Self::Target {
42285         &self.inner
42286     }
42287 }
42288 impl<'a> ::std::ops::DerefMut for PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target42289     fn deref_mut(&mut self) -> &mut Self::Target {
42290         &mut self.inner
42291     }
42292 }
42293 impl<'a> PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
42294     #[inline]
flags(mut self, flags: PipelineCoverageReductionStateCreateFlagsNV) -> Self42295     pub fn flags(mut self, flags: PipelineCoverageReductionStateCreateFlagsNV) -> Self {
42296         self.inner.flags = flags;
42297         self
42298     }
42299     #[inline]
coverage_reduction_mode( mut self, coverage_reduction_mode: CoverageReductionModeNV, ) -> Self42300     pub fn coverage_reduction_mode(
42301         mut self,
42302         coverage_reduction_mode: CoverageReductionModeNV,
42303     ) -> Self {
42304         self.inner.coverage_reduction_mode = coverage_reduction_mode;
42305         self
42306     }
42307     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42308     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42309     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineCoverageReductionStateCreateInfoNV42310     pub fn build(self) -> PipelineCoverageReductionStateCreateInfoNV {
42311         self.inner
42312     }
42313 }
42314 #[repr(C)]
42315 #[cfg_attr(feature = "debug", derive(Debug))]
42316 #[derive(Copy, Clone)]
42317 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebufferMixedSamplesCombinationNV.html>"]
42318 pub struct FramebufferMixedSamplesCombinationNV {
42319     pub s_type: StructureType,
42320     pub p_next: *mut c_void,
42321     pub coverage_reduction_mode: CoverageReductionModeNV,
42322     pub rasterization_samples: SampleCountFlags,
42323     pub depth_stencil_samples: SampleCountFlags,
42324     pub color_samples: SampleCountFlags,
42325 }
42326 impl ::std::default::Default for FramebufferMixedSamplesCombinationNV {
42327     #[inline]
default() -> Self42328     fn default() -> Self {
42329         Self {
42330             s_type: Self::STRUCTURE_TYPE,
42331             p_next: ::std::ptr::null_mut(),
42332             coverage_reduction_mode: CoverageReductionModeNV::default(),
42333             rasterization_samples: SampleCountFlags::default(),
42334             depth_stencil_samples: SampleCountFlags::default(),
42335             color_samples: SampleCountFlags::default(),
42336         }
42337     }
42338 }
42339 unsafe impl TaggedStructure for FramebufferMixedSamplesCombinationNV {
42340     const STRUCTURE_TYPE: StructureType = StructureType::FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV;
42341 }
42342 impl FramebufferMixedSamplesCombinationNV {
builder<'a>() -> FramebufferMixedSamplesCombinationNVBuilder<'a>42343     pub fn builder<'a>() -> FramebufferMixedSamplesCombinationNVBuilder<'a> {
42344         FramebufferMixedSamplesCombinationNVBuilder {
42345             inner: Self::default(),
42346             marker: ::std::marker::PhantomData,
42347         }
42348     }
42349 }
42350 #[repr(transparent)]
42351 pub struct FramebufferMixedSamplesCombinationNVBuilder<'a> {
42352     inner: FramebufferMixedSamplesCombinationNV,
42353     marker: ::std::marker::PhantomData<&'a ()>,
42354 }
42355 impl<'a> ::std::ops::Deref for FramebufferMixedSamplesCombinationNVBuilder<'a> {
42356     type Target = FramebufferMixedSamplesCombinationNV;
deref(&self) -> &Self::Target42357     fn deref(&self) -> &Self::Target {
42358         &self.inner
42359     }
42360 }
42361 impl<'a> ::std::ops::DerefMut for FramebufferMixedSamplesCombinationNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target42362     fn deref_mut(&mut self) -> &mut Self::Target {
42363         &mut self.inner
42364     }
42365 }
42366 impl<'a> FramebufferMixedSamplesCombinationNVBuilder<'a> {
42367     #[inline]
coverage_reduction_mode( mut self, coverage_reduction_mode: CoverageReductionModeNV, ) -> Self42368     pub fn coverage_reduction_mode(
42369         mut self,
42370         coverage_reduction_mode: CoverageReductionModeNV,
42371     ) -> Self {
42372         self.inner.coverage_reduction_mode = coverage_reduction_mode;
42373         self
42374     }
42375     #[inline]
rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self42376     pub fn rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self {
42377         self.inner.rasterization_samples = rasterization_samples;
42378         self
42379     }
42380     #[inline]
depth_stencil_samples(mut self, depth_stencil_samples: SampleCountFlags) -> Self42381     pub fn depth_stencil_samples(mut self, depth_stencil_samples: SampleCountFlags) -> Self {
42382         self.inner.depth_stencil_samples = depth_stencil_samples;
42383         self
42384     }
42385     #[inline]
color_samples(mut self, color_samples: SampleCountFlags) -> Self42386     pub fn color_samples(mut self, color_samples: SampleCountFlags) -> Self {
42387         self.inner.color_samples = color_samples;
42388         self
42389     }
42390     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42391     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42392     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> FramebufferMixedSamplesCombinationNV42393     pub fn build(self) -> FramebufferMixedSamplesCombinationNV {
42394         self.inner
42395     }
42396 }
42397 #[repr(C)]
42398 #[cfg_attr(feature = "debug", derive(Debug))]
42399 #[derive(Copy, Clone)]
42400 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL.html>"]
42401 pub struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
42402     pub s_type: StructureType,
42403     pub p_next: *mut c_void,
42404     pub shader_integer_functions2: Bool32,
42405 }
42406 impl ::std::default::Default for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
42407     #[inline]
default() -> Self42408     fn default() -> Self {
42409         Self {
42410             s_type: Self::STRUCTURE_TYPE,
42411             p_next: ::std::ptr::null_mut(),
42412             shader_integer_functions2: Bool32::default(),
42413         }
42414     }
42415 }
42416 unsafe impl TaggedStructure for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
42417     const STRUCTURE_TYPE: StructureType =
42418         StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
42419 }
42420 impl PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
builder<'a>() -> PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a>42421     pub fn builder<'a>() -> PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
42422         PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder {
42423             inner: Self::default(),
42424             marker: ::std::marker::PhantomData,
42425         }
42426     }
42427 }
42428 #[repr(transparent)]
42429 pub struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
42430     inner: PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL,
42431     marker: ::std::marker::PhantomData<&'a ()>,
42432 }
42433 unsafe impl ExtendsPhysicalDeviceFeatures2
42434     for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'_>
42435 {
42436 }
42437 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {}
42438 unsafe impl ExtendsDeviceCreateInfo
42439     for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'_>
42440 {
42441 }
42442 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {}
42443 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
42444     type Target = PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
deref(&self) -> &Self::Target42445     fn deref(&self) -> &Self::Target {
42446         &self.inner
42447     }
42448 }
42449 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target42450     fn deref_mut(&mut self) -> &mut Self::Target {
42451         &mut self.inner
42452     }
42453 }
42454 impl<'a> PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
42455     #[inline]
shader_integer_functions2(mut self, shader_integer_functions2: bool) -> Self42456     pub fn shader_integer_functions2(mut self, shader_integer_functions2: bool) -> Self {
42457         self.inner.shader_integer_functions2 = shader_integer_functions2.into();
42458         self
42459     }
42460     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42461     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42462     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL42463     pub fn build(self) -> PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
42464         self.inner
42465     }
42466 }
42467 #[repr(C)]
42468 #[derive(Copy, Clone)]
42469 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceValueDataINTEL.html>"]
42470 pub union PerformanceValueDataINTEL {
42471     pub value32: u32,
42472     pub value64: u64,
42473     pub value_float: f32,
42474     pub value_bool: Bool32,
42475     pub value_string: *const c_char,
42476 }
42477 impl ::std::default::Default for PerformanceValueDataINTEL {
42478     #[inline]
default() -> Self42479     fn default() -> Self {
42480         unsafe { ::std::mem::zeroed() }
42481     }
42482 }
42483 #[repr(C)]
42484 #[derive(Copy, Clone, Default)]
42485 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceValueINTEL.html>"]
42486 pub struct PerformanceValueINTEL {
42487     pub ty: PerformanceValueTypeINTEL,
42488     pub data: PerformanceValueDataINTEL,
42489 }
42490 #[cfg(feature = "debug")]
42491 impl fmt::Debug for PerformanceValueINTEL {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result42492     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
42493         fmt.debug_struct("PerformanceValueINTEL")
42494             .field("ty", &self.ty)
42495             .field("data", &"union")
42496             .finish()
42497     }
42498 }
42499 impl PerformanceValueINTEL {
builder<'a>() -> PerformanceValueINTELBuilder<'a>42500     pub fn builder<'a>() -> PerformanceValueINTELBuilder<'a> {
42501         PerformanceValueINTELBuilder {
42502             inner: Self::default(),
42503             marker: ::std::marker::PhantomData,
42504         }
42505     }
42506 }
42507 #[repr(transparent)]
42508 pub struct PerformanceValueINTELBuilder<'a> {
42509     inner: PerformanceValueINTEL,
42510     marker: ::std::marker::PhantomData<&'a ()>,
42511 }
42512 impl<'a> ::std::ops::Deref for PerformanceValueINTELBuilder<'a> {
42513     type Target = PerformanceValueINTEL;
deref(&self) -> &Self::Target42514     fn deref(&self) -> &Self::Target {
42515         &self.inner
42516     }
42517 }
42518 impl<'a> ::std::ops::DerefMut for PerformanceValueINTELBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target42519     fn deref_mut(&mut self) -> &mut Self::Target {
42520         &mut self.inner
42521     }
42522 }
42523 impl<'a> PerformanceValueINTELBuilder<'a> {
42524     #[inline]
ty(mut self, ty: PerformanceValueTypeINTEL) -> Self42525     pub fn ty(mut self, ty: PerformanceValueTypeINTEL) -> Self {
42526         self.inner.ty = ty;
42527         self
42528     }
42529     #[inline]
data(mut self, data: PerformanceValueDataINTEL) -> Self42530     pub fn data(mut self, data: PerformanceValueDataINTEL) -> Self {
42531         self.inner.data = data;
42532         self
42533     }
42534     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42535     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42536     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PerformanceValueINTEL42537     pub fn build(self) -> PerformanceValueINTEL {
42538         self.inner
42539     }
42540 }
42541 #[repr(C)]
42542 #[cfg_attr(feature = "debug", derive(Debug))]
42543 #[derive(Copy, Clone)]
42544 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkInitializePerformanceApiInfoINTEL.html>"]
42545 pub struct InitializePerformanceApiInfoINTEL {
42546     pub s_type: StructureType,
42547     pub p_next: *const c_void,
42548     pub p_user_data: *mut c_void,
42549 }
42550 impl ::std::default::Default for InitializePerformanceApiInfoINTEL {
42551     #[inline]
default() -> Self42552     fn default() -> Self {
42553         Self {
42554             s_type: Self::STRUCTURE_TYPE,
42555             p_next: ::std::ptr::null(),
42556             p_user_data: ::std::ptr::null_mut(),
42557         }
42558     }
42559 }
42560 unsafe impl TaggedStructure for InitializePerformanceApiInfoINTEL {
42561     const STRUCTURE_TYPE: StructureType = StructureType::INITIALIZE_PERFORMANCE_API_INFO_INTEL;
42562 }
42563 impl InitializePerformanceApiInfoINTEL {
builder<'a>() -> InitializePerformanceApiInfoINTELBuilder<'a>42564     pub fn builder<'a>() -> InitializePerformanceApiInfoINTELBuilder<'a> {
42565         InitializePerformanceApiInfoINTELBuilder {
42566             inner: Self::default(),
42567             marker: ::std::marker::PhantomData,
42568         }
42569     }
42570 }
42571 #[repr(transparent)]
42572 pub struct InitializePerformanceApiInfoINTELBuilder<'a> {
42573     inner: InitializePerformanceApiInfoINTEL,
42574     marker: ::std::marker::PhantomData<&'a ()>,
42575 }
42576 impl<'a> ::std::ops::Deref for InitializePerformanceApiInfoINTELBuilder<'a> {
42577     type Target = InitializePerformanceApiInfoINTEL;
deref(&self) -> &Self::Target42578     fn deref(&self) -> &Self::Target {
42579         &self.inner
42580     }
42581 }
42582 impl<'a> ::std::ops::DerefMut for InitializePerformanceApiInfoINTELBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target42583     fn deref_mut(&mut self) -> &mut Self::Target {
42584         &mut self.inner
42585     }
42586 }
42587 impl<'a> InitializePerformanceApiInfoINTELBuilder<'a> {
42588     #[inline]
user_data(mut self, user_data: *mut c_void) -> Self42589     pub fn user_data(mut self, user_data: *mut c_void) -> Self {
42590         self.inner.p_user_data = user_data;
42591         self
42592     }
42593     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42594     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42595     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> InitializePerformanceApiInfoINTEL42596     pub fn build(self) -> InitializePerformanceApiInfoINTEL {
42597         self.inner
42598     }
42599 }
42600 #[repr(C)]
42601 #[cfg_attr(feature = "debug", derive(Debug))]
42602 #[derive(Copy, Clone)]
42603 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPoolPerformanceQueryCreateInfoINTEL.html>"]
42604 pub struct QueryPoolPerformanceQueryCreateInfoINTEL {
42605     pub s_type: StructureType,
42606     pub p_next: *const c_void,
42607     pub performance_counters_sampling: QueryPoolSamplingModeINTEL,
42608 }
42609 impl ::std::default::Default for QueryPoolPerformanceQueryCreateInfoINTEL {
42610     #[inline]
default() -> Self42611     fn default() -> Self {
42612         Self {
42613             s_type: Self::STRUCTURE_TYPE,
42614             p_next: ::std::ptr::null(),
42615             performance_counters_sampling: QueryPoolSamplingModeINTEL::default(),
42616         }
42617     }
42618 }
42619 unsafe impl TaggedStructure for QueryPoolPerformanceQueryCreateInfoINTEL {
42620     const STRUCTURE_TYPE: StructureType =
42621         StructureType::QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL;
42622 }
42623 impl QueryPoolPerformanceQueryCreateInfoINTEL {
builder<'a>() -> QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a>42624     pub fn builder<'a>() -> QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
42625         QueryPoolPerformanceQueryCreateInfoINTELBuilder {
42626             inner: Self::default(),
42627             marker: ::std::marker::PhantomData,
42628         }
42629     }
42630 }
42631 #[repr(transparent)]
42632 pub struct QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
42633     inner: QueryPoolPerformanceQueryCreateInfoINTEL,
42634     marker: ::std::marker::PhantomData<&'a ()>,
42635 }
42636 unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceQueryCreateInfoINTELBuilder<'_> {}
42637 unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceQueryCreateInfoINTEL {}
42638 impl<'a> ::std::ops::Deref for QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
42639     type Target = QueryPoolPerformanceQueryCreateInfoINTEL;
deref(&self) -> &Self::Target42640     fn deref(&self) -> &Self::Target {
42641         &self.inner
42642     }
42643 }
42644 impl<'a> ::std::ops::DerefMut for QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target42645     fn deref_mut(&mut self) -> &mut Self::Target {
42646         &mut self.inner
42647     }
42648 }
42649 impl<'a> QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
42650     #[inline]
performance_counters_sampling( mut self, performance_counters_sampling: QueryPoolSamplingModeINTEL, ) -> Self42651     pub fn performance_counters_sampling(
42652         mut self,
42653         performance_counters_sampling: QueryPoolSamplingModeINTEL,
42654     ) -> Self {
42655         self.inner.performance_counters_sampling = performance_counters_sampling;
42656         self
42657     }
42658     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42659     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42660     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> QueryPoolPerformanceQueryCreateInfoINTEL42661     pub fn build(self) -> QueryPoolPerformanceQueryCreateInfoINTEL {
42662         self.inner
42663     }
42664 }
42665 #[repr(C)]
42666 #[cfg_attr(feature = "debug", derive(Debug))]
42667 #[derive(Copy, Clone)]
42668 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceMarkerInfoINTEL.html>"]
42669 pub struct PerformanceMarkerInfoINTEL {
42670     pub s_type: StructureType,
42671     pub p_next: *const c_void,
42672     pub marker: u64,
42673 }
42674 impl ::std::default::Default for PerformanceMarkerInfoINTEL {
42675     #[inline]
default() -> Self42676     fn default() -> Self {
42677         Self {
42678             s_type: Self::STRUCTURE_TYPE,
42679             p_next: ::std::ptr::null(),
42680             marker: u64::default(),
42681         }
42682     }
42683 }
42684 unsafe impl TaggedStructure for PerformanceMarkerInfoINTEL {
42685     const STRUCTURE_TYPE: StructureType = StructureType::PERFORMANCE_MARKER_INFO_INTEL;
42686 }
42687 impl PerformanceMarkerInfoINTEL {
builder<'a>() -> PerformanceMarkerInfoINTELBuilder<'a>42688     pub fn builder<'a>() -> PerformanceMarkerInfoINTELBuilder<'a> {
42689         PerformanceMarkerInfoINTELBuilder {
42690             inner: Self::default(),
42691             marker: ::std::marker::PhantomData,
42692         }
42693     }
42694 }
42695 #[repr(transparent)]
42696 pub struct PerformanceMarkerInfoINTELBuilder<'a> {
42697     inner: PerformanceMarkerInfoINTEL,
42698     marker: ::std::marker::PhantomData<&'a ()>,
42699 }
42700 impl<'a> ::std::ops::Deref for PerformanceMarkerInfoINTELBuilder<'a> {
42701     type Target = PerformanceMarkerInfoINTEL;
deref(&self) -> &Self::Target42702     fn deref(&self) -> &Self::Target {
42703         &self.inner
42704     }
42705 }
42706 impl<'a> ::std::ops::DerefMut for PerformanceMarkerInfoINTELBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target42707     fn deref_mut(&mut self) -> &mut Self::Target {
42708         &mut self.inner
42709     }
42710 }
42711 impl<'a> PerformanceMarkerInfoINTELBuilder<'a> {
42712     #[inline]
marker(mut self, marker: u64) -> Self42713     pub fn marker(mut self, marker: u64) -> Self {
42714         self.inner.marker = marker;
42715         self
42716     }
42717     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42718     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42719     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PerformanceMarkerInfoINTEL42720     pub fn build(self) -> PerformanceMarkerInfoINTEL {
42721         self.inner
42722     }
42723 }
42724 #[repr(C)]
42725 #[cfg_attr(feature = "debug", derive(Debug))]
42726 #[derive(Copy, Clone)]
42727 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceStreamMarkerInfoINTEL.html>"]
42728 pub struct PerformanceStreamMarkerInfoINTEL {
42729     pub s_type: StructureType,
42730     pub p_next: *const c_void,
42731     pub marker: u32,
42732 }
42733 impl ::std::default::Default for PerformanceStreamMarkerInfoINTEL {
42734     #[inline]
default() -> Self42735     fn default() -> Self {
42736         Self {
42737             s_type: Self::STRUCTURE_TYPE,
42738             p_next: ::std::ptr::null(),
42739             marker: u32::default(),
42740         }
42741     }
42742 }
42743 unsafe impl TaggedStructure for PerformanceStreamMarkerInfoINTEL {
42744     const STRUCTURE_TYPE: StructureType = StructureType::PERFORMANCE_STREAM_MARKER_INFO_INTEL;
42745 }
42746 impl PerformanceStreamMarkerInfoINTEL {
builder<'a>() -> PerformanceStreamMarkerInfoINTELBuilder<'a>42747     pub fn builder<'a>() -> PerformanceStreamMarkerInfoINTELBuilder<'a> {
42748         PerformanceStreamMarkerInfoINTELBuilder {
42749             inner: Self::default(),
42750             marker: ::std::marker::PhantomData,
42751         }
42752     }
42753 }
42754 #[repr(transparent)]
42755 pub struct PerformanceStreamMarkerInfoINTELBuilder<'a> {
42756     inner: PerformanceStreamMarkerInfoINTEL,
42757     marker: ::std::marker::PhantomData<&'a ()>,
42758 }
42759 impl<'a> ::std::ops::Deref for PerformanceStreamMarkerInfoINTELBuilder<'a> {
42760     type Target = PerformanceStreamMarkerInfoINTEL;
deref(&self) -> &Self::Target42761     fn deref(&self) -> &Self::Target {
42762         &self.inner
42763     }
42764 }
42765 impl<'a> ::std::ops::DerefMut for PerformanceStreamMarkerInfoINTELBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target42766     fn deref_mut(&mut self) -> &mut Self::Target {
42767         &mut self.inner
42768     }
42769 }
42770 impl<'a> PerformanceStreamMarkerInfoINTELBuilder<'a> {
42771     #[inline]
marker(mut self, marker: u32) -> Self42772     pub fn marker(mut self, marker: u32) -> Self {
42773         self.inner.marker = marker;
42774         self
42775     }
42776     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42777     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42778     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PerformanceStreamMarkerInfoINTEL42779     pub fn build(self) -> PerformanceStreamMarkerInfoINTEL {
42780         self.inner
42781     }
42782 }
42783 #[repr(C)]
42784 #[cfg_attr(feature = "debug", derive(Debug))]
42785 #[derive(Copy, Clone)]
42786 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceOverrideInfoINTEL.html>"]
42787 pub struct PerformanceOverrideInfoINTEL {
42788     pub s_type: StructureType,
42789     pub p_next: *const c_void,
42790     pub ty: PerformanceOverrideTypeINTEL,
42791     pub enable: Bool32,
42792     pub parameter: u64,
42793 }
42794 impl ::std::default::Default for PerformanceOverrideInfoINTEL {
42795     #[inline]
default() -> Self42796     fn default() -> Self {
42797         Self {
42798             s_type: Self::STRUCTURE_TYPE,
42799             p_next: ::std::ptr::null(),
42800             ty: PerformanceOverrideTypeINTEL::default(),
42801             enable: Bool32::default(),
42802             parameter: u64::default(),
42803         }
42804     }
42805 }
42806 unsafe impl TaggedStructure for PerformanceOverrideInfoINTEL {
42807     const STRUCTURE_TYPE: StructureType = StructureType::PERFORMANCE_OVERRIDE_INFO_INTEL;
42808 }
42809 impl PerformanceOverrideInfoINTEL {
builder<'a>() -> PerformanceOverrideInfoINTELBuilder<'a>42810     pub fn builder<'a>() -> PerformanceOverrideInfoINTELBuilder<'a> {
42811         PerformanceOverrideInfoINTELBuilder {
42812             inner: Self::default(),
42813             marker: ::std::marker::PhantomData,
42814         }
42815     }
42816 }
42817 #[repr(transparent)]
42818 pub struct PerformanceOverrideInfoINTELBuilder<'a> {
42819     inner: PerformanceOverrideInfoINTEL,
42820     marker: ::std::marker::PhantomData<&'a ()>,
42821 }
42822 impl<'a> ::std::ops::Deref for PerformanceOverrideInfoINTELBuilder<'a> {
42823     type Target = PerformanceOverrideInfoINTEL;
deref(&self) -> &Self::Target42824     fn deref(&self) -> &Self::Target {
42825         &self.inner
42826     }
42827 }
42828 impl<'a> ::std::ops::DerefMut for PerformanceOverrideInfoINTELBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target42829     fn deref_mut(&mut self) -> &mut Self::Target {
42830         &mut self.inner
42831     }
42832 }
42833 impl<'a> PerformanceOverrideInfoINTELBuilder<'a> {
42834     #[inline]
ty(mut self, ty: PerformanceOverrideTypeINTEL) -> Self42835     pub fn ty(mut self, ty: PerformanceOverrideTypeINTEL) -> Self {
42836         self.inner.ty = ty;
42837         self
42838     }
42839     #[inline]
enable(mut self, enable: bool) -> Self42840     pub fn enable(mut self, enable: bool) -> Self {
42841         self.inner.enable = enable.into();
42842         self
42843     }
42844     #[inline]
parameter(mut self, parameter: u64) -> Self42845     pub fn parameter(mut self, parameter: u64) -> Self {
42846         self.inner.parameter = parameter;
42847         self
42848     }
42849     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42850     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42851     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PerformanceOverrideInfoINTEL42852     pub fn build(self) -> PerformanceOverrideInfoINTEL {
42853         self.inner
42854     }
42855 }
42856 #[repr(C)]
42857 #[cfg_attr(feature = "debug", derive(Debug))]
42858 #[derive(Copy, Clone)]
42859 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceConfigurationAcquireInfoINTEL.html>"]
42860 pub struct PerformanceConfigurationAcquireInfoINTEL {
42861     pub s_type: StructureType,
42862     pub p_next: *const c_void,
42863     pub ty: PerformanceConfigurationTypeINTEL,
42864 }
42865 impl ::std::default::Default for PerformanceConfigurationAcquireInfoINTEL {
42866     #[inline]
default() -> Self42867     fn default() -> Self {
42868         Self {
42869             s_type: Self::STRUCTURE_TYPE,
42870             p_next: ::std::ptr::null(),
42871             ty: PerformanceConfigurationTypeINTEL::default(),
42872         }
42873     }
42874 }
42875 unsafe impl TaggedStructure for PerformanceConfigurationAcquireInfoINTEL {
42876     const STRUCTURE_TYPE: StructureType =
42877         StructureType::PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL;
42878 }
42879 impl PerformanceConfigurationAcquireInfoINTEL {
builder<'a>() -> PerformanceConfigurationAcquireInfoINTELBuilder<'a>42880     pub fn builder<'a>() -> PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
42881         PerformanceConfigurationAcquireInfoINTELBuilder {
42882             inner: Self::default(),
42883             marker: ::std::marker::PhantomData,
42884         }
42885     }
42886 }
42887 #[repr(transparent)]
42888 pub struct PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
42889     inner: PerformanceConfigurationAcquireInfoINTEL,
42890     marker: ::std::marker::PhantomData<&'a ()>,
42891 }
42892 impl<'a> ::std::ops::Deref for PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
42893     type Target = PerformanceConfigurationAcquireInfoINTEL;
deref(&self) -> &Self::Target42894     fn deref(&self) -> &Self::Target {
42895         &self.inner
42896     }
42897 }
42898 impl<'a> ::std::ops::DerefMut for PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target42899     fn deref_mut(&mut self) -> &mut Self::Target {
42900         &mut self.inner
42901     }
42902 }
42903 impl<'a> PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
42904     #[inline]
ty(mut self, ty: PerformanceConfigurationTypeINTEL) -> Self42905     pub fn ty(mut self, ty: PerformanceConfigurationTypeINTEL) -> Self {
42906         self.inner.ty = ty;
42907         self
42908     }
42909     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42910     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42911     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PerformanceConfigurationAcquireInfoINTEL42912     pub fn build(self) -> PerformanceConfigurationAcquireInfoINTEL {
42913         self.inner
42914     }
42915 }
42916 #[repr(C)]
42917 #[cfg_attr(feature = "debug", derive(Debug))]
42918 #[derive(Copy, Clone)]
42919 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderClockFeaturesKHR.html>"]
42920 pub struct PhysicalDeviceShaderClockFeaturesKHR {
42921     pub s_type: StructureType,
42922     pub p_next: *mut c_void,
42923     pub shader_subgroup_clock: Bool32,
42924     pub shader_device_clock: Bool32,
42925 }
42926 impl ::std::default::Default for PhysicalDeviceShaderClockFeaturesKHR {
42927     #[inline]
default() -> Self42928     fn default() -> Self {
42929         Self {
42930             s_type: Self::STRUCTURE_TYPE,
42931             p_next: ::std::ptr::null_mut(),
42932             shader_subgroup_clock: Bool32::default(),
42933             shader_device_clock: Bool32::default(),
42934         }
42935     }
42936 }
42937 unsafe impl TaggedStructure for PhysicalDeviceShaderClockFeaturesKHR {
42938     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
42939 }
42940 impl PhysicalDeviceShaderClockFeaturesKHR {
builder<'a>() -> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a>42941     pub fn builder<'a>() -> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
42942         PhysicalDeviceShaderClockFeaturesKHRBuilder {
42943             inner: Self::default(),
42944             marker: ::std::marker::PhantomData,
42945         }
42946     }
42947 }
42948 #[repr(transparent)]
42949 pub struct PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
42950     inner: PhysicalDeviceShaderClockFeaturesKHR,
42951     marker: ::std::marker::PhantomData<&'a ()>,
42952 }
42953 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderClockFeaturesKHRBuilder<'_> {}
42954 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderClockFeaturesKHR {}
42955 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderClockFeaturesKHRBuilder<'_> {}
42956 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderClockFeaturesKHR {}
42957 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
42958     type Target = PhysicalDeviceShaderClockFeaturesKHR;
deref(&self) -> &Self::Target42959     fn deref(&self) -> &Self::Target {
42960         &self.inner
42961     }
42962 }
42963 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target42964     fn deref_mut(&mut self) -> &mut Self::Target {
42965         &mut self.inner
42966     }
42967 }
42968 impl<'a> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
42969     #[inline]
shader_subgroup_clock(mut self, shader_subgroup_clock: bool) -> Self42970     pub fn shader_subgroup_clock(mut self, shader_subgroup_clock: bool) -> Self {
42971         self.inner.shader_subgroup_clock = shader_subgroup_clock.into();
42972         self
42973     }
42974     #[inline]
shader_device_clock(mut self, shader_device_clock: bool) -> Self42975     pub fn shader_device_clock(mut self, shader_device_clock: bool) -> Self {
42976         self.inner.shader_device_clock = shader_device_clock.into();
42977         self
42978     }
42979     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42980     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42981     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderClockFeaturesKHR42982     pub fn build(self) -> PhysicalDeviceShaderClockFeaturesKHR {
42983         self.inner
42984     }
42985 }
42986 #[repr(C)]
42987 #[cfg_attr(feature = "debug", derive(Debug))]
42988 #[derive(Copy, Clone)]
42989 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceIndexTypeUint8FeaturesEXT.html>"]
42990 pub struct PhysicalDeviceIndexTypeUint8FeaturesEXT {
42991     pub s_type: StructureType,
42992     pub p_next: *mut c_void,
42993     pub index_type_uint8: Bool32,
42994 }
42995 impl ::std::default::Default for PhysicalDeviceIndexTypeUint8FeaturesEXT {
42996     #[inline]
default() -> Self42997     fn default() -> Self {
42998         Self {
42999             s_type: Self::STRUCTURE_TYPE,
43000             p_next: ::std::ptr::null_mut(),
43001             index_type_uint8: Bool32::default(),
43002         }
43003     }
43004 }
43005 unsafe impl TaggedStructure for PhysicalDeviceIndexTypeUint8FeaturesEXT {
43006     const STRUCTURE_TYPE: StructureType =
43007         StructureType::PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT;
43008 }
43009 impl PhysicalDeviceIndexTypeUint8FeaturesEXT {
builder<'a>() -> PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a>43010     pub fn builder<'a>() -> PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
43011         PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder {
43012             inner: Self::default(),
43013             marker: ::std::marker::PhantomData,
43014         }
43015     }
43016 }
43017 #[repr(transparent)]
43018 pub struct PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
43019     inner: PhysicalDeviceIndexTypeUint8FeaturesEXT,
43020     marker: ::std::marker::PhantomData<&'a ()>,
43021 }
43022 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'_> {}
43023 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceIndexTypeUint8FeaturesEXT {}
43024 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'_> {}
43025 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceIndexTypeUint8FeaturesEXT {}
43026 impl<'a> ::std::ops::Deref for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
43027     type Target = PhysicalDeviceIndexTypeUint8FeaturesEXT;
deref(&self) -> &Self::Target43028     fn deref(&self) -> &Self::Target {
43029         &self.inner
43030     }
43031 }
43032 impl<'a> ::std::ops::DerefMut for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target43033     fn deref_mut(&mut self) -> &mut Self::Target {
43034         &mut self.inner
43035     }
43036 }
43037 impl<'a> PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
43038     #[inline]
index_type_uint8(mut self, index_type_uint8: bool) -> Self43039     pub fn index_type_uint8(mut self, index_type_uint8: bool) -> Self {
43040         self.inner.index_type_uint8 = index_type_uint8.into();
43041         self
43042     }
43043     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43044     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43045     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceIndexTypeUint8FeaturesEXT43046     pub fn build(self) -> PhysicalDeviceIndexTypeUint8FeaturesEXT {
43047         self.inner
43048     }
43049 }
43050 #[repr(C)]
43051 #[cfg_attr(feature = "debug", derive(Debug))]
43052 #[derive(Copy, Clone)]
43053 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderSMBuiltinsPropertiesNV.html>"]
43054 pub struct PhysicalDeviceShaderSMBuiltinsPropertiesNV {
43055     pub s_type: StructureType,
43056     pub p_next: *mut c_void,
43057     pub shader_sm_count: u32,
43058     pub shader_warps_per_sm: u32,
43059 }
43060 impl ::std::default::Default for PhysicalDeviceShaderSMBuiltinsPropertiesNV {
43061     #[inline]
default() -> Self43062     fn default() -> Self {
43063         Self {
43064             s_type: Self::STRUCTURE_TYPE,
43065             p_next: ::std::ptr::null_mut(),
43066             shader_sm_count: u32::default(),
43067             shader_warps_per_sm: u32::default(),
43068         }
43069     }
43070 }
43071 unsafe impl TaggedStructure for PhysicalDeviceShaderSMBuiltinsPropertiesNV {
43072     const STRUCTURE_TYPE: StructureType =
43073         StructureType::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV;
43074 }
43075 impl PhysicalDeviceShaderSMBuiltinsPropertiesNV {
builder<'a>() -> PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a>43076     pub fn builder<'a>() -> PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
43077         PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder {
43078             inner: Self::default(),
43079             marker: ::std::marker::PhantomData,
43080         }
43081     }
43082 }
43083 #[repr(transparent)]
43084 pub struct PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
43085     inner: PhysicalDeviceShaderSMBuiltinsPropertiesNV,
43086     marker: ::std::marker::PhantomData<&'a ()>,
43087 }
43088 unsafe impl ExtendsPhysicalDeviceProperties2
43089     for PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'_>
43090 {
43091 }
43092 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderSMBuiltinsPropertiesNV {}
43093 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
43094     type Target = PhysicalDeviceShaderSMBuiltinsPropertiesNV;
deref(&self) -> &Self::Target43095     fn deref(&self) -> &Self::Target {
43096         &self.inner
43097     }
43098 }
43099 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target43100     fn deref_mut(&mut self) -> &mut Self::Target {
43101         &mut self.inner
43102     }
43103 }
43104 impl<'a> PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
43105     #[inline]
shader_sm_count(mut self, shader_sm_count: u32) -> Self43106     pub fn shader_sm_count(mut self, shader_sm_count: u32) -> Self {
43107         self.inner.shader_sm_count = shader_sm_count;
43108         self
43109     }
43110     #[inline]
shader_warps_per_sm(mut self, shader_warps_per_sm: u32) -> Self43111     pub fn shader_warps_per_sm(mut self, shader_warps_per_sm: u32) -> Self {
43112         self.inner.shader_warps_per_sm = shader_warps_per_sm;
43113         self
43114     }
43115     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43116     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43117     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderSMBuiltinsPropertiesNV43118     pub fn build(self) -> PhysicalDeviceShaderSMBuiltinsPropertiesNV {
43119         self.inner
43120     }
43121 }
43122 #[repr(C)]
43123 #[cfg_attr(feature = "debug", derive(Debug))]
43124 #[derive(Copy, Clone)]
43125 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderSMBuiltinsFeaturesNV.html>"]
43126 pub struct PhysicalDeviceShaderSMBuiltinsFeaturesNV {
43127     pub s_type: StructureType,
43128     pub p_next: *mut c_void,
43129     pub shader_sm_builtins: Bool32,
43130 }
43131 impl ::std::default::Default for PhysicalDeviceShaderSMBuiltinsFeaturesNV {
43132     #[inline]
default() -> Self43133     fn default() -> Self {
43134         Self {
43135             s_type: Self::STRUCTURE_TYPE,
43136             p_next: ::std::ptr::null_mut(),
43137             shader_sm_builtins: Bool32::default(),
43138         }
43139     }
43140 }
43141 unsafe impl TaggedStructure for PhysicalDeviceShaderSMBuiltinsFeaturesNV {
43142     const STRUCTURE_TYPE: StructureType =
43143         StructureType::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
43144 }
43145 impl PhysicalDeviceShaderSMBuiltinsFeaturesNV {
builder<'a>() -> PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a>43146     pub fn builder<'a>() -> PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
43147         PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder {
43148             inner: Self::default(),
43149             marker: ::std::marker::PhantomData,
43150         }
43151     }
43152 }
43153 #[repr(transparent)]
43154 pub struct PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
43155     inner: PhysicalDeviceShaderSMBuiltinsFeaturesNV,
43156     marker: ::std::marker::PhantomData<&'a ()>,
43157 }
43158 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'_> {}
43159 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderSMBuiltinsFeaturesNV {}
43160 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'_> {}
43161 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSMBuiltinsFeaturesNV {}
43162 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
43163     type Target = PhysicalDeviceShaderSMBuiltinsFeaturesNV;
deref(&self) -> &Self::Target43164     fn deref(&self) -> &Self::Target {
43165         &self.inner
43166     }
43167 }
43168 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target43169     fn deref_mut(&mut self) -> &mut Self::Target {
43170         &mut self.inner
43171     }
43172 }
43173 impl<'a> PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
43174     #[inline]
shader_sm_builtins(mut self, shader_sm_builtins: bool) -> Self43175     pub fn shader_sm_builtins(mut self, shader_sm_builtins: bool) -> Self {
43176         self.inner.shader_sm_builtins = shader_sm_builtins.into();
43177         self
43178     }
43179     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43180     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43181     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderSMBuiltinsFeaturesNV43182     pub fn build(self) -> PhysicalDeviceShaderSMBuiltinsFeaturesNV {
43183         self.inner
43184     }
43185 }
43186 #[repr(C)]
43187 #[cfg_attr(feature = "debug", derive(Debug))]
43188 #[derive(Copy, Clone)]
43189 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT.html>"]
43190 pub struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
43191     pub s_type: StructureType,
43192     pub p_next: *mut c_void,
43193     pub fragment_shader_sample_interlock: Bool32,
43194     pub fragment_shader_pixel_interlock: Bool32,
43195     pub fragment_shader_shading_rate_interlock: Bool32,
43196 }
43197 impl ::std::default::Default for PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
43198     #[inline]
default() -> Self43199     fn default() -> Self {
43200         Self {
43201             s_type: Self::STRUCTURE_TYPE,
43202             p_next: ::std::ptr::null_mut(),
43203             fragment_shader_sample_interlock: Bool32::default(),
43204             fragment_shader_pixel_interlock: Bool32::default(),
43205             fragment_shader_shading_rate_interlock: Bool32::default(),
43206         }
43207     }
43208 }
43209 unsafe impl TaggedStructure for PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
43210     const STRUCTURE_TYPE: StructureType =
43211         StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
43212 }
43213 impl PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
builder<'a>() -> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a>43214     pub fn builder<'a>() -> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
43215         PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder {
43216             inner: Self::default(),
43217             marker: ::std::marker::PhantomData,
43218         }
43219     }
43220 }
43221 #[repr(transparent)]
43222 pub struct PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
43223     inner: PhysicalDeviceFragmentShaderInterlockFeaturesEXT,
43224     marker: ::std::marker::PhantomData<&'a ()>,
43225 }
43226 unsafe impl ExtendsPhysicalDeviceFeatures2
43227     for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'_>
43228 {
43229 }
43230 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShaderInterlockFeaturesEXT {}
43231 unsafe impl ExtendsDeviceCreateInfo
43232     for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'_>
43233 {
43234 }
43235 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderInterlockFeaturesEXT {}
43236 impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
43237     type Target = PhysicalDeviceFragmentShaderInterlockFeaturesEXT;
deref(&self) -> &Self::Target43238     fn deref(&self) -> &Self::Target {
43239         &self.inner
43240     }
43241 }
43242 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target43243     fn deref_mut(&mut self) -> &mut Self::Target {
43244         &mut self.inner
43245     }
43246 }
43247 impl<'a> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
43248     #[inline]
fragment_shader_sample_interlock( mut self, fragment_shader_sample_interlock: bool, ) -> Self43249     pub fn fragment_shader_sample_interlock(
43250         mut self,
43251         fragment_shader_sample_interlock: bool,
43252     ) -> Self {
43253         self.inner.fragment_shader_sample_interlock = fragment_shader_sample_interlock.into();
43254         self
43255     }
43256     #[inline]
fragment_shader_pixel_interlock( mut self, fragment_shader_pixel_interlock: bool, ) -> Self43257     pub fn fragment_shader_pixel_interlock(
43258         mut self,
43259         fragment_shader_pixel_interlock: bool,
43260     ) -> Self {
43261         self.inner.fragment_shader_pixel_interlock = fragment_shader_pixel_interlock.into();
43262         self
43263     }
43264     #[inline]
fragment_shader_shading_rate_interlock( mut self, fragment_shader_shading_rate_interlock: bool, ) -> Self43265     pub fn fragment_shader_shading_rate_interlock(
43266         mut self,
43267         fragment_shader_shading_rate_interlock: bool,
43268     ) -> Self {
43269         self.inner.fragment_shader_shading_rate_interlock =
43270             fragment_shader_shading_rate_interlock.into();
43271         self
43272     }
43273     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43274     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43275     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFragmentShaderInterlockFeaturesEXT43276     pub fn build(self) -> PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
43277         self.inner
43278     }
43279 }
43280 #[repr(C)]
43281 #[cfg_attr(feature = "debug", derive(Debug))]
43282 #[derive(Copy, Clone)]
43283 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures.html>"]
43284 pub struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
43285     pub s_type: StructureType,
43286     pub p_next: *mut c_void,
43287     pub separate_depth_stencil_layouts: Bool32,
43288 }
43289 impl ::std::default::Default for PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
43290     #[inline]
default() -> Self43291     fn default() -> Self {
43292         Self {
43293             s_type: Self::STRUCTURE_TYPE,
43294             p_next: ::std::ptr::null_mut(),
43295             separate_depth_stencil_layouts: Bool32::default(),
43296         }
43297     }
43298 }
43299 unsafe impl TaggedStructure for PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
43300     const STRUCTURE_TYPE: StructureType =
43301         StructureType::PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
43302 }
43303 impl PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
builder<'a>() -> PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a>43304     pub fn builder<'a>() -> PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
43305         PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder {
43306             inner: Self::default(),
43307             marker: ::std::marker::PhantomData,
43308         }
43309     }
43310 }
43311 #[repr(transparent)]
43312 pub struct PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
43313     inner: PhysicalDeviceSeparateDepthStencilLayoutsFeatures,
43314     marker: ::std::marker::PhantomData<&'a ()>,
43315 }
43316 unsafe impl ExtendsPhysicalDeviceFeatures2
43317     for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'_>
43318 {
43319 }
43320 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSeparateDepthStencilLayoutsFeatures {}
43321 unsafe impl ExtendsDeviceCreateInfo
43322     for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'_>
43323 {
43324 }
43325 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSeparateDepthStencilLayoutsFeatures {}
43326 impl<'a> ::std::ops::Deref for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
43327     type Target = PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
deref(&self) -> &Self::Target43328     fn deref(&self) -> &Self::Target {
43329         &self.inner
43330     }
43331 }
43332 impl<'a> ::std::ops::DerefMut for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target43333     fn deref_mut(&mut self) -> &mut Self::Target {
43334         &mut self.inner
43335     }
43336 }
43337 impl<'a> PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
43338     #[inline]
separate_depth_stencil_layouts(mut self, separate_depth_stencil_layouts: bool) -> Self43339     pub fn separate_depth_stencil_layouts(mut self, separate_depth_stencil_layouts: bool) -> Self {
43340         self.inner.separate_depth_stencil_layouts = separate_depth_stencil_layouts.into();
43341         self
43342     }
43343     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43344     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43345     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceSeparateDepthStencilLayoutsFeatures43346     pub fn build(self) -> PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
43347         self.inner
43348     }
43349 }
43350 #[repr(C)]
43351 #[cfg_attr(feature = "debug", derive(Debug))]
43352 #[derive(Copy, Clone)]
43353 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentReferenceStencilLayout.html>"]
43354 pub struct AttachmentReferenceStencilLayout {
43355     pub s_type: StructureType,
43356     pub p_next: *mut c_void,
43357     pub stencil_layout: ImageLayout,
43358 }
43359 impl ::std::default::Default for AttachmentReferenceStencilLayout {
43360     #[inline]
default() -> Self43361     fn default() -> Self {
43362         Self {
43363             s_type: Self::STRUCTURE_TYPE,
43364             p_next: ::std::ptr::null_mut(),
43365             stencil_layout: ImageLayout::default(),
43366         }
43367     }
43368 }
43369 unsafe impl TaggedStructure for AttachmentReferenceStencilLayout {
43370     const STRUCTURE_TYPE: StructureType = StructureType::ATTACHMENT_REFERENCE_STENCIL_LAYOUT;
43371 }
43372 impl AttachmentReferenceStencilLayout {
builder<'a>() -> AttachmentReferenceStencilLayoutBuilder<'a>43373     pub fn builder<'a>() -> AttachmentReferenceStencilLayoutBuilder<'a> {
43374         AttachmentReferenceStencilLayoutBuilder {
43375             inner: Self::default(),
43376             marker: ::std::marker::PhantomData,
43377         }
43378     }
43379 }
43380 #[repr(transparent)]
43381 pub struct AttachmentReferenceStencilLayoutBuilder<'a> {
43382     inner: AttachmentReferenceStencilLayout,
43383     marker: ::std::marker::PhantomData<&'a ()>,
43384 }
43385 unsafe impl ExtendsAttachmentReference2 for AttachmentReferenceStencilLayoutBuilder<'_> {}
43386 unsafe impl ExtendsAttachmentReference2 for AttachmentReferenceStencilLayout {}
43387 impl<'a> ::std::ops::Deref for AttachmentReferenceStencilLayoutBuilder<'a> {
43388     type Target = AttachmentReferenceStencilLayout;
deref(&self) -> &Self::Target43389     fn deref(&self) -> &Self::Target {
43390         &self.inner
43391     }
43392 }
43393 impl<'a> ::std::ops::DerefMut for AttachmentReferenceStencilLayoutBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target43394     fn deref_mut(&mut self) -> &mut Self::Target {
43395         &mut self.inner
43396     }
43397 }
43398 impl<'a> AttachmentReferenceStencilLayoutBuilder<'a> {
43399     #[inline]
stencil_layout(mut self, stencil_layout: ImageLayout) -> Self43400     pub fn stencil_layout(mut self, stencil_layout: ImageLayout) -> Self {
43401         self.inner.stencil_layout = stencil_layout;
43402         self
43403     }
43404     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43405     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43406     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AttachmentReferenceStencilLayout43407     pub fn build(self) -> AttachmentReferenceStencilLayout {
43408         self.inner
43409     }
43410 }
43411 #[repr(C)]
43412 #[cfg_attr(feature = "debug", derive(Debug))]
43413 #[derive(Copy, Clone)]
43414 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT.html>"]
43415 pub struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
43416     pub s_type: StructureType,
43417     pub p_next: *mut c_void,
43418     pub primitive_topology_list_restart: Bool32,
43419     pub primitive_topology_patch_list_restart: Bool32,
43420 }
43421 impl ::std::default::Default for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
43422     #[inline]
default() -> Self43423     fn default() -> Self {
43424         Self {
43425             s_type: Self::STRUCTURE_TYPE,
43426             p_next: ::std::ptr::null_mut(),
43427             primitive_topology_list_restart: Bool32::default(),
43428             primitive_topology_patch_list_restart: Bool32::default(),
43429         }
43430     }
43431 }
43432 unsafe impl TaggedStructure for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
43433     const STRUCTURE_TYPE: StructureType =
43434         StructureType::PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
43435 }
43436 impl PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
builder<'a>() -> PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a>43437     pub fn builder<'a>() -> PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> {
43438         PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder {
43439             inner: Self::default(),
43440             marker: ::std::marker::PhantomData,
43441         }
43442     }
43443 }
43444 #[repr(transparent)]
43445 pub struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> {
43446     inner: PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT,
43447     marker: ::std::marker::PhantomData<&'a ()>,
43448 }
43449 unsafe impl ExtendsPhysicalDeviceFeatures2
43450     for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'_>
43451 {
43452 }
43453 unsafe impl ExtendsPhysicalDeviceFeatures2
43454     for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT
43455 {
43456 }
43457 unsafe impl ExtendsDeviceCreateInfo
43458     for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'_>
43459 {
43460 }
43461 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {}
43462 impl<'a> ::std::ops::Deref for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> {
43463     type Target = PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT;
deref(&self) -> &Self::Target43464     fn deref(&self) -> &Self::Target {
43465         &self.inner
43466     }
43467 }
43468 impl<'a> ::std::ops::DerefMut for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target43469     fn deref_mut(&mut self) -> &mut Self::Target {
43470         &mut self.inner
43471     }
43472 }
43473 impl<'a> PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> {
43474     #[inline]
primitive_topology_list_restart( mut self, primitive_topology_list_restart: bool, ) -> Self43475     pub fn primitive_topology_list_restart(
43476         mut self,
43477         primitive_topology_list_restart: bool,
43478     ) -> Self {
43479         self.inner.primitive_topology_list_restart = primitive_topology_list_restart.into();
43480         self
43481     }
43482     #[inline]
primitive_topology_patch_list_restart( mut self, primitive_topology_patch_list_restart: bool, ) -> Self43483     pub fn primitive_topology_patch_list_restart(
43484         mut self,
43485         primitive_topology_patch_list_restart: bool,
43486     ) -> Self {
43487         self.inner.primitive_topology_patch_list_restart =
43488             primitive_topology_patch_list_restart.into();
43489         self
43490     }
43491     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43492     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43493     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT43494     pub fn build(self) -> PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
43495         self.inner
43496     }
43497 }
43498 #[repr(C)]
43499 #[cfg_attr(feature = "debug", derive(Debug))]
43500 #[derive(Copy, Clone)]
43501 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentDescriptionStencilLayout.html>"]
43502 pub struct AttachmentDescriptionStencilLayout {
43503     pub s_type: StructureType,
43504     pub p_next: *mut c_void,
43505     pub stencil_initial_layout: ImageLayout,
43506     pub stencil_final_layout: ImageLayout,
43507 }
43508 impl ::std::default::Default for AttachmentDescriptionStencilLayout {
43509     #[inline]
default() -> Self43510     fn default() -> Self {
43511         Self {
43512             s_type: Self::STRUCTURE_TYPE,
43513             p_next: ::std::ptr::null_mut(),
43514             stencil_initial_layout: ImageLayout::default(),
43515             stencil_final_layout: ImageLayout::default(),
43516         }
43517     }
43518 }
43519 unsafe impl TaggedStructure for AttachmentDescriptionStencilLayout {
43520     const STRUCTURE_TYPE: StructureType = StructureType::ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT;
43521 }
43522 impl AttachmentDescriptionStencilLayout {
builder<'a>() -> AttachmentDescriptionStencilLayoutBuilder<'a>43523     pub fn builder<'a>() -> AttachmentDescriptionStencilLayoutBuilder<'a> {
43524         AttachmentDescriptionStencilLayoutBuilder {
43525             inner: Self::default(),
43526             marker: ::std::marker::PhantomData,
43527         }
43528     }
43529 }
43530 #[repr(transparent)]
43531 pub struct AttachmentDescriptionStencilLayoutBuilder<'a> {
43532     inner: AttachmentDescriptionStencilLayout,
43533     marker: ::std::marker::PhantomData<&'a ()>,
43534 }
43535 unsafe impl ExtendsAttachmentDescription2 for AttachmentDescriptionStencilLayoutBuilder<'_> {}
43536 unsafe impl ExtendsAttachmentDescription2 for AttachmentDescriptionStencilLayout {}
43537 impl<'a> ::std::ops::Deref for AttachmentDescriptionStencilLayoutBuilder<'a> {
43538     type Target = AttachmentDescriptionStencilLayout;
deref(&self) -> &Self::Target43539     fn deref(&self) -> &Self::Target {
43540         &self.inner
43541     }
43542 }
43543 impl<'a> ::std::ops::DerefMut for AttachmentDescriptionStencilLayoutBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target43544     fn deref_mut(&mut self) -> &mut Self::Target {
43545         &mut self.inner
43546     }
43547 }
43548 impl<'a> AttachmentDescriptionStencilLayoutBuilder<'a> {
43549     #[inline]
stencil_initial_layout(mut self, stencil_initial_layout: ImageLayout) -> Self43550     pub fn stencil_initial_layout(mut self, stencil_initial_layout: ImageLayout) -> Self {
43551         self.inner.stencil_initial_layout = stencil_initial_layout;
43552         self
43553     }
43554     #[inline]
stencil_final_layout(mut self, stencil_final_layout: ImageLayout) -> Self43555     pub fn stencil_final_layout(mut self, stencil_final_layout: ImageLayout) -> Self {
43556         self.inner.stencil_final_layout = stencil_final_layout;
43557         self
43558     }
43559     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43560     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43561     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AttachmentDescriptionStencilLayout43562     pub fn build(self) -> AttachmentDescriptionStencilLayout {
43563         self.inner
43564     }
43565 }
43566 #[repr(C)]
43567 #[cfg_attr(feature = "debug", derive(Debug))]
43568 #[derive(Copy, Clone)]
43569 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR.html>"]
43570 pub struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
43571     pub s_type: StructureType,
43572     pub p_next: *mut c_void,
43573     pub pipeline_executable_info: Bool32,
43574 }
43575 impl ::std::default::Default for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
43576     #[inline]
default() -> Self43577     fn default() -> Self {
43578         Self {
43579             s_type: Self::STRUCTURE_TYPE,
43580             p_next: ::std::ptr::null_mut(),
43581             pipeline_executable_info: Bool32::default(),
43582         }
43583     }
43584 }
43585 unsafe impl TaggedStructure for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
43586     const STRUCTURE_TYPE: StructureType =
43587         StructureType::PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
43588 }
43589 impl PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
builder<'a>() -> PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a>43590     pub fn builder<'a>() -> PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
43591         PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder {
43592             inner: Self::default(),
43593             marker: ::std::marker::PhantomData,
43594         }
43595     }
43596 }
43597 #[repr(transparent)]
43598 pub struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
43599     inner: PhysicalDevicePipelineExecutablePropertiesFeaturesKHR,
43600     marker: ::std::marker::PhantomData<&'a ()>,
43601 }
43602 unsafe impl ExtendsPhysicalDeviceFeatures2
43603     for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'_>
43604 {
43605 }
43606 unsafe impl ExtendsPhysicalDeviceFeatures2
43607     for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR
43608 {
43609 }
43610 unsafe impl ExtendsDeviceCreateInfo
43611     for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'_>
43612 {
43613 }
43614 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {}
43615 impl<'a> ::std::ops::Deref for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
43616     type Target = PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
deref(&self) -> &Self::Target43617     fn deref(&self) -> &Self::Target {
43618         &self.inner
43619     }
43620 }
43621 impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target43622     fn deref_mut(&mut self) -> &mut Self::Target {
43623         &mut self.inner
43624     }
43625 }
43626 impl<'a> PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
43627     #[inline]
pipeline_executable_info(mut self, pipeline_executable_info: bool) -> Self43628     pub fn pipeline_executable_info(mut self, pipeline_executable_info: bool) -> Self {
43629         self.inner.pipeline_executable_info = pipeline_executable_info.into();
43630         self
43631     }
43632     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43633     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43634     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePipelineExecutablePropertiesFeaturesKHR43635     pub fn build(self) -> PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
43636         self.inner
43637     }
43638 }
43639 #[repr(C)]
43640 #[cfg_attr(feature = "debug", derive(Debug))]
43641 #[derive(Copy, Clone)]
43642 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineInfoKHR.html>"]
43643 pub struct PipelineInfoKHR {
43644     pub s_type: StructureType,
43645     pub p_next: *const c_void,
43646     pub pipeline: Pipeline,
43647 }
43648 impl ::std::default::Default for PipelineInfoKHR {
43649     #[inline]
default() -> Self43650     fn default() -> Self {
43651         Self {
43652             s_type: Self::STRUCTURE_TYPE,
43653             p_next: ::std::ptr::null(),
43654             pipeline: Pipeline::default(),
43655         }
43656     }
43657 }
43658 unsafe impl TaggedStructure for PipelineInfoKHR {
43659     const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_INFO_KHR;
43660 }
43661 impl PipelineInfoKHR {
builder<'a>() -> PipelineInfoKHRBuilder<'a>43662     pub fn builder<'a>() -> PipelineInfoKHRBuilder<'a> {
43663         PipelineInfoKHRBuilder {
43664             inner: Self::default(),
43665             marker: ::std::marker::PhantomData,
43666         }
43667     }
43668 }
43669 #[repr(transparent)]
43670 pub struct PipelineInfoKHRBuilder<'a> {
43671     inner: PipelineInfoKHR,
43672     marker: ::std::marker::PhantomData<&'a ()>,
43673 }
43674 impl<'a> ::std::ops::Deref for PipelineInfoKHRBuilder<'a> {
43675     type Target = PipelineInfoKHR;
deref(&self) -> &Self::Target43676     fn deref(&self) -> &Self::Target {
43677         &self.inner
43678     }
43679 }
43680 impl<'a> ::std::ops::DerefMut for PipelineInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target43681     fn deref_mut(&mut self) -> &mut Self::Target {
43682         &mut self.inner
43683     }
43684 }
43685 impl<'a> PipelineInfoKHRBuilder<'a> {
43686     #[inline]
pipeline(mut self, pipeline: Pipeline) -> Self43687     pub fn pipeline(mut self, pipeline: Pipeline) -> Self {
43688         self.inner.pipeline = pipeline;
43689         self
43690     }
43691     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43692     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43693     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineInfoKHR43694     pub fn build(self) -> PipelineInfoKHR {
43695         self.inner
43696     }
43697 }
43698 #[repr(C)]
43699 #[derive(Copy, Clone)]
43700 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineExecutablePropertiesKHR.html>"]
43701 pub struct PipelineExecutablePropertiesKHR {
43702     pub s_type: StructureType,
43703     pub p_next: *mut c_void,
43704     pub stages: ShaderStageFlags,
43705     pub name: [c_char; MAX_DESCRIPTION_SIZE],
43706     pub description: [c_char; MAX_DESCRIPTION_SIZE],
43707     pub subgroup_size: u32,
43708 }
43709 #[cfg(feature = "debug")]
43710 impl fmt::Debug for PipelineExecutablePropertiesKHR {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result43711     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
43712         fmt.debug_struct("PipelineExecutablePropertiesKHR")
43713             .field("s_type", &self.s_type)
43714             .field("p_next", &self.p_next)
43715             .field("stages", &self.stages)
43716             .field("name", &unsafe {
43717                 ::std::ffi::CStr::from_ptr(self.name.as_ptr())
43718             })
43719             .field("description", &unsafe {
43720                 ::std::ffi::CStr::from_ptr(self.description.as_ptr())
43721             })
43722             .field("subgroup_size", &self.subgroup_size)
43723             .finish()
43724     }
43725 }
43726 impl ::std::default::Default for PipelineExecutablePropertiesKHR {
43727     #[inline]
default() -> Self43728     fn default() -> Self {
43729         Self {
43730             s_type: Self::STRUCTURE_TYPE,
43731             p_next: ::std::ptr::null_mut(),
43732             stages: ShaderStageFlags::default(),
43733             name: unsafe { ::std::mem::zeroed() },
43734             description: unsafe { ::std::mem::zeroed() },
43735             subgroup_size: u32::default(),
43736         }
43737     }
43738 }
43739 unsafe impl TaggedStructure for PipelineExecutablePropertiesKHR {
43740     const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_EXECUTABLE_PROPERTIES_KHR;
43741 }
43742 impl PipelineExecutablePropertiesKHR {
builder<'a>() -> PipelineExecutablePropertiesKHRBuilder<'a>43743     pub fn builder<'a>() -> PipelineExecutablePropertiesKHRBuilder<'a> {
43744         PipelineExecutablePropertiesKHRBuilder {
43745             inner: Self::default(),
43746             marker: ::std::marker::PhantomData,
43747         }
43748     }
43749 }
43750 #[repr(transparent)]
43751 pub struct PipelineExecutablePropertiesKHRBuilder<'a> {
43752     inner: PipelineExecutablePropertiesKHR,
43753     marker: ::std::marker::PhantomData<&'a ()>,
43754 }
43755 impl<'a> ::std::ops::Deref for PipelineExecutablePropertiesKHRBuilder<'a> {
43756     type Target = PipelineExecutablePropertiesKHR;
deref(&self) -> &Self::Target43757     fn deref(&self) -> &Self::Target {
43758         &self.inner
43759     }
43760 }
43761 impl<'a> ::std::ops::DerefMut for PipelineExecutablePropertiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target43762     fn deref_mut(&mut self) -> &mut Self::Target {
43763         &mut self.inner
43764     }
43765 }
43766 impl<'a> PipelineExecutablePropertiesKHRBuilder<'a> {
43767     #[inline]
stages(mut self, stages: ShaderStageFlags) -> Self43768     pub fn stages(mut self, stages: ShaderStageFlags) -> Self {
43769         self.inner.stages = stages;
43770         self
43771     }
43772     #[inline]
name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self43773     pub fn name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
43774         self.inner.name = name;
43775         self
43776     }
43777     #[inline]
description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self43778     pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
43779         self.inner.description = description;
43780         self
43781     }
43782     #[inline]
subgroup_size(mut self, subgroup_size: u32) -> Self43783     pub fn subgroup_size(mut self, subgroup_size: u32) -> Self {
43784         self.inner.subgroup_size = subgroup_size;
43785         self
43786     }
43787     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43788     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43789     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineExecutablePropertiesKHR43790     pub fn build(self) -> PipelineExecutablePropertiesKHR {
43791         self.inner
43792     }
43793 }
43794 #[repr(C)]
43795 #[cfg_attr(feature = "debug", derive(Debug))]
43796 #[derive(Copy, Clone)]
43797 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineExecutableInfoKHR.html>"]
43798 pub struct PipelineExecutableInfoKHR {
43799     pub s_type: StructureType,
43800     pub p_next: *const c_void,
43801     pub pipeline: Pipeline,
43802     pub executable_index: u32,
43803 }
43804 impl ::std::default::Default for PipelineExecutableInfoKHR {
43805     #[inline]
default() -> Self43806     fn default() -> Self {
43807         Self {
43808             s_type: Self::STRUCTURE_TYPE,
43809             p_next: ::std::ptr::null(),
43810             pipeline: Pipeline::default(),
43811             executable_index: u32::default(),
43812         }
43813     }
43814 }
43815 unsafe impl TaggedStructure for PipelineExecutableInfoKHR {
43816     const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_EXECUTABLE_INFO_KHR;
43817 }
43818 impl PipelineExecutableInfoKHR {
builder<'a>() -> PipelineExecutableInfoKHRBuilder<'a>43819     pub fn builder<'a>() -> PipelineExecutableInfoKHRBuilder<'a> {
43820         PipelineExecutableInfoKHRBuilder {
43821             inner: Self::default(),
43822             marker: ::std::marker::PhantomData,
43823         }
43824     }
43825 }
43826 #[repr(transparent)]
43827 pub struct PipelineExecutableInfoKHRBuilder<'a> {
43828     inner: PipelineExecutableInfoKHR,
43829     marker: ::std::marker::PhantomData<&'a ()>,
43830 }
43831 impl<'a> ::std::ops::Deref for PipelineExecutableInfoKHRBuilder<'a> {
43832     type Target = PipelineExecutableInfoKHR;
deref(&self) -> &Self::Target43833     fn deref(&self) -> &Self::Target {
43834         &self.inner
43835     }
43836 }
43837 impl<'a> ::std::ops::DerefMut for PipelineExecutableInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target43838     fn deref_mut(&mut self) -> &mut Self::Target {
43839         &mut self.inner
43840     }
43841 }
43842 impl<'a> PipelineExecutableInfoKHRBuilder<'a> {
43843     #[inline]
pipeline(mut self, pipeline: Pipeline) -> Self43844     pub fn pipeline(mut self, pipeline: Pipeline) -> Self {
43845         self.inner.pipeline = pipeline;
43846         self
43847     }
43848     #[inline]
executable_index(mut self, executable_index: u32) -> Self43849     pub fn executable_index(mut self, executable_index: u32) -> Self {
43850         self.inner.executable_index = executable_index;
43851         self
43852     }
43853     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43854     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43855     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineExecutableInfoKHR43856     pub fn build(self) -> PipelineExecutableInfoKHR {
43857         self.inner
43858     }
43859 }
43860 #[repr(C)]
43861 #[derive(Copy, Clone)]
43862 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineExecutableStatisticValueKHR.html>"]
43863 pub union PipelineExecutableStatisticValueKHR {
43864     pub b32: Bool32,
43865     pub i64: i64,
43866     pub u64: u64,
43867     pub f64: f64,
43868 }
43869 impl ::std::default::Default for PipelineExecutableStatisticValueKHR {
43870     #[inline]
default() -> Self43871     fn default() -> Self {
43872         unsafe { ::std::mem::zeroed() }
43873     }
43874 }
43875 #[repr(C)]
43876 #[derive(Copy, Clone)]
43877 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineExecutableStatisticKHR.html>"]
43878 pub struct PipelineExecutableStatisticKHR {
43879     pub s_type: StructureType,
43880     pub p_next: *mut c_void,
43881     pub name: [c_char; MAX_DESCRIPTION_SIZE],
43882     pub description: [c_char; MAX_DESCRIPTION_SIZE],
43883     pub format: PipelineExecutableStatisticFormatKHR,
43884     pub value: PipelineExecutableStatisticValueKHR,
43885 }
43886 #[cfg(feature = "debug")]
43887 impl fmt::Debug for PipelineExecutableStatisticKHR {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result43888     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
43889         fmt.debug_struct("PipelineExecutableStatisticKHR")
43890             .field("s_type", &self.s_type)
43891             .field("p_next", &self.p_next)
43892             .field("name", &unsafe {
43893                 ::std::ffi::CStr::from_ptr(self.name.as_ptr())
43894             })
43895             .field("description", &unsafe {
43896                 ::std::ffi::CStr::from_ptr(self.description.as_ptr())
43897             })
43898             .field("format", &self.format)
43899             .field("value", &"union")
43900             .finish()
43901     }
43902 }
43903 impl ::std::default::Default for PipelineExecutableStatisticKHR {
43904     #[inline]
default() -> Self43905     fn default() -> Self {
43906         Self {
43907             s_type: Self::STRUCTURE_TYPE,
43908             p_next: ::std::ptr::null_mut(),
43909             name: unsafe { ::std::mem::zeroed() },
43910             description: unsafe { ::std::mem::zeroed() },
43911             format: PipelineExecutableStatisticFormatKHR::default(),
43912             value: PipelineExecutableStatisticValueKHR::default(),
43913         }
43914     }
43915 }
43916 unsafe impl TaggedStructure for PipelineExecutableStatisticKHR {
43917     const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_EXECUTABLE_STATISTIC_KHR;
43918 }
43919 impl PipelineExecutableStatisticKHR {
builder<'a>() -> PipelineExecutableStatisticKHRBuilder<'a>43920     pub fn builder<'a>() -> PipelineExecutableStatisticKHRBuilder<'a> {
43921         PipelineExecutableStatisticKHRBuilder {
43922             inner: Self::default(),
43923             marker: ::std::marker::PhantomData,
43924         }
43925     }
43926 }
43927 #[repr(transparent)]
43928 pub struct PipelineExecutableStatisticKHRBuilder<'a> {
43929     inner: PipelineExecutableStatisticKHR,
43930     marker: ::std::marker::PhantomData<&'a ()>,
43931 }
43932 impl<'a> ::std::ops::Deref for PipelineExecutableStatisticKHRBuilder<'a> {
43933     type Target = PipelineExecutableStatisticKHR;
deref(&self) -> &Self::Target43934     fn deref(&self) -> &Self::Target {
43935         &self.inner
43936     }
43937 }
43938 impl<'a> ::std::ops::DerefMut for PipelineExecutableStatisticKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target43939     fn deref_mut(&mut self) -> &mut Self::Target {
43940         &mut self.inner
43941     }
43942 }
43943 impl<'a> PipelineExecutableStatisticKHRBuilder<'a> {
43944     #[inline]
name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self43945     pub fn name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
43946         self.inner.name = name;
43947         self
43948     }
43949     #[inline]
description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self43950     pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
43951         self.inner.description = description;
43952         self
43953     }
43954     #[inline]
format(mut self, format: PipelineExecutableStatisticFormatKHR) -> Self43955     pub fn format(mut self, format: PipelineExecutableStatisticFormatKHR) -> Self {
43956         self.inner.format = format;
43957         self
43958     }
43959     #[inline]
value(mut self, value: PipelineExecutableStatisticValueKHR) -> Self43960     pub fn value(mut self, value: PipelineExecutableStatisticValueKHR) -> Self {
43961         self.inner.value = value;
43962         self
43963     }
43964     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43965     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43966     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineExecutableStatisticKHR43967     pub fn build(self) -> PipelineExecutableStatisticKHR {
43968         self.inner
43969     }
43970 }
43971 #[repr(C)]
43972 #[derive(Copy, Clone)]
43973 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineExecutableInternalRepresentationKHR.html>"]
43974 pub struct PipelineExecutableInternalRepresentationKHR {
43975     pub s_type: StructureType,
43976     pub p_next: *mut c_void,
43977     pub name: [c_char; MAX_DESCRIPTION_SIZE],
43978     pub description: [c_char; MAX_DESCRIPTION_SIZE],
43979     pub is_text: Bool32,
43980     pub data_size: usize,
43981     pub p_data: *mut c_void,
43982 }
43983 #[cfg(feature = "debug")]
43984 impl fmt::Debug for PipelineExecutableInternalRepresentationKHR {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result43985     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
43986         fmt.debug_struct("PipelineExecutableInternalRepresentationKHR")
43987             .field("s_type", &self.s_type)
43988             .field("p_next", &self.p_next)
43989             .field("name", &unsafe {
43990                 ::std::ffi::CStr::from_ptr(self.name.as_ptr())
43991             })
43992             .field("description", &unsafe {
43993                 ::std::ffi::CStr::from_ptr(self.description.as_ptr())
43994             })
43995             .field("is_text", &self.is_text)
43996             .field("data_size", &self.data_size)
43997             .field("p_data", &self.p_data)
43998             .finish()
43999     }
44000 }
44001 impl ::std::default::Default for PipelineExecutableInternalRepresentationKHR {
44002     #[inline]
default() -> Self44003     fn default() -> Self {
44004         Self {
44005             s_type: Self::STRUCTURE_TYPE,
44006             p_next: ::std::ptr::null_mut(),
44007             name: unsafe { ::std::mem::zeroed() },
44008             description: unsafe { ::std::mem::zeroed() },
44009             is_text: Bool32::default(),
44010             data_size: usize::default(),
44011             p_data: ::std::ptr::null_mut(),
44012         }
44013     }
44014 }
44015 unsafe impl TaggedStructure for PipelineExecutableInternalRepresentationKHR {
44016     const STRUCTURE_TYPE: StructureType =
44017         StructureType::PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR;
44018 }
44019 impl PipelineExecutableInternalRepresentationKHR {
builder<'a>() -> PipelineExecutableInternalRepresentationKHRBuilder<'a>44020     pub fn builder<'a>() -> PipelineExecutableInternalRepresentationKHRBuilder<'a> {
44021         PipelineExecutableInternalRepresentationKHRBuilder {
44022             inner: Self::default(),
44023             marker: ::std::marker::PhantomData,
44024         }
44025     }
44026 }
44027 #[repr(transparent)]
44028 pub struct PipelineExecutableInternalRepresentationKHRBuilder<'a> {
44029     inner: PipelineExecutableInternalRepresentationKHR,
44030     marker: ::std::marker::PhantomData<&'a ()>,
44031 }
44032 impl<'a> ::std::ops::Deref for PipelineExecutableInternalRepresentationKHRBuilder<'a> {
44033     type Target = PipelineExecutableInternalRepresentationKHR;
deref(&self) -> &Self::Target44034     fn deref(&self) -> &Self::Target {
44035         &self.inner
44036     }
44037 }
44038 impl<'a> ::std::ops::DerefMut for PipelineExecutableInternalRepresentationKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target44039     fn deref_mut(&mut self) -> &mut Self::Target {
44040         &mut self.inner
44041     }
44042 }
44043 impl<'a> PipelineExecutableInternalRepresentationKHRBuilder<'a> {
44044     #[inline]
name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self44045     pub fn name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
44046         self.inner.name = name;
44047         self
44048     }
44049     #[inline]
description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self44050     pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
44051         self.inner.description = description;
44052         self
44053     }
44054     #[inline]
is_text(mut self, is_text: bool) -> Self44055     pub fn is_text(mut self, is_text: bool) -> Self {
44056         self.inner.is_text = is_text.into();
44057         self
44058     }
44059     #[inline]
data(mut self, data: &'a mut [u8]) -> Self44060     pub fn data(mut self, data: &'a mut [u8]) -> Self {
44061         self.inner.data_size = data.len();
44062         self.inner.p_data = data.as_mut_ptr().cast();
44063         self
44064     }
44065     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44066     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44067     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineExecutableInternalRepresentationKHR44068     pub fn build(self) -> PipelineExecutableInternalRepresentationKHR {
44069         self.inner
44070     }
44071 }
44072 #[repr(C)]
44073 #[cfg_attr(feature = "debug", derive(Debug))]
44074 #[derive(Copy, Clone)]
44075 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures.html>"]
44076 pub struct PhysicalDeviceShaderDemoteToHelperInvocationFeatures {
44077     pub s_type: StructureType,
44078     pub p_next: *mut c_void,
44079     pub shader_demote_to_helper_invocation: Bool32,
44080 }
44081 impl ::std::default::Default for PhysicalDeviceShaderDemoteToHelperInvocationFeatures {
44082     #[inline]
default() -> Self44083     fn default() -> Self {
44084         Self {
44085             s_type: Self::STRUCTURE_TYPE,
44086             p_next: ::std::ptr::null_mut(),
44087             shader_demote_to_helper_invocation: Bool32::default(),
44088         }
44089     }
44090 }
44091 unsafe impl TaggedStructure for PhysicalDeviceShaderDemoteToHelperInvocationFeatures {
44092     const STRUCTURE_TYPE: StructureType =
44093         StructureType::PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
44094 }
44095 impl PhysicalDeviceShaderDemoteToHelperInvocationFeatures {
builder<'a>() -> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a>44096     pub fn builder<'a>() -> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> {
44097         PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder {
44098             inner: Self::default(),
44099             marker: ::std::marker::PhantomData,
44100         }
44101     }
44102 }
44103 #[repr(transparent)]
44104 pub struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> {
44105     inner: PhysicalDeviceShaderDemoteToHelperInvocationFeatures,
44106     marker: ::std::marker::PhantomData<&'a ()>,
44107 }
44108 unsafe impl ExtendsPhysicalDeviceFeatures2
44109     for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'_>
44110 {
44111 }
44112 unsafe impl ExtendsPhysicalDeviceFeatures2
44113     for PhysicalDeviceShaderDemoteToHelperInvocationFeatures
44114 {
44115 }
44116 unsafe impl ExtendsDeviceCreateInfo
44117     for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'_>
44118 {
44119 }
44120 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDemoteToHelperInvocationFeatures {}
44121 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> {
44122     type Target = PhysicalDeviceShaderDemoteToHelperInvocationFeatures;
deref(&self) -> &Self::Target44123     fn deref(&self) -> &Self::Target {
44124         &self.inner
44125     }
44126 }
44127 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target44128     fn deref_mut(&mut self) -> &mut Self::Target {
44129         &mut self.inner
44130     }
44131 }
44132 impl<'a> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> {
44133     #[inline]
shader_demote_to_helper_invocation( mut self, shader_demote_to_helper_invocation: bool, ) -> Self44134     pub fn shader_demote_to_helper_invocation(
44135         mut self,
44136         shader_demote_to_helper_invocation: bool,
44137     ) -> Self {
44138         self.inner.shader_demote_to_helper_invocation = shader_demote_to_helper_invocation.into();
44139         self
44140     }
44141     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44142     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44143     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderDemoteToHelperInvocationFeatures44144     pub fn build(self) -> PhysicalDeviceShaderDemoteToHelperInvocationFeatures {
44145         self.inner
44146     }
44147 }
44148 #[repr(C)]
44149 #[cfg_attr(feature = "debug", derive(Debug))]
44150 #[derive(Copy, Clone)]
44151 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT.html>"]
44152 pub struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
44153     pub s_type: StructureType,
44154     pub p_next: *mut c_void,
44155     pub texel_buffer_alignment: Bool32,
44156 }
44157 impl ::std::default::Default for PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
44158     #[inline]
default() -> Self44159     fn default() -> Self {
44160         Self {
44161             s_type: Self::STRUCTURE_TYPE,
44162             p_next: ::std::ptr::null_mut(),
44163             texel_buffer_alignment: Bool32::default(),
44164         }
44165     }
44166 }
44167 unsafe impl TaggedStructure for PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
44168     const STRUCTURE_TYPE: StructureType =
44169         StructureType::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
44170 }
44171 impl PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
builder<'a>() -> PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a>44172     pub fn builder<'a>() -> PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
44173         PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder {
44174             inner: Self::default(),
44175             marker: ::std::marker::PhantomData,
44176         }
44177     }
44178 }
44179 #[repr(transparent)]
44180 pub struct PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
44181     inner: PhysicalDeviceTexelBufferAlignmentFeaturesEXT,
44182     marker: ::std::marker::PhantomData<&'a ()>,
44183 }
44184 unsafe impl ExtendsPhysicalDeviceFeatures2
44185     for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'_>
44186 {
44187 }
44188 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTexelBufferAlignmentFeaturesEXT {}
44189 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'_> {}
44190 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTexelBufferAlignmentFeaturesEXT {}
44191 impl<'a> ::std::ops::Deref for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
44192     type Target = PhysicalDeviceTexelBufferAlignmentFeaturesEXT;
deref(&self) -> &Self::Target44193     fn deref(&self) -> &Self::Target {
44194         &self.inner
44195     }
44196 }
44197 impl<'a> ::std::ops::DerefMut for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target44198     fn deref_mut(&mut self) -> &mut Self::Target {
44199         &mut self.inner
44200     }
44201 }
44202 impl<'a> PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
44203     #[inline]
texel_buffer_alignment(mut self, texel_buffer_alignment: bool) -> Self44204     pub fn texel_buffer_alignment(mut self, texel_buffer_alignment: bool) -> Self {
44205         self.inner.texel_buffer_alignment = texel_buffer_alignment.into();
44206         self
44207     }
44208     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44209     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44210     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceTexelBufferAlignmentFeaturesEXT44211     pub fn build(self) -> PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
44212         self.inner
44213     }
44214 }
44215 #[repr(C)]
44216 #[cfg_attr(feature = "debug", derive(Debug))]
44217 #[derive(Copy, Clone)]
44218 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTexelBufferAlignmentProperties.html>"]
44219 pub struct PhysicalDeviceTexelBufferAlignmentProperties {
44220     pub s_type: StructureType,
44221     pub p_next: *mut c_void,
44222     pub storage_texel_buffer_offset_alignment_bytes: DeviceSize,
44223     pub storage_texel_buffer_offset_single_texel_alignment: Bool32,
44224     pub uniform_texel_buffer_offset_alignment_bytes: DeviceSize,
44225     pub uniform_texel_buffer_offset_single_texel_alignment: Bool32,
44226 }
44227 impl ::std::default::Default for PhysicalDeviceTexelBufferAlignmentProperties {
44228     #[inline]
default() -> Self44229     fn default() -> Self {
44230         Self {
44231             s_type: Self::STRUCTURE_TYPE,
44232             p_next: ::std::ptr::null_mut(),
44233             storage_texel_buffer_offset_alignment_bytes: DeviceSize::default(),
44234             storage_texel_buffer_offset_single_texel_alignment: Bool32::default(),
44235             uniform_texel_buffer_offset_alignment_bytes: DeviceSize::default(),
44236             uniform_texel_buffer_offset_single_texel_alignment: Bool32::default(),
44237         }
44238     }
44239 }
44240 unsafe impl TaggedStructure for PhysicalDeviceTexelBufferAlignmentProperties {
44241     const STRUCTURE_TYPE: StructureType =
44242         StructureType::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
44243 }
44244 impl PhysicalDeviceTexelBufferAlignmentProperties {
builder<'a>() -> PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a>44245     pub fn builder<'a>() -> PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> {
44246         PhysicalDeviceTexelBufferAlignmentPropertiesBuilder {
44247             inner: Self::default(),
44248             marker: ::std::marker::PhantomData,
44249         }
44250     }
44251 }
44252 #[repr(transparent)]
44253 pub struct PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> {
44254     inner: PhysicalDeviceTexelBufferAlignmentProperties,
44255     marker: ::std::marker::PhantomData<&'a ()>,
44256 }
44257 unsafe impl ExtendsPhysicalDeviceProperties2
44258     for PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'_>
44259 {
44260 }
44261 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTexelBufferAlignmentProperties {}
44262 impl<'a> ::std::ops::Deref for PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> {
44263     type Target = PhysicalDeviceTexelBufferAlignmentProperties;
deref(&self) -> &Self::Target44264     fn deref(&self) -> &Self::Target {
44265         &self.inner
44266     }
44267 }
44268 impl<'a> ::std::ops::DerefMut for PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target44269     fn deref_mut(&mut self) -> &mut Self::Target {
44270         &mut self.inner
44271     }
44272 }
44273 impl<'a> PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> {
44274     #[inline]
storage_texel_buffer_offset_alignment_bytes( mut self, storage_texel_buffer_offset_alignment_bytes: DeviceSize, ) -> Self44275     pub fn storage_texel_buffer_offset_alignment_bytes(
44276         mut self,
44277         storage_texel_buffer_offset_alignment_bytes: DeviceSize,
44278     ) -> Self {
44279         self.inner.storage_texel_buffer_offset_alignment_bytes =
44280             storage_texel_buffer_offset_alignment_bytes;
44281         self
44282     }
44283     #[inline]
storage_texel_buffer_offset_single_texel_alignment( mut self, storage_texel_buffer_offset_single_texel_alignment: bool, ) -> Self44284     pub fn storage_texel_buffer_offset_single_texel_alignment(
44285         mut self,
44286         storage_texel_buffer_offset_single_texel_alignment: bool,
44287     ) -> Self {
44288         self.inner
44289             .storage_texel_buffer_offset_single_texel_alignment =
44290             storage_texel_buffer_offset_single_texel_alignment.into();
44291         self
44292     }
44293     #[inline]
uniform_texel_buffer_offset_alignment_bytes( mut self, uniform_texel_buffer_offset_alignment_bytes: DeviceSize, ) -> Self44294     pub fn uniform_texel_buffer_offset_alignment_bytes(
44295         mut self,
44296         uniform_texel_buffer_offset_alignment_bytes: DeviceSize,
44297     ) -> Self {
44298         self.inner.uniform_texel_buffer_offset_alignment_bytes =
44299             uniform_texel_buffer_offset_alignment_bytes;
44300         self
44301     }
44302     #[inline]
uniform_texel_buffer_offset_single_texel_alignment( mut self, uniform_texel_buffer_offset_single_texel_alignment: bool, ) -> Self44303     pub fn uniform_texel_buffer_offset_single_texel_alignment(
44304         mut self,
44305         uniform_texel_buffer_offset_single_texel_alignment: bool,
44306     ) -> Self {
44307         self.inner
44308             .uniform_texel_buffer_offset_single_texel_alignment =
44309             uniform_texel_buffer_offset_single_texel_alignment.into();
44310         self
44311     }
44312     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44313     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44314     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceTexelBufferAlignmentProperties44315     pub fn build(self) -> PhysicalDeviceTexelBufferAlignmentProperties {
44316         self.inner
44317     }
44318 }
44319 #[repr(C)]
44320 #[cfg_attr(feature = "debug", derive(Debug))]
44321 #[derive(Copy, Clone)]
44322 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSubgroupSizeControlFeatures.html>"]
44323 pub struct PhysicalDeviceSubgroupSizeControlFeatures {
44324     pub s_type: StructureType,
44325     pub p_next: *mut c_void,
44326     pub subgroup_size_control: Bool32,
44327     pub compute_full_subgroups: Bool32,
44328 }
44329 impl ::std::default::Default for PhysicalDeviceSubgroupSizeControlFeatures {
44330     #[inline]
default() -> Self44331     fn default() -> Self {
44332         Self {
44333             s_type: Self::STRUCTURE_TYPE,
44334             p_next: ::std::ptr::null_mut(),
44335             subgroup_size_control: Bool32::default(),
44336             compute_full_subgroups: Bool32::default(),
44337         }
44338     }
44339 }
44340 unsafe impl TaggedStructure for PhysicalDeviceSubgroupSizeControlFeatures {
44341     const STRUCTURE_TYPE: StructureType =
44342         StructureType::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
44343 }
44344 impl PhysicalDeviceSubgroupSizeControlFeatures {
builder<'a>() -> PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a>44345     pub fn builder<'a>() -> PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> {
44346         PhysicalDeviceSubgroupSizeControlFeaturesBuilder {
44347             inner: Self::default(),
44348             marker: ::std::marker::PhantomData,
44349         }
44350     }
44351 }
44352 #[repr(transparent)]
44353 pub struct PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> {
44354     inner: PhysicalDeviceSubgroupSizeControlFeatures,
44355     marker: ::std::marker::PhantomData<&'a ()>,
44356 }
44357 unsafe impl ExtendsPhysicalDeviceFeatures2
44358     for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'_>
44359 {
44360 }
44361 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSubgroupSizeControlFeatures {}
44362 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'_> {}
44363 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubgroupSizeControlFeatures {}
44364 impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> {
44365     type Target = PhysicalDeviceSubgroupSizeControlFeatures;
deref(&self) -> &Self::Target44366     fn deref(&self) -> &Self::Target {
44367         &self.inner
44368     }
44369 }
44370 impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target44371     fn deref_mut(&mut self) -> &mut Self::Target {
44372         &mut self.inner
44373     }
44374 }
44375 impl<'a> PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> {
44376     #[inline]
subgroup_size_control(mut self, subgroup_size_control: bool) -> Self44377     pub fn subgroup_size_control(mut self, subgroup_size_control: bool) -> Self {
44378         self.inner.subgroup_size_control = subgroup_size_control.into();
44379         self
44380     }
44381     #[inline]
compute_full_subgroups(mut self, compute_full_subgroups: bool) -> Self44382     pub fn compute_full_subgroups(mut self, compute_full_subgroups: bool) -> Self {
44383         self.inner.compute_full_subgroups = compute_full_subgroups.into();
44384         self
44385     }
44386     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44387     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44388     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceSubgroupSizeControlFeatures44389     pub fn build(self) -> PhysicalDeviceSubgroupSizeControlFeatures {
44390         self.inner
44391     }
44392 }
44393 #[repr(C)]
44394 #[cfg_attr(feature = "debug", derive(Debug))]
44395 #[derive(Copy, Clone)]
44396 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSubgroupSizeControlProperties.html>"]
44397 pub struct PhysicalDeviceSubgroupSizeControlProperties {
44398     pub s_type: StructureType,
44399     pub p_next: *mut c_void,
44400     pub min_subgroup_size: u32,
44401     pub max_subgroup_size: u32,
44402     pub max_compute_workgroup_subgroups: u32,
44403     pub required_subgroup_size_stages: ShaderStageFlags,
44404 }
44405 impl ::std::default::Default for PhysicalDeviceSubgroupSizeControlProperties {
44406     #[inline]
default() -> Self44407     fn default() -> Self {
44408         Self {
44409             s_type: Self::STRUCTURE_TYPE,
44410             p_next: ::std::ptr::null_mut(),
44411             min_subgroup_size: u32::default(),
44412             max_subgroup_size: u32::default(),
44413             max_compute_workgroup_subgroups: u32::default(),
44414             required_subgroup_size_stages: ShaderStageFlags::default(),
44415         }
44416     }
44417 }
44418 unsafe impl TaggedStructure for PhysicalDeviceSubgroupSizeControlProperties {
44419     const STRUCTURE_TYPE: StructureType =
44420         StructureType::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
44421 }
44422 impl PhysicalDeviceSubgroupSizeControlProperties {
builder<'a>() -> PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a>44423     pub fn builder<'a>() -> PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> {
44424         PhysicalDeviceSubgroupSizeControlPropertiesBuilder {
44425             inner: Self::default(),
44426             marker: ::std::marker::PhantomData,
44427         }
44428     }
44429 }
44430 #[repr(transparent)]
44431 pub struct PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> {
44432     inner: PhysicalDeviceSubgroupSizeControlProperties,
44433     marker: ::std::marker::PhantomData<&'a ()>,
44434 }
44435 unsafe impl ExtendsPhysicalDeviceProperties2
44436     for PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'_>
44437 {
44438 }
44439 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupSizeControlProperties {}
44440 impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> {
44441     type Target = PhysicalDeviceSubgroupSizeControlProperties;
deref(&self) -> &Self::Target44442     fn deref(&self) -> &Self::Target {
44443         &self.inner
44444     }
44445 }
44446 impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target44447     fn deref_mut(&mut self) -> &mut Self::Target {
44448         &mut self.inner
44449     }
44450 }
44451 impl<'a> PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> {
44452     #[inline]
min_subgroup_size(mut self, min_subgroup_size: u32) -> Self44453     pub fn min_subgroup_size(mut self, min_subgroup_size: u32) -> Self {
44454         self.inner.min_subgroup_size = min_subgroup_size;
44455         self
44456     }
44457     #[inline]
max_subgroup_size(mut self, max_subgroup_size: u32) -> Self44458     pub fn max_subgroup_size(mut self, max_subgroup_size: u32) -> Self {
44459         self.inner.max_subgroup_size = max_subgroup_size;
44460         self
44461     }
44462     #[inline]
max_compute_workgroup_subgroups(mut self, max_compute_workgroup_subgroups: u32) -> Self44463     pub fn max_compute_workgroup_subgroups(mut self, max_compute_workgroup_subgroups: u32) -> Self {
44464         self.inner.max_compute_workgroup_subgroups = max_compute_workgroup_subgroups;
44465         self
44466     }
44467     #[inline]
required_subgroup_size_stages( mut self, required_subgroup_size_stages: ShaderStageFlags, ) -> Self44468     pub fn required_subgroup_size_stages(
44469         mut self,
44470         required_subgroup_size_stages: ShaderStageFlags,
44471     ) -> Self {
44472         self.inner.required_subgroup_size_stages = required_subgroup_size_stages;
44473         self
44474     }
44475     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44476     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44477     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceSubgroupSizeControlProperties44478     pub fn build(self) -> PhysicalDeviceSubgroupSizeControlProperties {
44479         self.inner
44480     }
44481 }
44482 #[repr(C)]
44483 #[cfg_attr(feature = "debug", derive(Debug))]
44484 #[derive(Copy, Clone)]
44485 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineShaderStageRequiredSubgroupSizeCreateInfo.html>"]
44486 pub struct PipelineShaderStageRequiredSubgroupSizeCreateInfo {
44487     pub s_type: StructureType,
44488     pub p_next: *mut c_void,
44489     pub required_subgroup_size: u32,
44490 }
44491 impl ::std::default::Default for PipelineShaderStageRequiredSubgroupSizeCreateInfo {
44492     #[inline]
default() -> Self44493     fn default() -> Self {
44494         Self {
44495             s_type: Self::STRUCTURE_TYPE,
44496             p_next: ::std::ptr::null_mut(),
44497             required_subgroup_size: u32::default(),
44498         }
44499     }
44500 }
44501 unsafe impl TaggedStructure for PipelineShaderStageRequiredSubgroupSizeCreateInfo {
44502     const STRUCTURE_TYPE: StructureType =
44503         StructureType::PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
44504 }
44505 impl PipelineShaderStageRequiredSubgroupSizeCreateInfo {
builder<'a>() -> PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a>44506     pub fn builder<'a>() -> PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> {
44507         PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder {
44508             inner: Self::default(),
44509             marker: ::std::marker::PhantomData,
44510         }
44511     }
44512 }
44513 #[repr(transparent)]
44514 pub struct PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> {
44515     inner: PipelineShaderStageRequiredSubgroupSizeCreateInfo,
44516     marker: ::std::marker::PhantomData<&'a ()>,
44517 }
44518 unsafe impl ExtendsPipelineShaderStageCreateInfo
44519     for PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'_>
44520 {
44521 }
44522 unsafe impl ExtendsPipelineShaderStageCreateInfo
44523     for PipelineShaderStageRequiredSubgroupSizeCreateInfo
44524 {
44525 }
44526 unsafe impl ExtendsShaderCreateInfoEXT
44527     for PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'_>
44528 {
44529 }
44530 unsafe impl ExtendsShaderCreateInfoEXT for PipelineShaderStageRequiredSubgroupSizeCreateInfo {}
44531 impl<'a> ::std::ops::Deref for PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> {
44532     type Target = PipelineShaderStageRequiredSubgroupSizeCreateInfo;
deref(&self) -> &Self::Target44533     fn deref(&self) -> &Self::Target {
44534         &self.inner
44535     }
44536 }
44537 impl<'a> ::std::ops::DerefMut for PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target44538     fn deref_mut(&mut self) -> &mut Self::Target {
44539         &mut self.inner
44540     }
44541 }
44542 impl<'a> PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> {
44543     #[inline]
required_subgroup_size(mut self, required_subgroup_size: u32) -> Self44544     pub fn required_subgroup_size(mut self, required_subgroup_size: u32) -> Self {
44545         self.inner.required_subgroup_size = required_subgroup_size;
44546         self
44547     }
44548     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44549     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44550     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineShaderStageRequiredSubgroupSizeCreateInfo44551     pub fn build(self) -> PipelineShaderStageRequiredSubgroupSizeCreateInfo {
44552         self.inner
44553     }
44554 }
44555 #[repr(C)]
44556 #[cfg_attr(feature = "debug", derive(Debug))]
44557 #[derive(Copy, Clone)]
44558 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassShadingPipelineCreateInfoHUAWEI.html>"]
44559 pub struct SubpassShadingPipelineCreateInfoHUAWEI {
44560     pub s_type: StructureType,
44561     pub p_next: *mut c_void,
44562     pub render_pass: RenderPass,
44563     pub subpass: u32,
44564 }
44565 impl ::std::default::Default for SubpassShadingPipelineCreateInfoHUAWEI {
44566     #[inline]
default() -> Self44567     fn default() -> Self {
44568         Self {
44569             s_type: Self::STRUCTURE_TYPE,
44570             p_next: ::std::ptr::null_mut(),
44571             render_pass: RenderPass::default(),
44572             subpass: u32::default(),
44573         }
44574     }
44575 }
44576 unsafe impl TaggedStructure for SubpassShadingPipelineCreateInfoHUAWEI {
44577     const STRUCTURE_TYPE: StructureType =
44578         StructureType::SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI;
44579 }
44580 impl SubpassShadingPipelineCreateInfoHUAWEI {
builder<'a>() -> SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a>44581     pub fn builder<'a>() -> SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> {
44582         SubpassShadingPipelineCreateInfoHUAWEIBuilder {
44583             inner: Self::default(),
44584             marker: ::std::marker::PhantomData,
44585         }
44586     }
44587 }
44588 #[repr(transparent)]
44589 pub struct SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> {
44590     inner: SubpassShadingPipelineCreateInfoHUAWEI,
44591     marker: ::std::marker::PhantomData<&'a ()>,
44592 }
44593 unsafe impl ExtendsComputePipelineCreateInfo for SubpassShadingPipelineCreateInfoHUAWEIBuilder<'_> {}
44594 unsafe impl ExtendsComputePipelineCreateInfo for SubpassShadingPipelineCreateInfoHUAWEI {}
44595 impl<'a> ::std::ops::Deref for SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> {
44596     type Target = SubpassShadingPipelineCreateInfoHUAWEI;
deref(&self) -> &Self::Target44597     fn deref(&self) -> &Self::Target {
44598         &self.inner
44599     }
44600 }
44601 impl<'a> ::std::ops::DerefMut for SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target44602     fn deref_mut(&mut self) -> &mut Self::Target {
44603         &mut self.inner
44604     }
44605 }
44606 impl<'a> SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> {
44607     #[inline]
render_pass(mut self, render_pass: RenderPass) -> Self44608     pub fn render_pass(mut self, render_pass: RenderPass) -> Self {
44609         self.inner.render_pass = render_pass;
44610         self
44611     }
44612     #[inline]
subpass(mut self, subpass: u32) -> Self44613     pub fn subpass(mut self, subpass: u32) -> Self {
44614         self.inner.subpass = subpass;
44615         self
44616     }
44617     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44618     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44619     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SubpassShadingPipelineCreateInfoHUAWEI44620     pub fn build(self) -> SubpassShadingPipelineCreateInfoHUAWEI {
44621         self.inner
44622     }
44623 }
44624 #[repr(C)]
44625 #[cfg_attr(feature = "debug", derive(Debug))]
44626 #[derive(Copy, Clone)]
44627 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSubpassShadingPropertiesHUAWEI.html>"]
44628 pub struct PhysicalDeviceSubpassShadingPropertiesHUAWEI {
44629     pub s_type: StructureType,
44630     pub p_next: *mut c_void,
44631     pub max_subpass_shading_workgroup_size_aspect_ratio: u32,
44632 }
44633 impl ::std::default::Default for PhysicalDeviceSubpassShadingPropertiesHUAWEI {
44634     #[inline]
default() -> Self44635     fn default() -> Self {
44636         Self {
44637             s_type: Self::STRUCTURE_TYPE,
44638             p_next: ::std::ptr::null_mut(),
44639             max_subpass_shading_workgroup_size_aspect_ratio: u32::default(),
44640         }
44641     }
44642 }
44643 unsafe impl TaggedStructure for PhysicalDeviceSubpassShadingPropertiesHUAWEI {
44644     const STRUCTURE_TYPE: StructureType =
44645         StructureType::PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI;
44646 }
44647 impl PhysicalDeviceSubpassShadingPropertiesHUAWEI {
builder<'a>() -> PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a>44648     pub fn builder<'a>() -> PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> {
44649         PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder {
44650             inner: Self::default(),
44651             marker: ::std::marker::PhantomData,
44652         }
44653     }
44654 }
44655 #[repr(transparent)]
44656 pub struct PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> {
44657     inner: PhysicalDeviceSubpassShadingPropertiesHUAWEI,
44658     marker: ::std::marker::PhantomData<&'a ()>,
44659 }
44660 unsafe impl ExtendsPhysicalDeviceProperties2
44661     for PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'_>
44662 {
44663 }
44664 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubpassShadingPropertiesHUAWEI {}
44665 impl<'a> ::std::ops::Deref for PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> {
44666     type Target = PhysicalDeviceSubpassShadingPropertiesHUAWEI;
deref(&self) -> &Self::Target44667     fn deref(&self) -> &Self::Target {
44668         &self.inner
44669     }
44670 }
44671 impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target44672     fn deref_mut(&mut self) -> &mut Self::Target {
44673         &mut self.inner
44674     }
44675 }
44676 impl<'a> PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> {
44677     #[inline]
max_subpass_shading_workgroup_size_aspect_ratio( mut self, max_subpass_shading_workgroup_size_aspect_ratio: u32, ) -> Self44678     pub fn max_subpass_shading_workgroup_size_aspect_ratio(
44679         mut self,
44680         max_subpass_shading_workgroup_size_aspect_ratio: u32,
44681     ) -> Self {
44682         self.inner.max_subpass_shading_workgroup_size_aspect_ratio =
44683             max_subpass_shading_workgroup_size_aspect_ratio;
44684         self
44685     }
44686     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44687     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44688     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceSubpassShadingPropertiesHUAWEI44689     pub fn build(self) -> PhysicalDeviceSubpassShadingPropertiesHUAWEI {
44690         self.inner
44691     }
44692 }
44693 #[repr(C)]
44694 #[cfg_attr(feature = "debug", derive(Debug))]
44695 #[derive(Copy, Clone)]
44696 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI.html>"]
44697 pub struct PhysicalDeviceClusterCullingShaderPropertiesHUAWEI {
44698     pub s_type: StructureType,
44699     pub p_next: *mut c_void,
44700     pub max_work_group_count: [u32; 3],
44701     pub max_work_group_size: [u32; 3],
44702     pub max_output_cluster_count: u32,
44703     pub indirect_buffer_offset_alignment: DeviceSize,
44704 }
44705 impl ::std::default::Default for PhysicalDeviceClusterCullingShaderPropertiesHUAWEI {
44706     #[inline]
default() -> Self44707     fn default() -> Self {
44708         Self {
44709             s_type: Self::STRUCTURE_TYPE,
44710             p_next: ::std::ptr::null_mut(),
44711             max_work_group_count: unsafe { ::std::mem::zeroed() },
44712             max_work_group_size: unsafe { ::std::mem::zeroed() },
44713             max_output_cluster_count: u32::default(),
44714             indirect_buffer_offset_alignment: DeviceSize::default(),
44715         }
44716     }
44717 }
44718 unsafe impl TaggedStructure for PhysicalDeviceClusterCullingShaderPropertiesHUAWEI {
44719     const STRUCTURE_TYPE: StructureType =
44720         StructureType::PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI;
44721 }
44722 impl PhysicalDeviceClusterCullingShaderPropertiesHUAWEI {
builder<'a>() -> PhysicalDeviceClusterCullingShaderPropertiesHUAWEIBuilder<'a>44723     pub fn builder<'a>() -> PhysicalDeviceClusterCullingShaderPropertiesHUAWEIBuilder<'a> {
44724         PhysicalDeviceClusterCullingShaderPropertiesHUAWEIBuilder {
44725             inner: Self::default(),
44726             marker: ::std::marker::PhantomData,
44727         }
44728     }
44729 }
44730 #[repr(transparent)]
44731 pub struct PhysicalDeviceClusterCullingShaderPropertiesHUAWEIBuilder<'a> {
44732     inner: PhysicalDeviceClusterCullingShaderPropertiesHUAWEI,
44733     marker: ::std::marker::PhantomData<&'a ()>,
44734 }
44735 unsafe impl ExtendsPhysicalDeviceProperties2
44736     for PhysicalDeviceClusterCullingShaderPropertiesHUAWEIBuilder<'_>
44737 {
44738 }
44739 unsafe impl ExtendsPhysicalDeviceProperties2
44740     for PhysicalDeviceClusterCullingShaderPropertiesHUAWEI
44741 {
44742 }
44743 impl<'a> ::std::ops::Deref for PhysicalDeviceClusterCullingShaderPropertiesHUAWEIBuilder<'a> {
44744     type Target = PhysicalDeviceClusterCullingShaderPropertiesHUAWEI;
deref(&self) -> &Self::Target44745     fn deref(&self) -> &Self::Target {
44746         &self.inner
44747     }
44748 }
44749 impl<'a> ::std::ops::DerefMut for PhysicalDeviceClusterCullingShaderPropertiesHUAWEIBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target44750     fn deref_mut(&mut self) -> &mut Self::Target {
44751         &mut self.inner
44752     }
44753 }
44754 impl<'a> PhysicalDeviceClusterCullingShaderPropertiesHUAWEIBuilder<'a> {
44755     #[inline]
max_work_group_count(mut self, max_work_group_count: [u32; 3]) -> Self44756     pub fn max_work_group_count(mut self, max_work_group_count: [u32; 3]) -> Self {
44757         self.inner.max_work_group_count = max_work_group_count;
44758         self
44759     }
44760     #[inline]
max_work_group_size(mut self, max_work_group_size: [u32; 3]) -> Self44761     pub fn max_work_group_size(mut self, max_work_group_size: [u32; 3]) -> Self {
44762         self.inner.max_work_group_size = max_work_group_size;
44763         self
44764     }
44765     #[inline]
max_output_cluster_count(mut self, max_output_cluster_count: u32) -> Self44766     pub fn max_output_cluster_count(mut self, max_output_cluster_count: u32) -> Self {
44767         self.inner.max_output_cluster_count = max_output_cluster_count;
44768         self
44769     }
44770     #[inline]
indirect_buffer_offset_alignment( mut self, indirect_buffer_offset_alignment: DeviceSize, ) -> Self44771     pub fn indirect_buffer_offset_alignment(
44772         mut self,
44773         indirect_buffer_offset_alignment: DeviceSize,
44774     ) -> Self {
44775         self.inner.indirect_buffer_offset_alignment = indirect_buffer_offset_alignment;
44776         self
44777     }
44778     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44779     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44780     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceClusterCullingShaderPropertiesHUAWEI44781     pub fn build(self) -> PhysicalDeviceClusterCullingShaderPropertiesHUAWEI {
44782         self.inner
44783     }
44784 }
44785 #[repr(C)]
44786 #[cfg_attr(feature = "debug", derive(Debug))]
44787 #[derive(Copy, Clone)]
44788 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryOpaqueCaptureAddressAllocateInfo.html>"]
44789 pub struct MemoryOpaqueCaptureAddressAllocateInfo {
44790     pub s_type: StructureType,
44791     pub p_next: *const c_void,
44792     pub opaque_capture_address: u64,
44793 }
44794 impl ::std::default::Default for MemoryOpaqueCaptureAddressAllocateInfo {
44795     #[inline]
default() -> Self44796     fn default() -> Self {
44797         Self {
44798             s_type: Self::STRUCTURE_TYPE,
44799             p_next: ::std::ptr::null(),
44800             opaque_capture_address: u64::default(),
44801         }
44802     }
44803 }
44804 unsafe impl TaggedStructure for MemoryOpaqueCaptureAddressAllocateInfo {
44805     const STRUCTURE_TYPE: StructureType =
44806         StructureType::MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO;
44807 }
44808 impl MemoryOpaqueCaptureAddressAllocateInfo {
builder<'a>() -> MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a>44809     pub fn builder<'a>() -> MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
44810         MemoryOpaqueCaptureAddressAllocateInfoBuilder {
44811             inner: Self::default(),
44812             marker: ::std::marker::PhantomData,
44813         }
44814     }
44815 }
44816 #[repr(transparent)]
44817 pub struct MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
44818     inner: MemoryOpaqueCaptureAddressAllocateInfo,
44819     marker: ::std::marker::PhantomData<&'a ()>,
44820 }
44821 unsafe impl ExtendsMemoryAllocateInfo for MemoryOpaqueCaptureAddressAllocateInfoBuilder<'_> {}
44822 unsafe impl ExtendsMemoryAllocateInfo for MemoryOpaqueCaptureAddressAllocateInfo {}
44823 impl<'a> ::std::ops::Deref for MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
44824     type Target = MemoryOpaqueCaptureAddressAllocateInfo;
deref(&self) -> &Self::Target44825     fn deref(&self) -> &Self::Target {
44826         &self.inner
44827     }
44828 }
44829 impl<'a> ::std::ops::DerefMut for MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target44830     fn deref_mut(&mut self) -> &mut Self::Target {
44831         &mut self.inner
44832     }
44833 }
44834 impl<'a> MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
44835     #[inline]
opaque_capture_address(mut self, opaque_capture_address: u64) -> Self44836     pub fn opaque_capture_address(mut self, opaque_capture_address: u64) -> Self {
44837         self.inner.opaque_capture_address = opaque_capture_address;
44838         self
44839     }
44840     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44841     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44842     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryOpaqueCaptureAddressAllocateInfo44843     pub fn build(self) -> MemoryOpaqueCaptureAddressAllocateInfo {
44844         self.inner
44845     }
44846 }
44847 #[repr(C)]
44848 #[cfg_attr(feature = "debug", derive(Debug))]
44849 #[derive(Copy, Clone)]
44850 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceMemoryOpaqueCaptureAddressInfo.html>"]
44851 pub struct DeviceMemoryOpaqueCaptureAddressInfo {
44852     pub s_type: StructureType,
44853     pub p_next: *const c_void,
44854     pub memory: DeviceMemory,
44855 }
44856 impl ::std::default::Default for DeviceMemoryOpaqueCaptureAddressInfo {
44857     #[inline]
default() -> Self44858     fn default() -> Self {
44859         Self {
44860             s_type: Self::STRUCTURE_TYPE,
44861             p_next: ::std::ptr::null(),
44862             memory: DeviceMemory::default(),
44863         }
44864     }
44865 }
44866 unsafe impl TaggedStructure for DeviceMemoryOpaqueCaptureAddressInfo {
44867     const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO;
44868 }
44869 impl DeviceMemoryOpaqueCaptureAddressInfo {
builder<'a>() -> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a>44870     pub fn builder<'a>() -> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
44871         DeviceMemoryOpaqueCaptureAddressInfoBuilder {
44872             inner: Self::default(),
44873             marker: ::std::marker::PhantomData,
44874         }
44875     }
44876 }
44877 #[repr(transparent)]
44878 pub struct DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
44879     inner: DeviceMemoryOpaqueCaptureAddressInfo,
44880     marker: ::std::marker::PhantomData<&'a ()>,
44881 }
44882 impl<'a> ::std::ops::Deref for DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
44883     type Target = DeviceMemoryOpaqueCaptureAddressInfo;
deref(&self) -> &Self::Target44884     fn deref(&self) -> &Self::Target {
44885         &self.inner
44886     }
44887 }
44888 impl<'a> ::std::ops::DerefMut for DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target44889     fn deref_mut(&mut self) -> &mut Self::Target {
44890         &mut self.inner
44891     }
44892 }
44893 impl<'a> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
44894     #[inline]
memory(mut self, memory: DeviceMemory) -> Self44895     pub fn memory(mut self, memory: DeviceMemory) -> Self {
44896         self.inner.memory = memory;
44897         self
44898     }
44899     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44900     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44901     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceMemoryOpaqueCaptureAddressInfo44902     pub fn build(self) -> DeviceMemoryOpaqueCaptureAddressInfo {
44903         self.inner
44904     }
44905 }
44906 #[repr(C)]
44907 #[cfg_attr(feature = "debug", derive(Debug))]
44908 #[derive(Copy, Clone)]
44909 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceLineRasterizationFeaturesEXT.html>"]
44910 pub struct PhysicalDeviceLineRasterizationFeaturesEXT {
44911     pub s_type: StructureType,
44912     pub p_next: *mut c_void,
44913     pub rectangular_lines: Bool32,
44914     pub bresenham_lines: Bool32,
44915     pub smooth_lines: Bool32,
44916     pub stippled_rectangular_lines: Bool32,
44917     pub stippled_bresenham_lines: Bool32,
44918     pub stippled_smooth_lines: Bool32,
44919 }
44920 impl ::std::default::Default for PhysicalDeviceLineRasterizationFeaturesEXT {
44921     #[inline]
default() -> Self44922     fn default() -> Self {
44923         Self {
44924             s_type: Self::STRUCTURE_TYPE,
44925             p_next: ::std::ptr::null_mut(),
44926             rectangular_lines: Bool32::default(),
44927             bresenham_lines: Bool32::default(),
44928             smooth_lines: Bool32::default(),
44929             stippled_rectangular_lines: Bool32::default(),
44930             stippled_bresenham_lines: Bool32::default(),
44931             stippled_smooth_lines: Bool32::default(),
44932         }
44933     }
44934 }
44935 unsafe impl TaggedStructure for PhysicalDeviceLineRasterizationFeaturesEXT {
44936     const STRUCTURE_TYPE: StructureType =
44937         StructureType::PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT;
44938 }
44939 impl PhysicalDeviceLineRasterizationFeaturesEXT {
builder<'a>() -> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a>44940     pub fn builder<'a>() -> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
44941         PhysicalDeviceLineRasterizationFeaturesEXTBuilder {
44942             inner: Self::default(),
44943             marker: ::std::marker::PhantomData,
44944         }
44945     }
44946 }
44947 #[repr(transparent)]
44948 pub struct PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
44949     inner: PhysicalDeviceLineRasterizationFeaturesEXT,
44950     marker: ::std::marker::PhantomData<&'a ()>,
44951 }
44952 unsafe impl ExtendsPhysicalDeviceFeatures2
44953     for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'_>
44954 {
44955 }
44956 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLineRasterizationFeaturesEXT {}
44957 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'_> {}
44958 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLineRasterizationFeaturesEXT {}
44959 impl<'a> ::std::ops::Deref for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
44960     type Target = PhysicalDeviceLineRasterizationFeaturesEXT;
deref(&self) -> &Self::Target44961     fn deref(&self) -> &Self::Target {
44962         &self.inner
44963     }
44964 }
44965 impl<'a> ::std::ops::DerefMut for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target44966     fn deref_mut(&mut self) -> &mut Self::Target {
44967         &mut self.inner
44968     }
44969 }
44970 impl<'a> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
44971     #[inline]
rectangular_lines(mut self, rectangular_lines: bool) -> Self44972     pub fn rectangular_lines(mut self, rectangular_lines: bool) -> Self {
44973         self.inner.rectangular_lines = rectangular_lines.into();
44974         self
44975     }
44976     #[inline]
bresenham_lines(mut self, bresenham_lines: bool) -> Self44977     pub fn bresenham_lines(mut self, bresenham_lines: bool) -> Self {
44978         self.inner.bresenham_lines = bresenham_lines.into();
44979         self
44980     }
44981     #[inline]
smooth_lines(mut self, smooth_lines: bool) -> Self44982     pub fn smooth_lines(mut self, smooth_lines: bool) -> Self {
44983         self.inner.smooth_lines = smooth_lines.into();
44984         self
44985     }
44986     #[inline]
stippled_rectangular_lines(mut self, stippled_rectangular_lines: bool) -> Self44987     pub fn stippled_rectangular_lines(mut self, stippled_rectangular_lines: bool) -> Self {
44988         self.inner.stippled_rectangular_lines = stippled_rectangular_lines.into();
44989         self
44990     }
44991     #[inline]
stippled_bresenham_lines(mut self, stippled_bresenham_lines: bool) -> Self44992     pub fn stippled_bresenham_lines(mut self, stippled_bresenham_lines: bool) -> Self {
44993         self.inner.stippled_bresenham_lines = stippled_bresenham_lines.into();
44994         self
44995     }
44996     #[inline]
stippled_smooth_lines(mut self, stippled_smooth_lines: bool) -> Self44997     pub fn stippled_smooth_lines(mut self, stippled_smooth_lines: bool) -> Self {
44998         self.inner.stippled_smooth_lines = stippled_smooth_lines.into();
44999         self
45000     }
45001     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45002     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45003     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceLineRasterizationFeaturesEXT45004     pub fn build(self) -> PhysicalDeviceLineRasterizationFeaturesEXT {
45005         self.inner
45006     }
45007 }
45008 #[repr(C)]
45009 #[cfg_attr(feature = "debug", derive(Debug))]
45010 #[derive(Copy, Clone)]
45011 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceLineRasterizationPropertiesEXT.html>"]
45012 pub struct PhysicalDeviceLineRasterizationPropertiesEXT {
45013     pub s_type: StructureType,
45014     pub p_next: *mut c_void,
45015     pub line_sub_pixel_precision_bits: u32,
45016 }
45017 impl ::std::default::Default for PhysicalDeviceLineRasterizationPropertiesEXT {
45018     #[inline]
default() -> Self45019     fn default() -> Self {
45020         Self {
45021             s_type: Self::STRUCTURE_TYPE,
45022             p_next: ::std::ptr::null_mut(),
45023             line_sub_pixel_precision_bits: u32::default(),
45024         }
45025     }
45026 }
45027 unsafe impl TaggedStructure for PhysicalDeviceLineRasterizationPropertiesEXT {
45028     const STRUCTURE_TYPE: StructureType =
45029         StructureType::PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT;
45030 }
45031 impl PhysicalDeviceLineRasterizationPropertiesEXT {
builder<'a>() -> PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a>45032     pub fn builder<'a>() -> PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
45033         PhysicalDeviceLineRasterizationPropertiesEXTBuilder {
45034             inner: Self::default(),
45035             marker: ::std::marker::PhantomData,
45036         }
45037     }
45038 }
45039 #[repr(transparent)]
45040 pub struct PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
45041     inner: PhysicalDeviceLineRasterizationPropertiesEXT,
45042     marker: ::std::marker::PhantomData<&'a ()>,
45043 }
45044 unsafe impl ExtendsPhysicalDeviceProperties2
45045     for PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'_>
45046 {
45047 }
45048 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceLineRasterizationPropertiesEXT {}
45049 impl<'a> ::std::ops::Deref for PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
45050     type Target = PhysicalDeviceLineRasterizationPropertiesEXT;
deref(&self) -> &Self::Target45051     fn deref(&self) -> &Self::Target {
45052         &self.inner
45053     }
45054 }
45055 impl<'a> ::std::ops::DerefMut for PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target45056     fn deref_mut(&mut self) -> &mut Self::Target {
45057         &mut self.inner
45058     }
45059 }
45060 impl<'a> PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
45061     #[inline]
line_sub_pixel_precision_bits(mut self, line_sub_pixel_precision_bits: u32) -> Self45062     pub fn line_sub_pixel_precision_bits(mut self, line_sub_pixel_precision_bits: u32) -> Self {
45063         self.inner.line_sub_pixel_precision_bits = line_sub_pixel_precision_bits;
45064         self
45065     }
45066     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45067     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45068     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceLineRasterizationPropertiesEXT45069     pub fn build(self) -> PhysicalDeviceLineRasterizationPropertiesEXT {
45070         self.inner
45071     }
45072 }
45073 #[repr(C)]
45074 #[cfg_attr(feature = "debug", derive(Debug))]
45075 #[derive(Copy, Clone)]
45076 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationLineStateCreateInfoEXT.html>"]
45077 pub struct PipelineRasterizationLineStateCreateInfoEXT {
45078     pub s_type: StructureType,
45079     pub p_next: *const c_void,
45080     pub line_rasterization_mode: LineRasterizationModeEXT,
45081     pub stippled_line_enable: Bool32,
45082     pub line_stipple_factor: u32,
45083     pub line_stipple_pattern: u16,
45084 }
45085 impl ::std::default::Default for PipelineRasterizationLineStateCreateInfoEXT {
45086     #[inline]
default() -> Self45087     fn default() -> Self {
45088         Self {
45089             s_type: Self::STRUCTURE_TYPE,
45090             p_next: ::std::ptr::null(),
45091             line_rasterization_mode: LineRasterizationModeEXT::default(),
45092             stippled_line_enable: Bool32::default(),
45093             line_stipple_factor: u32::default(),
45094             line_stipple_pattern: u16::default(),
45095         }
45096     }
45097 }
45098 unsafe impl TaggedStructure for PipelineRasterizationLineStateCreateInfoEXT {
45099     const STRUCTURE_TYPE: StructureType =
45100         StructureType::PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT;
45101 }
45102 impl PipelineRasterizationLineStateCreateInfoEXT {
builder<'a>() -> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a>45103     pub fn builder<'a>() -> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
45104         PipelineRasterizationLineStateCreateInfoEXTBuilder {
45105             inner: Self::default(),
45106             marker: ::std::marker::PhantomData,
45107         }
45108     }
45109 }
45110 #[repr(transparent)]
45111 pub struct PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
45112     inner: PipelineRasterizationLineStateCreateInfoEXT,
45113     marker: ::std::marker::PhantomData<&'a ()>,
45114 }
45115 unsafe impl ExtendsPipelineRasterizationStateCreateInfo
45116     for PipelineRasterizationLineStateCreateInfoEXTBuilder<'_>
45117 {
45118 }
45119 unsafe impl ExtendsPipelineRasterizationStateCreateInfo
45120     for PipelineRasterizationLineStateCreateInfoEXT
45121 {
45122 }
45123 impl<'a> ::std::ops::Deref for PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
45124     type Target = PipelineRasterizationLineStateCreateInfoEXT;
deref(&self) -> &Self::Target45125     fn deref(&self) -> &Self::Target {
45126         &self.inner
45127     }
45128 }
45129 impl<'a> ::std::ops::DerefMut for PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target45130     fn deref_mut(&mut self) -> &mut Self::Target {
45131         &mut self.inner
45132     }
45133 }
45134 impl<'a> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
45135     #[inline]
line_rasterization_mode( mut self, line_rasterization_mode: LineRasterizationModeEXT, ) -> Self45136     pub fn line_rasterization_mode(
45137         mut self,
45138         line_rasterization_mode: LineRasterizationModeEXT,
45139     ) -> Self {
45140         self.inner.line_rasterization_mode = line_rasterization_mode;
45141         self
45142     }
45143     #[inline]
stippled_line_enable(mut self, stippled_line_enable: bool) -> Self45144     pub fn stippled_line_enable(mut self, stippled_line_enable: bool) -> Self {
45145         self.inner.stippled_line_enable = stippled_line_enable.into();
45146         self
45147     }
45148     #[inline]
line_stipple_factor(mut self, line_stipple_factor: u32) -> Self45149     pub fn line_stipple_factor(mut self, line_stipple_factor: u32) -> Self {
45150         self.inner.line_stipple_factor = line_stipple_factor;
45151         self
45152     }
45153     #[inline]
line_stipple_pattern(mut self, line_stipple_pattern: u16) -> Self45154     pub fn line_stipple_pattern(mut self, line_stipple_pattern: u16) -> Self {
45155         self.inner.line_stipple_pattern = line_stipple_pattern;
45156         self
45157     }
45158     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45159     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45160     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineRasterizationLineStateCreateInfoEXT45161     pub fn build(self) -> PipelineRasterizationLineStateCreateInfoEXT {
45162         self.inner
45163     }
45164 }
45165 #[repr(C)]
45166 #[cfg_attr(feature = "debug", derive(Debug))]
45167 #[derive(Copy, Clone)]
45168 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePipelineCreationCacheControlFeatures.html>"]
45169 pub struct PhysicalDevicePipelineCreationCacheControlFeatures {
45170     pub s_type: StructureType,
45171     pub p_next: *mut c_void,
45172     pub pipeline_creation_cache_control: Bool32,
45173 }
45174 impl ::std::default::Default for PhysicalDevicePipelineCreationCacheControlFeatures {
45175     #[inline]
default() -> Self45176     fn default() -> Self {
45177         Self {
45178             s_type: Self::STRUCTURE_TYPE,
45179             p_next: ::std::ptr::null_mut(),
45180             pipeline_creation_cache_control: Bool32::default(),
45181         }
45182     }
45183 }
45184 unsafe impl TaggedStructure for PhysicalDevicePipelineCreationCacheControlFeatures {
45185     const STRUCTURE_TYPE: StructureType =
45186         StructureType::PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
45187 }
45188 impl PhysicalDevicePipelineCreationCacheControlFeatures {
builder<'a>() -> PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a>45189     pub fn builder<'a>() -> PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> {
45190         PhysicalDevicePipelineCreationCacheControlFeaturesBuilder {
45191             inner: Self::default(),
45192             marker: ::std::marker::PhantomData,
45193         }
45194     }
45195 }
45196 #[repr(transparent)]
45197 pub struct PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> {
45198     inner: PhysicalDevicePipelineCreationCacheControlFeatures,
45199     marker: ::std::marker::PhantomData<&'a ()>,
45200 }
45201 unsafe impl ExtendsPhysicalDeviceFeatures2
45202     for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'_>
45203 {
45204 }
45205 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelineCreationCacheControlFeatures {}
45206 unsafe impl ExtendsDeviceCreateInfo
45207     for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'_>
45208 {
45209 }
45210 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineCreationCacheControlFeatures {}
45211 impl<'a> ::std::ops::Deref for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> {
45212     type Target = PhysicalDevicePipelineCreationCacheControlFeatures;
deref(&self) -> &Self::Target45213     fn deref(&self) -> &Self::Target {
45214         &self.inner
45215     }
45216 }
45217 impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target45218     fn deref_mut(&mut self) -> &mut Self::Target {
45219         &mut self.inner
45220     }
45221 }
45222 impl<'a> PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> {
45223     #[inline]
pipeline_creation_cache_control( mut self, pipeline_creation_cache_control: bool, ) -> Self45224     pub fn pipeline_creation_cache_control(
45225         mut self,
45226         pipeline_creation_cache_control: bool,
45227     ) -> Self {
45228         self.inner.pipeline_creation_cache_control = pipeline_creation_cache_control.into();
45229         self
45230     }
45231     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45232     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45233     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePipelineCreationCacheControlFeatures45234     pub fn build(self) -> PhysicalDevicePipelineCreationCacheControlFeatures {
45235         self.inner
45236     }
45237 }
45238 #[repr(C)]
45239 #[cfg_attr(feature = "debug", derive(Debug))]
45240 #[derive(Copy, Clone)]
45241 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkan11Features.html>"]
45242 pub struct PhysicalDeviceVulkan11Features {
45243     pub s_type: StructureType,
45244     pub p_next: *mut c_void,
45245     pub storage_buffer16_bit_access: Bool32,
45246     pub uniform_and_storage_buffer16_bit_access: Bool32,
45247     pub storage_push_constant16: Bool32,
45248     pub storage_input_output16: Bool32,
45249     pub multiview: Bool32,
45250     pub multiview_geometry_shader: Bool32,
45251     pub multiview_tessellation_shader: Bool32,
45252     pub variable_pointers_storage_buffer: Bool32,
45253     pub variable_pointers: Bool32,
45254     pub protected_memory: Bool32,
45255     pub sampler_ycbcr_conversion: Bool32,
45256     pub shader_draw_parameters: Bool32,
45257 }
45258 impl ::std::default::Default for PhysicalDeviceVulkan11Features {
45259     #[inline]
default() -> Self45260     fn default() -> Self {
45261         Self {
45262             s_type: Self::STRUCTURE_TYPE,
45263             p_next: ::std::ptr::null_mut(),
45264             storage_buffer16_bit_access: Bool32::default(),
45265             uniform_and_storage_buffer16_bit_access: Bool32::default(),
45266             storage_push_constant16: Bool32::default(),
45267             storage_input_output16: Bool32::default(),
45268             multiview: Bool32::default(),
45269             multiview_geometry_shader: Bool32::default(),
45270             multiview_tessellation_shader: Bool32::default(),
45271             variable_pointers_storage_buffer: Bool32::default(),
45272             variable_pointers: Bool32::default(),
45273             protected_memory: Bool32::default(),
45274             sampler_ycbcr_conversion: Bool32::default(),
45275             shader_draw_parameters: Bool32::default(),
45276         }
45277     }
45278 }
45279 unsafe impl TaggedStructure for PhysicalDeviceVulkan11Features {
45280     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
45281 }
45282 impl PhysicalDeviceVulkan11Features {
builder<'a>() -> PhysicalDeviceVulkan11FeaturesBuilder<'a>45283     pub fn builder<'a>() -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
45284         PhysicalDeviceVulkan11FeaturesBuilder {
45285             inner: Self::default(),
45286             marker: ::std::marker::PhantomData,
45287         }
45288     }
45289 }
45290 #[repr(transparent)]
45291 pub struct PhysicalDeviceVulkan11FeaturesBuilder<'a> {
45292     inner: PhysicalDeviceVulkan11Features,
45293     marker: ::std::marker::PhantomData<&'a ()>,
45294 }
45295 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan11FeaturesBuilder<'_> {}
45296 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan11Features {}
45297 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan11FeaturesBuilder<'_> {}
45298 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan11Features {}
45299 impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan11FeaturesBuilder<'a> {
45300     type Target = PhysicalDeviceVulkan11Features;
deref(&self) -> &Self::Target45301     fn deref(&self) -> &Self::Target {
45302         &self.inner
45303     }
45304 }
45305 impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan11FeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target45306     fn deref_mut(&mut self) -> &mut Self::Target {
45307         &mut self.inner
45308     }
45309 }
45310 impl<'a> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
45311     #[inline]
storage_buffer16_bit_access(mut self, storage_buffer16_bit_access: bool) -> Self45312     pub fn storage_buffer16_bit_access(mut self, storage_buffer16_bit_access: bool) -> Self {
45313         self.inner.storage_buffer16_bit_access = storage_buffer16_bit_access.into();
45314         self
45315     }
45316     #[inline]
uniform_and_storage_buffer16_bit_access( mut self, uniform_and_storage_buffer16_bit_access: bool, ) -> Self45317     pub fn uniform_and_storage_buffer16_bit_access(
45318         mut self,
45319         uniform_and_storage_buffer16_bit_access: bool,
45320     ) -> Self {
45321         self.inner.uniform_and_storage_buffer16_bit_access =
45322             uniform_and_storage_buffer16_bit_access.into();
45323         self
45324     }
45325     #[inline]
storage_push_constant16(mut self, storage_push_constant16: bool) -> Self45326     pub fn storage_push_constant16(mut self, storage_push_constant16: bool) -> Self {
45327         self.inner.storage_push_constant16 = storage_push_constant16.into();
45328         self
45329     }
45330     #[inline]
storage_input_output16(mut self, storage_input_output16: bool) -> Self45331     pub fn storage_input_output16(mut self, storage_input_output16: bool) -> Self {
45332         self.inner.storage_input_output16 = storage_input_output16.into();
45333         self
45334     }
45335     #[inline]
multiview(mut self, multiview: bool) -> Self45336     pub fn multiview(mut self, multiview: bool) -> Self {
45337         self.inner.multiview = multiview.into();
45338         self
45339     }
45340     #[inline]
multiview_geometry_shader(mut self, multiview_geometry_shader: bool) -> Self45341     pub fn multiview_geometry_shader(mut self, multiview_geometry_shader: bool) -> Self {
45342         self.inner.multiview_geometry_shader = multiview_geometry_shader.into();
45343         self
45344     }
45345     #[inline]
multiview_tessellation_shader(mut self, multiview_tessellation_shader: bool) -> Self45346     pub fn multiview_tessellation_shader(mut self, multiview_tessellation_shader: bool) -> Self {
45347         self.inner.multiview_tessellation_shader = multiview_tessellation_shader.into();
45348         self
45349     }
45350     #[inline]
variable_pointers_storage_buffer( mut self, variable_pointers_storage_buffer: bool, ) -> Self45351     pub fn variable_pointers_storage_buffer(
45352         mut self,
45353         variable_pointers_storage_buffer: bool,
45354     ) -> Self {
45355         self.inner.variable_pointers_storage_buffer = variable_pointers_storage_buffer.into();
45356         self
45357     }
45358     #[inline]
variable_pointers(mut self, variable_pointers: bool) -> Self45359     pub fn variable_pointers(mut self, variable_pointers: bool) -> Self {
45360         self.inner.variable_pointers = variable_pointers.into();
45361         self
45362     }
45363     #[inline]
protected_memory(mut self, protected_memory: bool) -> Self45364     pub fn protected_memory(mut self, protected_memory: bool) -> Self {
45365         self.inner.protected_memory = protected_memory.into();
45366         self
45367     }
45368     #[inline]
sampler_ycbcr_conversion(mut self, sampler_ycbcr_conversion: bool) -> Self45369     pub fn sampler_ycbcr_conversion(mut self, sampler_ycbcr_conversion: bool) -> Self {
45370         self.inner.sampler_ycbcr_conversion = sampler_ycbcr_conversion.into();
45371         self
45372     }
45373     #[inline]
shader_draw_parameters(mut self, shader_draw_parameters: bool) -> Self45374     pub fn shader_draw_parameters(mut self, shader_draw_parameters: bool) -> Self {
45375         self.inner.shader_draw_parameters = shader_draw_parameters.into();
45376         self
45377     }
45378     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45379     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45380     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceVulkan11Features45381     pub fn build(self) -> PhysicalDeviceVulkan11Features {
45382         self.inner
45383     }
45384 }
45385 #[repr(C)]
45386 #[cfg_attr(feature = "debug", derive(Debug))]
45387 #[derive(Copy, Clone)]
45388 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkan11Properties.html>"]
45389 pub struct PhysicalDeviceVulkan11Properties {
45390     pub s_type: StructureType,
45391     pub p_next: *mut c_void,
45392     pub device_uuid: [u8; UUID_SIZE],
45393     pub driver_uuid: [u8; UUID_SIZE],
45394     pub device_luid: [u8; LUID_SIZE],
45395     pub device_node_mask: u32,
45396     pub device_luid_valid: Bool32,
45397     pub subgroup_size: u32,
45398     pub subgroup_supported_stages: ShaderStageFlags,
45399     pub subgroup_supported_operations: SubgroupFeatureFlags,
45400     pub subgroup_quad_operations_in_all_stages: Bool32,
45401     pub point_clipping_behavior: PointClippingBehavior,
45402     pub max_multiview_view_count: u32,
45403     pub max_multiview_instance_index: u32,
45404     pub protected_no_fault: Bool32,
45405     pub max_per_set_descriptors: u32,
45406     pub max_memory_allocation_size: DeviceSize,
45407 }
45408 impl ::std::default::Default for PhysicalDeviceVulkan11Properties {
45409     #[inline]
default() -> Self45410     fn default() -> Self {
45411         Self {
45412             s_type: Self::STRUCTURE_TYPE,
45413             p_next: ::std::ptr::null_mut(),
45414             device_uuid: unsafe { ::std::mem::zeroed() },
45415             driver_uuid: unsafe { ::std::mem::zeroed() },
45416             device_luid: unsafe { ::std::mem::zeroed() },
45417             device_node_mask: u32::default(),
45418             device_luid_valid: Bool32::default(),
45419             subgroup_size: u32::default(),
45420             subgroup_supported_stages: ShaderStageFlags::default(),
45421             subgroup_supported_operations: SubgroupFeatureFlags::default(),
45422             subgroup_quad_operations_in_all_stages: Bool32::default(),
45423             point_clipping_behavior: PointClippingBehavior::default(),
45424             max_multiview_view_count: u32::default(),
45425             max_multiview_instance_index: u32::default(),
45426             protected_no_fault: Bool32::default(),
45427             max_per_set_descriptors: u32::default(),
45428             max_memory_allocation_size: DeviceSize::default(),
45429         }
45430     }
45431 }
45432 unsafe impl TaggedStructure for PhysicalDeviceVulkan11Properties {
45433     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES;
45434 }
45435 impl PhysicalDeviceVulkan11Properties {
builder<'a>() -> PhysicalDeviceVulkan11PropertiesBuilder<'a>45436     pub fn builder<'a>() -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
45437         PhysicalDeviceVulkan11PropertiesBuilder {
45438             inner: Self::default(),
45439             marker: ::std::marker::PhantomData,
45440         }
45441     }
45442 }
45443 #[repr(transparent)]
45444 pub struct PhysicalDeviceVulkan11PropertiesBuilder<'a> {
45445     inner: PhysicalDeviceVulkan11Properties,
45446     marker: ::std::marker::PhantomData<&'a ()>,
45447 }
45448 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan11PropertiesBuilder<'_> {}
45449 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan11Properties {}
45450 impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan11PropertiesBuilder<'a> {
45451     type Target = PhysicalDeviceVulkan11Properties;
deref(&self) -> &Self::Target45452     fn deref(&self) -> &Self::Target {
45453         &self.inner
45454     }
45455 }
45456 impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan11PropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target45457     fn deref_mut(&mut self) -> &mut Self::Target {
45458         &mut self.inner
45459     }
45460 }
45461 impl<'a> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
45462     #[inline]
device_uuid(mut self, device_uuid: [u8; UUID_SIZE]) -> Self45463     pub fn device_uuid(mut self, device_uuid: [u8; UUID_SIZE]) -> Self {
45464         self.inner.device_uuid = device_uuid;
45465         self
45466     }
45467     #[inline]
driver_uuid(mut self, driver_uuid: [u8; UUID_SIZE]) -> Self45468     pub fn driver_uuid(mut self, driver_uuid: [u8; UUID_SIZE]) -> Self {
45469         self.inner.driver_uuid = driver_uuid;
45470         self
45471     }
45472     #[inline]
device_luid(mut self, device_luid: [u8; LUID_SIZE]) -> Self45473     pub fn device_luid(mut self, device_luid: [u8; LUID_SIZE]) -> Self {
45474         self.inner.device_luid = device_luid;
45475         self
45476     }
45477     #[inline]
device_node_mask(mut self, device_node_mask: u32) -> Self45478     pub fn device_node_mask(mut self, device_node_mask: u32) -> Self {
45479         self.inner.device_node_mask = device_node_mask;
45480         self
45481     }
45482     #[inline]
device_luid_valid(mut self, device_luid_valid: bool) -> Self45483     pub fn device_luid_valid(mut self, device_luid_valid: bool) -> Self {
45484         self.inner.device_luid_valid = device_luid_valid.into();
45485         self
45486     }
45487     #[inline]
subgroup_size(mut self, subgroup_size: u32) -> Self45488     pub fn subgroup_size(mut self, subgroup_size: u32) -> Self {
45489         self.inner.subgroup_size = subgroup_size;
45490         self
45491     }
45492     #[inline]
subgroup_supported_stages( mut self, subgroup_supported_stages: ShaderStageFlags, ) -> Self45493     pub fn subgroup_supported_stages(
45494         mut self,
45495         subgroup_supported_stages: ShaderStageFlags,
45496     ) -> Self {
45497         self.inner.subgroup_supported_stages = subgroup_supported_stages;
45498         self
45499     }
45500     #[inline]
subgroup_supported_operations( mut self, subgroup_supported_operations: SubgroupFeatureFlags, ) -> Self45501     pub fn subgroup_supported_operations(
45502         mut self,
45503         subgroup_supported_operations: SubgroupFeatureFlags,
45504     ) -> Self {
45505         self.inner.subgroup_supported_operations = subgroup_supported_operations;
45506         self
45507     }
45508     #[inline]
subgroup_quad_operations_in_all_stages( mut self, subgroup_quad_operations_in_all_stages: bool, ) -> Self45509     pub fn subgroup_quad_operations_in_all_stages(
45510         mut self,
45511         subgroup_quad_operations_in_all_stages: bool,
45512     ) -> Self {
45513         self.inner.subgroup_quad_operations_in_all_stages =
45514             subgroup_quad_operations_in_all_stages.into();
45515         self
45516     }
45517     #[inline]
point_clipping_behavior( mut self, point_clipping_behavior: PointClippingBehavior, ) -> Self45518     pub fn point_clipping_behavior(
45519         mut self,
45520         point_clipping_behavior: PointClippingBehavior,
45521     ) -> Self {
45522         self.inner.point_clipping_behavior = point_clipping_behavior;
45523         self
45524     }
45525     #[inline]
max_multiview_view_count(mut self, max_multiview_view_count: u32) -> Self45526     pub fn max_multiview_view_count(mut self, max_multiview_view_count: u32) -> Self {
45527         self.inner.max_multiview_view_count = max_multiview_view_count;
45528         self
45529     }
45530     #[inline]
max_multiview_instance_index(mut self, max_multiview_instance_index: u32) -> Self45531     pub fn max_multiview_instance_index(mut self, max_multiview_instance_index: u32) -> Self {
45532         self.inner.max_multiview_instance_index = max_multiview_instance_index;
45533         self
45534     }
45535     #[inline]
protected_no_fault(mut self, protected_no_fault: bool) -> Self45536     pub fn protected_no_fault(mut self, protected_no_fault: bool) -> Self {
45537         self.inner.protected_no_fault = protected_no_fault.into();
45538         self
45539     }
45540     #[inline]
max_per_set_descriptors(mut self, max_per_set_descriptors: u32) -> Self45541     pub fn max_per_set_descriptors(mut self, max_per_set_descriptors: u32) -> Self {
45542         self.inner.max_per_set_descriptors = max_per_set_descriptors;
45543         self
45544     }
45545     #[inline]
max_memory_allocation_size(mut self, max_memory_allocation_size: DeviceSize) -> Self45546     pub fn max_memory_allocation_size(mut self, max_memory_allocation_size: DeviceSize) -> Self {
45547         self.inner.max_memory_allocation_size = max_memory_allocation_size;
45548         self
45549     }
45550     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45551     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45552     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceVulkan11Properties45553     pub fn build(self) -> PhysicalDeviceVulkan11Properties {
45554         self.inner
45555     }
45556 }
45557 #[repr(C)]
45558 #[cfg_attr(feature = "debug", derive(Debug))]
45559 #[derive(Copy, Clone)]
45560 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkan12Features.html>"]
45561 pub struct PhysicalDeviceVulkan12Features {
45562     pub s_type: StructureType,
45563     pub p_next: *mut c_void,
45564     pub sampler_mirror_clamp_to_edge: Bool32,
45565     pub draw_indirect_count: Bool32,
45566     pub storage_buffer8_bit_access: Bool32,
45567     pub uniform_and_storage_buffer8_bit_access: Bool32,
45568     pub storage_push_constant8: Bool32,
45569     pub shader_buffer_int64_atomics: Bool32,
45570     pub shader_shared_int64_atomics: Bool32,
45571     pub shader_float16: Bool32,
45572     pub shader_int8: Bool32,
45573     pub descriptor_indexing: Bool32,
45574     pub shader_input_attachment_array_dynamic_indexing: Bool32,
45575     pub shader_uniform_texel_buffer_array_dynamic_indexing: Bool32,
45576     pub shader_storage_texel_buffer_array_dynamic_indexing: Bool32,
45577     pub shader_uniform_buffer_array_non_uniform_indexing: Bool32,
45578     pub shader_sampled_image_array_non_uniform_indexing: Bool32,
45579     pub shader_storage_buffer_array_non_uniform_indexing: Bool32,
45580     pub shader_storage_image_array_non_uniform_indexing: Bool32,
45581     pub shader_input_attachment_array_non_uniform_indexing: Bool32,
45582     pub shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32,
45583     pub shader_storage_texel_buffer_array_non_uniform_indexing: Bool32,
45584     pub descriptor_binding_uniform_buffer_update_after_bind: Bool32,
45585     pub descriptor_binding_sampled_image_update_after_bind: Bool32,
45586     pub descriptor_binding_storage_image_update_after_bind: Bool32,
45587     pub descriptor_binding_storage_buffer_update_after_bind: Bool32,
45588     pub descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32,
45589     pub descriptor_binding_storage_texel_buffer_update_after_bind: Bool32,
45590     pub descriptor_binding_update_unused_while_pending: Bool32,
45591     pub descriptor_binding_partially_bound: Bool32,
45592     pub descriptor_binding_variable_descriptor_count: Bool32,
45593     pub runtime_descriptor_array: Bool32,
45594     pub sampler_filter_minmax: Bool32,
45595     pub scalar_block_layout: Bool32,
45596     pub imageless_framebuffer: Bool32,
45597     pub uniform_buffer_standard_layout: Bool32,
45598     pub shader_subgroup_extended_types: Bool32,
45599     pub separate_depth_stencil_layouts: Bool32,
45600     pub host_query_reset: Bool32,
45601     pub timeline_semaphore: Bool32,
45602     pub buffer_device_address: Bool32,
45603     pub buffer_device_address_capture_replay: Bool32,
45604     pub buffer_device_address_multi_device: Bool32,
45605     pub vulkan_memory_model: Bool32,
45606     pub vulkan_memory_model_device_scope: Bool32,
45607     pub vulkan_memory_model_availability_visibility_chains: Bool32,
45608     pub shader_output_viewport_index: Bool32,
45609     pub shader_output_layer: Bool32,
45610     pub subgroup_broadcast_dynamic_id: Bool32,
45611 }
45612 impl ::std::default::Default for PhysicalDeviceVulkan12Features {
45613     #[inline]
default() -> Self45614     fn default() -> Self {
45615         Self {
45616             s_type: Self::STRUCTURE_TYPE,
45617             p_next: ::std::ptr::null_mut(),
45618             sampler_mirror_clamp_to_edge: Bool32::default(),
45619             draw_indirect_count: Bool32::default(),
45620             storage_buffer8_bit_access: Bool32::default(),
45621             uniform_and_storage_buffer8_bit_access: Bool32::default(),
45622             storage_push_constant8: Bool32::default(),
45623             shader_buffer_int64_atomics: Bool32::default(),
45624             shader_shared_int64_atomics: Bool32::default(),
45625             shader_float16: Bool32::default(),
45626             shader_int8: Bool32::default(),
45627             descriptor_indexing: Bool32::default(),
45628             shader_input_attachment_array_dynamic_indexing: Bool32::default(),
45629             shader_uniform_texel_buffer_array_dynamic_indexing: Bool32::default(),
45630             shader_storage_texel_buffer_array_dynamic_indexing: Bool32::default(),
45631             shader_uniform_buffer_array_non_uniform_indexing: Bool32::default(),
45632             shader_sampled_image_array_non_uniform_indexing: Bool32::default(),
45633             shader_storage_buffer_array_non_uniform_indexing: Bool32::default(),
45634             shader_storage_image_array_non_uniform_indexing: Bool32::default(),
45635             shader_input_attachment_array_non_uniform_indexing: Bool32::default(),
45636             shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32::default(),
45637             shader_storage_texel_buffer_array_non_uniform_indexing: Bool32::default(),
45638             descriptor_binding_uniform_buffer_update_after_bind: Bool32::default(),
45639             descriptor_binding_sampled_image_update_after_bind: Bool32::default(),
45640             descriptor_binding_storage_image_update_after_bind: Bool32::default(),
45641             descriptor_binding_storage_buffer_update_after_bind: Bool32::default(),
45642             descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32::default(),
45643             descriptor_binding_storage_texel_buffer_update_after_bind: Bool32::default(),
45644             descriptor_binding_update_unused_while_pending: Bool32::default(),
45645             descriptor_binding_partially_bound: Bool32::default(),
45646             descriptor_binding_variable_descriptor_count: Bool32::default(),
45647             runtime_descriptor_array: Bool32::default(),
45648             sampler_filter_minmax: Bool32::default(),
45649             scalar_block_layout: Bool32::default(),
45650             imageless_framebuffer: Bool32::default(),
45651             uniform_buffer_standard_layout: Bool32::default(),
45652             shader_subgroup_extended_types: Bool32::default(),
45653             separate_depth_stencil_layouts: Bool32::default(),
45654             host_query_reset: Bool32::default(),
45655             timeline_semaphore: Bool32::default(),
45656             buffer_device_address: Bool32::default(),
45657             buffer_device_address_capture_replay: Bool32::default(),
45658             buffer_device_address_multi_device: Bool32::default(),
45659             vulkan_memory_model: Bool32::default(),
45660             vulkan_memory_model_device_scope: Bool32::default(),
45661             vulkan_memory_model_availability_visibility_chains: Bool32::default(),
45662             shader_output_viewport_index: Bool32::default(),
45663             shader_output_layer: Bool32::default(),
45664             subgroup_broadcast_dynamic_id: Bool32::default(),
45665         }
45666     }
45667 }
45668 unsafe impl TaggedStructure for PhysicalDeviceVulkan12Features {
45669     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
45670 }
45671 impl PhysicalDeviceVulkan12Features {
builder<'a>() -> PhysicalDeviceVulkan12FeaturesBuilder<'a>45672     pub fn builder<'a>() -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
45673         PhysicalDeviceVulkan12FeaturesBuilder {
45674             inner: Self::default(),
45675             marker: ::std::marker::PhantomData,
45676         }
45677     }
45678 }
45679 #[repr(transparent)]
45680 pub struct PhysicalDeviceVulkan12FeaturesBuilder<'a> {
45681     inner: PhysicalDeviceVulkan12Features,
45682     marker: ::std::marker::PhantomData<&'a ()>,
45683 }
45684 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan12FeaturesBuilder<'_> {}
45685 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan12Features {}
45686 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan12FeaturesBuilder<'_> {}
45687 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan12Features {}
45688 impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan12FeaturesBuilder<'a> {
45689     type Target = PhysicalDeviceVulkan12Features;
deref(&self) -> &Self::Target45690     fn deref(&self) -> &Self::Target {
45691         &self.inner
45692     }
45693 }
45694 impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan12FeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target45695     fn deref_mut(&mut self) -> &mut Self::Target {
45696         &mut self.inner
45697     }
45698 }
45699 impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
45700     #[inline]
sampler_mirror_clamp_to_edge(mut self, sampler_mirror_clamp_to_edge: bool) -> Self45701     pub fn sampler_mirror_clamp_to_edge(mut self, sampler_mirror_clamp_to_edge: bool) -> Self {
45702         self.inner.sampler_mirror_clamp_to_edge = sampler_mirror_clamp_to_edge.into();
45703         self
45704     }
45705     #[inline]
draw_indirect_count(mut self, draw_indirect_count: bool) -> Self45706     pub fn draw_indirect_count(mut self, draw_indirect_count: bool) -> Self {
45707         self.inner.draw_indirect_count = draw_indirect_count.into();
45708         self
45709     }
45710     #[inline]
storage_buffer8_bit_access(mut self, storage_buffer8_bit_access: bool) -> Self45711     pub fn storage_buffer8_bit_access(mut self, storage_buffer8_bit_access: bool) -> Self {
45712         self.inner.storage_buffer8_bit_access = storage_buffer8_bit_access.into();
45713         self
45714     }
45715     #[inline]
uniform_and_storage_buffer8_bit_access( mut self, uniform_and_storage_buffer8_bit_access: bool, ) -> Self45716     pub fn uniform_and_storage_buffer8_bit_access(
45717         mut self,
45718         uniform_and_storage_buffer8_bit_access: bool,
45719     ) -> Self {
45720         self.inner.uniform_and_storage_buffer8_bit_access =
45721             uniform_and_storage_buffer8_bit_access.into();
45722         self
45723     }
45724     #[inline]
storage_push_constant8(mut self, storage_push_constant8: bool) -> Self45725     pub fn storage_push_constant8(mut self, storage_push_constant8: bool) -> Self {
45726         self.inner.storage_push_constant8 = storage_push_constant8.into();
45727         self
45728     }
45729     #[inline]
shader_buffer_int64_atomics(mut self, shader_buffer_int64_atomics: bool) -> Self45730     pub fn shader_buffer_int64_atomics(mut self, shader_buffer_int64_atomics: bool) -> Self {
45731         self.inner.shader_buffer_int64_atomics = shader_buffer_int64_atomics.into();
45732         self
45733     }
45734     #[inline]
shader_shared_int64_atomics(mut self, shader_shared_int64_atomics: bool) -> Self45735     pub fn shader_shared_int64_atomics(mut self, shader_shared_int64_atomics: bool) -> Self {
45736         self.inner.shader_shared_int64_atomics = shader_shared_int64_atomics.into();
45737         self
45738     }
45739     #[inline]
shader_float16(mut self, shader_float16: bool) -> Self45740     pub fn shader_float16(mut self, shader_float16: bool) -> Self {
45741         self.inner.shader_float16 = shader_float16.into();
45742         self
45743     }
45744     #[inline]
shader_int8(mut self, shader_int8: bool) -> Self45745     pub fn shader_int8(mut self, shader_int8: bool) -> Self {
45746         self.inner.shader_int8 = shader_int8.into();
45747         self
45748     }
45749     #[inline]
descriptor_indexing(mut self, descriptor_indexing: bool) -> Self45750     pub fn descriptor_indexing(mut self, descriptor_indexing: bool) -> Self {
45751         self.inner.descriptor_indexing = descriptor_indexing.into();
45752         self
45753     }
45754     #[inline]
shader_input_attachment_array_dynamic_indexing( mut self, shader_input_attachment_array_dynamic_indexing: bool, ) -> Self45755     pub fn shader_input_attachment_array_dynamic_indexing(
45756         mut self,
45757         shader_input_attachment_array_dynamic_indexing: bool,
45758     ) -> Self {
45759         self.inner.shader_input_attachment_array_dynamic_indexing =
45760             shader_input_attachment_array_dynamic_indexing.into();
45761         self
45762     }
45763     #[inline]
shader_uniform_texel_buffer_array_dynamic_indexing( mut self, shader_uniform_texel_buffer_array_dynamic_indexing: bool, ) -> Self45764     pub fn shader_uniform_texel_buffer_array_dynamic_indexing(
45765         mut self,
45766         shader_uniform_texel_buffer_array_dynamic_indexing: bool,
45767     ) -> Self {
45768         self.inner
45769             .shader_uniform_texel_buffer_array_dynamic_indexing =
45770             shader_uniform_texel_buffer_array_dynamic_indexing.into();
45771         self
45772     }
45773     #[inline]
shader_storage_texel_buffer_array_dynamic_indexing( mut self, shader_storage_texel_buffer_array_dynamic_indexing: bool, ) -> Self45774     pub fn shader_storage_texel_buffer_array_dynamic_indexing(
45775         mut self,
45776         shader_storage_texel_buffer_array_dynamic_indexing: bool,
45777     ) -> Self {
45778         self.inner
45779             .shader_storage_texel_buffer_array_dynamic_indexing =
45780             shader_storage_texel_buffer_array_dynamic_indexing.into();
45781         self
45782     }
45783     #[inline]
shader_uniform_buffer_array_non_uniform_indexing( mut self, shader_uniform_buffer_array_non_uniform_indexing: bool, ) -> Self45784     pub fn shader_uniform_buffer_array_non_uniform_indexing(
45785         mut self,
45786         shader_uniform_buffer_array_non_uniform_indexing: bool,
45787     ) -> Self {
45788         self.inner.shader_uniform_buffer_array_non_uniform_indexing =
45789             shader_uniform_buffer_array_non_uniform_indexing.into();
45790         self
45791     }
45792     #[inline]
shader_sampled_image_array_non_uniform_indexing( mut self, shader_sampled_image_array_non_uniform_indexing: bool, ) -> Self45793     pub fn shader_sampled_image_array_non_uniform_indexing(
45794         mut self,
45795         shader_sampled_image_array_non_uniform_indexing: bool,
45796     ) -> Self {
45797         self.inner.shader_sampled_image_array_non_uniform_indexing =
45798             shader_sampled_image_array_non_uniform_indexing.into();
45799         self
45800     }
45801     #[inline]
shader_storage_buffer_array_non_uniform_indexing( mut self, shader_storage_buffer_array_non_uniform_indexing: bool, ) -> Self45802     pub fn shader_storage_buffer_array_non_uniform_indexing(
45803         mut self,
45804         shader_storage_buffer_array_non_uniform_indexing: bool,
45805     ) -> Self {
45806         self.inner.shader_storage_buffer_array_non_uniform_indexing =
45807             shader_storage_buffer_array_non_uniform_indexing.into();
45808         self
45809     }
45810     #[inline]
shader_storage_image_array_non_uniform_indexing( mut self, shader_storage_image_array_non_uniform_indexing: bool, ) -> Self45811     pub fn shader_storage_image_array_non_uniform_indexing(
45812         mut self,
45813         shader_storage_image_array_non_uniform_indexing: bool,
45814     ) -> Self {
45815         self.inner.shader_storage_image_array_non_uniform_indexing =
45816             shader_storage_image_array_non_uniform_indexing.into();
45817         self
45818     }
45819     #[inline]
shader_input_attachment_array_non_uniform_indexing( mut self, shader_input_attachment_array_non_uniform_indexing: bool, ) -> Self45820     pub fn shader_input_attachment_array_non_uniform_indexing(
45821         mut self,
45822         shader_input_attachment_array_non_uniform_indexing: bool,
45823     ) -> Self {
45824         self.inner
45825             .shader_input_attachment_array_non_uniform_indexing =
45826             shader_input_attachment_array_non_uniform_indexing.into();
45827         self
45828     }
45829     #[inline]
shader_uniform_texel_buffer_array_non_uniform_indexing( mut self, shader_uniform_texel_buffer_array_non_uniform_indexing: bool, ) -> Self45830     pub fn shader_uniform_texel_buffer_array_non_uniform_indexing(
45831         mut self,
45832         shader_uniform_texel_buffer_array_non_uniform_indexing: bool,
45833     ) -> Self {
45834         self.inner
45835             .shader_uniform_texel_buffer_array_non_uniform_indexing =
45836             shader_uniform_texel_buffer_array_non_uniform_indexing.into();
45837         self
45838     }
45839     #[inline]
shader_storage_texel_buffer_array_non_uniform_indexing( mut self, shader_storage_texel_buffer_array_non_uniform_indexing: bool, ) -> Self45840     pub fn shader_storage_texel_buffer_array_non_uniform_indexing(
45841         mut self,
45842         shader_storage_texel_buffer_array_non_uniform_indexing: bool,
45843     ) -> Self {
45844         self.inner
45845             .shader_storage_texel_buffer_array_non_uniform_indexing =
45846             shader_storage_texel_buffer_array_non_uniform_indexing.into();
45847         self
45848     }
45849     #[inline]
descriptor_binding_uniform_buffer_update_after_bind( mut self, descriptor_binding_uniform_buffer_update_after_bind: bool, ) -> Self45850     pub fn descriptor_binding_uniform_buffer_update_after_bind(
45851         mut self,
45852         descriptor_binding_uniform_buffer_update_after_bind: bool,
45853     ) -> Self {
45854         self.inner
45855             .descriptor_binding_uniform_buffer_update_after_bind =
45856             descriptor_binding_uniform_buffer_update_after_bind.into();
45857         self
45858     }
45859     #[inline]
descriptor_binding_sampled_image_update_after_bind( mut self, descriptor_binding_sampled_image_update_after_bind: bool, ) -> Self45860     pub fn descriptor_binding_sampled_image_update_after_bind(
45861         mut self,
45862         descriptor_binding_sampled_image_update_after_bind: bool,
45863     ) -> Self {
45864         self.inner
45865             .descriptor_binding_sampled_image_update_after_bind =
45866             descriptor_binding_sampled_image_update_after_bind.into();
45867         self
45868     }
45869     #[inline]
descriptor_binding_storage_image_update_after_bind( mut self, descriptor_binding_storage_image_update_after_bind: bool, ) -> Self45870     pub fn descriptor_binding_storage_image_update_after_bind(
45871         mut self,
45872         descriptor_binding_storage_image_update_after_bind: bool,
45873     ) -> Self {
45874         self.inner
45875             .descriptor_binding_storage_image_update_after_bind =
45876             descriptor_binding_storage_image_update_after_bind.into();
45877         self
45878     }
45879     #[inline]
descriptor_binding_storage_buffer_update_after_bind( mut self, descriptor_binding_storage_buffer_update_after_bind: bool, ) -> Self45880     pub fn descriptor_binding_storage_buffer_update_after_bind(
45881         mut self,
45882         descriptor_binding_storage_buffer_update_after_bind: bool,
45883     ) -> Self {
45884         self.inner
45885             .descriptor_binding_storage_buffer_update_after_bind =
45886             descriptor_binding_storage_buffer_update_after_bind.into();
45887         self
45888     }
45889     #[inline]
descriptor_binding_uniform_texel_buffer_update_after_bind( mut self, descriptor_binding_uniform_texel_buffer_update_after_bind: bool, ) -> Self45890     pub fn descriptor_binding_uniform_texel_buffer_update_after_bind(
45891         mut self,
45892         descriptor_binding_uniform_texel_buffer_update_after_bind: bool,
45893     ) -> Self {
45894         self.inner
45895             .descriptor_binding_uniform_texel_buffer_update_after_bind =
45896             descriptor_binding_uniform_texel_buffer_update_after_bind.into();
45897         self
45898     }
45899     #[inline]
descriptor_binding_storage_texel_buffer_update_after_bind( mut self, descriptor_binding_storage_texel_buffer_update_after_bind: bool, ) -> Self45900     pub fn descriptor_binding_storage_texel_buffer_update_after_bind(
45901         mut self,
45902         descriptor_binding_storage_texel_buffer_update_after_bind: bool,
45903     ) -> Self {
45904         self.inner
45905             .descriptor_binding_storage_texel_buffer_update_after_bind =
45906             descriptor_binding_storage_texel_buffer_update_after_bind.into();
45907         self
45908     }
45909     #[inline]
descriptor_binding_update_unused_while_pending( mut self, descriptor_binding_update_unused_while_pending: bool, ) -> Self45910     pub fn descriptor_binding_update_unused_while_pending(
45911         mut self,
45912         descriptor_binding_update_unused_while_pending: bool,
45913     ) -> Self {
45914         self.inner.descriptor_binding_update_unused_while_pending =
45915             descriptor_binding_update_unused_while_pending.into();
45916         self
45917     }
45918     #[inline]
descriptor_binding_partially_bound( mut self, descriptor_binding_partially_bound: bool, ) -> Self45919     pub fn descriptor_binding_partially_bound(
45920         mut self,
45921         descriptor_binding_partially_bound: bool,
45922     ) -> Self {
45923         self.inner.descriptor_binding_partially_bound = descriptor_binding_partially_bound.into();
45924         self
45925     }
45926     #[inline]
descriptor_binding_variable_descriptor_count( mut self, descriptor_binding_variable_descriptor_count: bool, ) -> Self45927     pub fn descriptor_binding_variable_descriptor_count(
45928         mut self,
45929         descriptor_binding_variable_descriptor_count: bool,
45930     ) -> Self {
45931         self.inner.descriptor_binding_variable_descriptor_count =
45932             descriptor_binding_variable_descriptor_count.into();
45933         self
45934     }
45935     #[inline]
runtime_descriptor_array(mut self, runtime_descriptor_array: bool) -> Self45936     pub fn runtime_descriptor_array(mut self, runtime_descriptor_array: bool) -> Self {
45937         self.inner.runtime_descriptor_array = runtime_descriptor_array.into();
45938         self
45939     }
45940     #[inline]
sampler_filter_minmax(mut self, sampler_filter_minmax: bool) -> Self45941     pub fn sampler_filter_minmax(mut self, sampler_filter_minmax: bool) -> Self {
45942         self.inner.sampler_filter_minmax = sampler_filter_minmax.into();
45943         self
45944     }
45945     #[inline]
scalar_block_layout(mut self, scalar_block_layout: bool) -> Self45946     pub fn scalar_block_layout(mut self, scalar_block_layout: bool) -> Self {
45947         self.inner.scalar_block_layout = scalar_block_layout.into();
45948         self
45949     }
45950     #[inline]
imageless_framebuffer(mut self, imageless_framebuffer: bool) -> Self45951     pub fn imageless_framebuffer(mut self, imageless_framebuffer: bool) -> Self {
45952         self.inner.imageless_framebuffer = imageless_framebuffer.into();
45953         self
45954     }
45955     #[inline]
uniform_buffer_standard_layout(mut self, uniform_buffer_standard_layout: bool) -> Self45956     pub fn uniform_buffer_standard_layout(mut self, uniform_buffer_standard_layout: bool) -> Self {
45957         self.inner.uniform_buffer_standard_layout = uniform_buffer_standard_layout.into();
45958         self
45959     }
45960     #[inline]
shader_subgroup_extended_types(mut self, shader_subgroup_extended_types: bool) -> Self45961     pub fn shader_subgroup_extended_types(mut self, shader_subgroup_extended_types: bool) -> Self {
45962         self.inner.shader_subgroup_extended_types = shader_subgroup_extended_types.into();
45963         self
45964     }
45965     #[inline]
separate_depth_stencil_layouts(mut self, separate_depth_stencil_layouts: bool) -> Self45966     pub fn separate_depth_stencil_layouts(mut self, separate_depth_stencil_layouts: bool) -> Self {
45967         self.inner.separate_depth_stencil_layouts = separate_depth_stencil_layouts.into();
45968         self
45969     }
45970     #[inline]
host_query_reset(mut self, host_query_reset: bool) -> Self45971     pub fn host_query_reset(mut self, host_query_reset: bool) -> Self {
45972         self.inner.host_query_reset = host_query_reset.into();
45973         self
45974     }
45975     #[inline]
timeline_semaphore(mut self, timeline_semaphore: bool) -> Self45976     pub fn timeline_semaphore(mut self, timeline_semaphore: bool) -> Self {
45977         self.inner.timeline_semaphore = timeline_semaphore.into();
45978         self
45979     }
45980     #[inline]
buffer_device_address(mut self, buffer_device_address: bool) -> Self45981     pub fn buffer_device_address(mut self, buffer_device_address: bool) -> Self {
45982         self.inner.buffer_device_address = buffer_device_address.into();
45983         self
45984     }
45985     #[inline]
buffer_device_address_capture_replay( mut self, buffer_device_address_capture_replay: bool, ) -> Self45986     pub fn buffer_device_address_capture_replay(
45987         mut self,
45988         buffer_device_address_capture_replay: bool,
45989     ) -> Self {
45990         self.inner.buffer_device_address_capture_replay =
45991             buffer_device_address_capture_replay.into();
45992         self
45993     }
45994     #[inline]
buffer_device_address_multi_device( mut self, buffer_device_address_multi_device: bool, ) -> Self45995     pub fn buffer_device_address_multi_device(
45996         mut self,
45997         buffer_device_address_multi_device: bool,
45998     ) -> Self {
45999         self.inner.buffer_device_address_multi_device = buffer_device_address_multi_device.into();
46000         self
46001     }
46002     #[inline]
vulkan_memory_model(mut self, vulkan_memory_model: bool) -> Self46003     pub fn vulkan_memory_model(mut self, vulkan_memory_model: bool) -> Self {
46004         self.inner.vulkan_memory_model = vulkan_memory_model.into();
46005         self
46006     }
46007     #[inline]
vulkan_memory_model_device_scope( mut self, vulkan_memory_model_device_scope: bool, ) -> Self46008     pub fn vulkan_memory_model_device_scope(
46009         mut self,
46010         vulkan_memory_model_device_scope: bool,
46011     ) -> Self {
46012         self.inner.vulkan_memory_model_device_scope = vulkan_memory_model_device_scope.into();
46013         self
46014     }
46015     #[inline]
vulkan_memory_model_availability_visibility_chains( mut self, vulkan_memory_model_availability_visibility_chains: bool, ) -> Self46016     pub fn vulkan_memory_model_availability_visibility_chains(
46017         mut self,
46018         vulkan_memory_model_availability_visibility_chains: bool,
46019     ) -> Self {
46020         self.inner
46021             .vulkan_memory_model_availability_visibility_chains =
46022             vulkan_memory_model_availability_visibility_chains.into();
46023         self
46024     }
46025     #[inline]
shader_output_viewport_index(mut self, shader_output_viewport_index: bool) -> Self46026     pub fn shader_output_viewport_index(mut self, shader_output_viewport_index: bool) -> Self {
46027         self.inner.shader_output_viewport_index = shader_output_viewport_index.into();
46028         self
46029     }
46030     #[inline]
shader_output_layer(mut self, shader_output_layer: bool) -> Self46031     pub fn shader_output_layer(mut self, shader_output_layer: bool) -> Self {
46032         self.inner.shader_output_layer = shader_output_layer.into();
46033         self
46034     }
46035     #[inline]
subgroup_broadcast_dynamic_id(mut self, subgroup_broadcast_dynamic_id: bool) -> Self46036     pub fn subgroup_broadcast_dynamic_id(mut self, subgroup_broadcast_dynamic_id: bool) -> Self {
46037         self.inner.subgroup_broadcast_dynamic_id = subgroup_broadcast_dynamic_id.into();
46038         self
46039     }
46040     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46041     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46042     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceVulkan12Features46043     pub fn build(self) -> PhysicalDeviceVulkan12Features {
46044         self.inner
46045     }
46046 }
46047 #[repr(C)]
46048 #[derive(Copy, Clone)]
46049 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html>"]
46050 pub struct PhysicalDeviceVulkan12Properties {
46051     pub s_type: StructureType,
46052     pub p_next: *mut c_void,
46053     pub driver_id: DriverId,
46054     pub driver_name: [c_char; MAX_DRIVER_NAME_SIZE],
46055     pub driver_info: [c_char; MAX_DRIVER_INFO_SIZE],
46056     pub conformance_version: ConformanceVersion,
46057     pub denorm_behavior_independence: ShaderFloatControlsIndependence,
46058     pub rounding_mode_independence: ShaderFloatControlsIndependence,
46059     pub shader_signed_zero_inf_nan_preserve_float16: Bool32,
46060     pub shader_signed_zero_inf_nan_preserve_float32: Bool32,
46061     pub shader_signed_zero_inf_nan_preserve_float64: Bool32,
46062     pub shader_denorm_preserve_float16: Bool32,
46063     pub shader_denorm_preserve_float32: Bool32,
46064     pub shader_denorm_preserve_float64: Bool32,
46065     pub shader_denorm_flush_to_zero_float16: Bool32,
46066     pub shader_denorm_flush_to_zero_float32: Bool32,
46067     pub shader_denorm_flush_to_zero_float64: Bool32,
46068     pub shader_rounding_mode_rte_float16: Bool32,
46069     pub shader_rounding_mode_rte_float32: Bool32,
46070     pub shader_rounding_mode_rte_float64: Bool32,
46071     pub shader_rounding_mode_rtz_float16: Bool32,
46072     pub shader_rounding_mode_rtz_float32: Bool32,
46073     pub shader_rounding_mode_rtz_float64: Bool32,
46074     pub max_update_after_bind_descriptors_in_all_pools: u32,
46075     pub shader_uniform_buffer_array_non_uniform_indexing_native: Bool32,
46076     pub shader_sampled_image_array_non_uniform_indexing_native: Bool32,
46077     pub shader_storage_buffer_array_non_uniform_indexing_native: Bool32,
46078     pub shader_storage_image_array_non_uniform_indexing_native: Bool32,
46079     pub shader_input_attachment_array_non_uniform_indexing_native: Bool32,
46080     pub robust_buffer_access_update_after_bind: Bool32,
46081     pub quad_divergent_implicit_lod: Bool32,
46082     pub max_per_stage_descriptor_update_after_bind_samplers: u32,
46083     pub max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
46084     pub max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
46085     pub max_per_stage_descriptor_update_after_bind_sampled_images: u32,
46086     pub max_per_stage_descriptor_update_after_bind_storage_images: u32,
46087     pub max_per_stage_descriptor_update_after_bind_input_attachments: u32,
46088     pub max_per_stage_update_after_bind_resources: u32,
46089     pub max_descriptor_set_update_after_bind_samplers: u32,
46090     pub max_descriptor_set_update_after_bind_uniform_buffers: u32,
46091     pub max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
46092     pub max_descriptor_set_update_after_bind_storage_buffers: u32,
46093     pub max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
46094     pub max_descriptor_set_update_after_bind_sampled_images: u32,
46095     pub max_descriptor_set_update_after_bind_storage_images: u32,
46096     pub max_descriptor_set_update_after_bind_input_attachments: u32,
46097     pub supported_depth_resolve_modes: ResolveModeFlags,
46098     pub supported_stencil_resolve_modes: ResolveModeFlags,
46099     pub independent_resolve_none: Bool32,
46100     pub independent_resolve: Bool32,
46101     pub filter_minmax_single_component_formats: Bool32,
46102     pub filter_minmax_image_component_mapping: Bool32,
46103     pub max_timeline_semaphore_value_difference: u64,
46104     pub framebuffer_integer_color_sample_counts: SampleCountFlags,
46105 }
46106 #[cfg(feature = "debug")]
46107 impl fmt::Debug for PhysicalDeviceVulkan12Properties {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result46108     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
46109         fmt.debug_struct("PhysicalDeviceVulkan12Properties")
46110             .field("s_type", &self.s_type)
46111             .field("p_next", &self.p_next)
46112             .field("driver_id", &self.driver_id)
46113             .field("driver_name", &unsafe {
46114                 ::std::ffi::CStr::from_ptr(self.driver_name.as_ptr())
46115             })
46116             .field("driver_info", &unsafe {
46117                 ::std::ffi::CStr::from_ptr(self.driver_info.as_ptr())
46118             })
46119             .field("conformance_version", &self.conformance_version)
46120             .field(
46121                 "denorm_behavior_independence",
46122                 &self.denorm_behavior_independence,
46123             )
46124             .field(
46125                 "rounding_mode_independence",
46126                 &self.rounding_mode_independence,
46127             )
46128             .field(
46129                 "shader_signed_zero_inf_nan_preserve_float16",
46130                 &self.shader_signed_zero_inf_nan_preserve_float16,
46131             )
46132             .field(
46133                 "shader_signed_zero_inf_nan_preserve_float32",
46134                 &self.shader_signed_zero_inf_nan_preserve_float32,
46135             )
46136             .field(
46137                 "shader_signed_zero_inf_nan_preserve_float64",
46138                 &self.shader_signed_zero_inf_nan_preserve_float64,
46139             )
46140             .field(
46141                 "shader_denorm_preserve_float16",
46142                 &self.shader_denorm_preserve_float16,
46143             )
46144             .field(
46145                 "shader_denorm_preserve_float32",
46146                 &self.shader_denorm_preserve_float32,
46147             )
46148             .field(
46149                 "shader_denorm_preserve_float64",
46150                 &self.shader_denorm_preserve_float64,
46151             )
46152             .field(
46153                 "shader_denorm_flush_to_zero_float16",
46154                 &self.shader_denorm_flush_to_zero_float16,
46155             )
46156             .field(
46157                 "shader_denorm_flush_to_zero_float32",
46158                 &self.shader_denorm_flush_to_zero_float32,
46159             )
46160             .field(
46161                 "shader_denorm_flush_to_zero_float64",
46162                 &self.shader_denorm_flush_to_zero_float64,
46163             )
46164             .field(
46165                 "shader_rounding_mode_rte_float16",
46166                 &self.shader_rounding_mode_rte_float16,
46167             )
46168             .field(
46169                 "shader_rounding_mode_rte_float32",
46170                 &self.shader_rounding_mode_rte_float32,
46171             )
46172             .field(
46173                 "shader_rounding_mode_rte_float64",
46174                 &self.shader_rounding_mode_rte_float64,
46175             )
46176             .field(
46177                 "shader_rounding_mode_rtz_float16",
46178                 &self.shader_rounding_mode_rtz_float16,
46179             )
46180             .field(
46181                 "shader_rounding_mode_rtz_float32",
46182                 &self.shader_rounding_mode_rtz_float32,
46183             )
46184             .field(
46185                 "shader_rounding_mode_rtz_float64",
46186                 &self.shader_rounding_mode_rtz_float64,
46187             )
46188             .field(
46189                 "max_update_after_bind_descriptors_in_all_pools",
46190                 &self.max_update_after_bind_descriptors_in_all_pools,
46191             )
46192             .field(
46193                 "shader_uniform_buffer_array_non_uniform_indexing_native",
46194                 &self.shader_uniform_buffer_array_non_uniform_indexing_native,
46195             )
46196             .field(
46197                 "shader_sampled_image_array_non_uniform_indexing_native",
46198                 &self.shader_sampled_image_array_non_uniform_indexing_native,
46199             )
46200             .field(
46201                 "shader_storage_buffer_array_non_uniform_indexing_native",
46202                 &self.shader_storage_buffer_array_non_uniform_indexing_native,
46203             )
46204             .field(
46205                 "shader_storage_image_array_non_uniform_indexing_native",
46206                 &self.shader_storage_image_array_non_uniform_indexing_native,
46207             )
46208             .field(
46209                 "shader_input_attachment_array_non_uniform_indexing_native",
46210                 &self.shader_input_attachment_array_non_uniform_indexing_native,
46211             )
46212             .field(
46213                 "robust_buffer_access_update_after_bind",
46214                 &self.robust_buffer_access_update_after_bind,
46215             )
46216             .field(
46217                 "quad_divergent_implicit_lod",
46218                 &self.quad_divergent_implicit_lod,
46219             )
46220             .field(
46221                 "max_per_stage_descriptor_update_after_bind_samplers",
46222                 &self.max_per_stage_descriptor_update_after_bind_samplers,
46223             )
46224             .field(
46225                 "max_per_stage_descriptor_update_after_bind_uniform_buffers",
46226                 &self.max_per_stage_descriptor_update_after_bind_uniform_buffers,
46227             )
46228             .field(
46229                 "max_per_stage_descriptor_update_after_bind_storage_buffers",
46230                 &self.max_per_stage_descriptor_update_after_bind_storage_buffers,
46231             )
46232             .field(
46233                 "max_per_stage_descriptor_update_after_bind_sampled_images",
46234                 &self.max_per_stage_descriptor_update_after_bind_sampled_images,
46235             )
46236             .field(
46237                 "max_per_stage_descriptor_update_after_bind_storage_images",
46238                 &self.max_per_stage_descriptor_update_after_bind_storage_images,
46239             )
46240             .field(
46241                 "max_per_stage_descriptor_update_after_bind_input_attachments",
46242                 &self.max_per_stage_descriptor_update_after_bind_input_attachments,
46243             )
46244             .field(
46245                 "max_per_stage_update_after_bind_resources",
46246                 &self.max_per_stage_update_after_bind_resources,
46247             )
46248             .field(
46249                 "max_descriptor_set_update_after_bind_samplers",
46250                 &self.max_descriptor_set_update_after_bind_samplers,
46251             )
46252             .field(
46253                 "max_descriptor_set_update_after_bind_uniform_buffers",
46254                 &self.max_descriptor_set_update_after_bind_uniform_buffers,
46255             )
46256             .field(
46257                 "max_descriptor_set_update_after_bind_uniform_buffers_dynamic",
46258                 &self.max_descriptor_set_update_after_bind_uniform_buffers_dynamic,
46259             )
46260             .field(
46261                 "max_descriptor_set_update_after_bind_storage_buffers",
46262                 &self.max_descriptor_set_update_after_bind_storage_buffers,
46263             )
46264             .field(
46265                 "max_descriptor_set_update_after_bind_storage_buffers_dynamic",
46266                 &self.max_descriptor_set_update_after_bind_storage_buffers_dynamic,
46267             )
46268             .field(
46269                 "max_descriptor_set_update_after_bind_sampled_images",
46270                 &self.max_descriptor_set_update_after_bind_sampled_images,
46271             )
46272             .field(
46273                 "max_descriptor_set_update_after_bind_storage_images",
46274                 &self.max_descriptor_set_update_after_bind_storage_images,
46275             )
46276             .field(
46277                 "max_descriptor_set_update_after_bind_input_attachments",
46278                 &self.max_descriptor_set_update_after_bind_input_attachments,
46279             )
46280             .field(
46281                 "supported_depth_resolve_modes",
46282                 &self.supported_depth_resolve_modes,
46283             )
46284             .field(
46285                 "supported_stencil_resolve_modes",
46286                 &self.supported_stencil_resolve_modes,
46287             )
46288             .field("independent_resolve_none", &self.independent_resolve_none)
46289             .field("independent_resolve", &self.independent_resolve)
46290             .field(
46291                 "filter_minmax_single_component_formats",
46292                 &self.filter_minmax_single_component_formats,
46293             )
46294             .field(
46295                 "filter_minmax_image_component_mapping",
46296                 &self.filter_minmax_image_component_mapping,
46297             )
46298             .field(
46299                 "max_timeline_semaphore_value_difference",
46300                 &self.max_timeline_semaphore_value_difference,
46301             )
46302             .field(
46303                 "framebuffer_integer_color_sample_counts",
46304                 &self.framebuffer_integer_color_sample_counts,
46305             )
46306             .finish()
46307     }
46308 }
46309 impl ::std::default::Default for PhysicalDeviceVulkan12Properties {
46310     #[inline]
default() -> Self46311     fn default() -> Self {
46312         Self {
46313             s_type: Self::STRUCTURE_TYPE,
46314             p_next: ::std::ptr::null_mut(),
46315             driver_id: DriverId::default(),
46316             driver_name: unsafe { ::std::mem::zeroed() },
46317             driver_info: unsafe { ::std::mem::zeroed() },
46318             conformance_version: ConformanceVersion::default(),
46319             denorm_behavior_independence: ShaderFloatControlsIndependence::default(),
46320             rounding_mode_independence: ShaderFloatControlsIndependence::default(),
46321             shader_signed_zero_inf_nan_preserve_float16: Bool32::default(),
46322             shader_signed_zero_inf_nan_preserve_float32: Bool32::default(),
46323             shader_signed_zero_inf_nan_preserve_float64: Bool32::default(),
46324             shader_denorm_preserve_float16: Bool32::default(),
46325             shader_denorm_preserve_float32: Bool32::default(),
46326             shader_denorm_preserve_float64: Bool32::default(),
46327             shader_denorm_flush_to_zero_float16: Bool32::default(),
46328             shader_denorm_flush_to_zero_float32: Bool32::default(),
46329             shader_denorm_flush_to_zero_float64: Bool32::default(),
46330             shader_rounding_mode_rte_float16: Bool32::default(),
46331             shader_rounding_mode_rte_float32: Bool32::default(),
46332             shader_rounding_mode_rte_float64: Bool32::default(),
46333             shader_rounding_mode_rtz_float16: Bool32::default(),
46334             shader_rounding_mode_rtz_float32: Bool32::default(),
46335             shader_rounding_mode_rtz_float64: Bool32::default(),
46336             max_update_after_bind_descriptors_in_all_pools: u32::default(),
46337             shader_uniform_buffer_array_non_uniform_indexing_native: Bool32::default(),
46338             shader_sampled_image_array_non_uniform_indexing_native: Bool32::default(),
46339             shader_storage_buffer_array_non_uniform_indexing_native: Bool32::default(),
46340             shader_storage_image_array_non_uniform_indexing_native: Bool32::default(),
46341             shader_input_attachment_array_non_uniform_indexing_native: Bool32::default(),
46342             robust_buffer_access_update_after_bind: Bool32::default(),
46343             quad_divergent_implicit_lod: Bool32::default(),
46344             max_per_stage_descriptor_update_after_bind_samplers: u32::default(),
46345             max_per_stage_descriptor_update_after_bind_uniform_buffers: u32::default(),
46346             max_per_stage_descriptor_update_after_bind_storage_buffers: u32::default(),
46347             max_per_stage_descriptor_update_after_bind_sampled_images: u32::default(),
46348             max_per_stage_descriptor_update_after_bind_storage_images: u32::default(),
46349             max_per_stage_descriptor_update_after_bind_input_attachments: u32::default(),
46350             max_per_stage_update_after_bind_resources: u32::default(),
46351             max_descriptor_set_update_after_bind_samplers: u32::default(),
46352             max_descriptor_set_update_after_bind_uniform_buffers: u32::default(),
46353             max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32::default(),
46354             max_descriptor_set_update_after_bind_storage_buffers: u32::default(),
46355             max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32::default(),
46356             max_descriptor_set_update_after_bind_sampled_images: u32::default(),
46357             max_descriptor_set_update_after_bind_storage_images: u32::default(),
46358             max_descriptor_set_update_after_bind_input_attachments: u32::default(),
46359             supported_depth_resolve_modes: ResolveModeFlags::default(),
46360             supported_stencil_resolve_modes: ResolveModeFlags::default(),
46361             independent_resolve_none: Bool32::default(),
46362             independent_resolve: Bool32::default(),
46363             filter_minmax_single_component_formats: Bool32::default(),
46364             filter_minmax_image_component_mapping: Bool32::default(),
46365             max_timeline_semaphore_value_difference: u64::default(),
46366             framebuffer_integer_color_sample_counts: SampleCountFlags::default(),
46367         }
46368     }
46369 }
46370 unsafe impl TaggedStructure for PhysicalDeviceVulkan12Properties {
46371     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES;
46372 }
46373 impl PhysicalDeviceVulkan12Properties {
builder<'a>() -> PhysicalDeviceVulkan12PropertiesBuilder<'a>46374     pub fn builder<'a>() -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
46375         PhysicalDeviceVulkan12PropertiesBuilder {
46376             inner: Self::default(),
46377             marker: ::std::marker::PhantomData,
46378         }
46379     }
46380 }
46381 #[repr(transparent)]
46382 pub struct PhysicalDeviceVulkan12PropertiesBuilder<'a> {
46383     inner: PhysicalDeviceVulkan12Properties,
46384     marker: ::std::marker::PhantomData<&'a ()>,
46385 }
46386 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan12PropertiesBuilder<'_> {}
46387 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan12Properties {}
46388 impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan12PropertiesBuilder<'a> {
46389     type Target = PhysicalDeviceVulkan12Properties;
deref(&self) -> &Self::Target46390     fn deref(&self) -> &Self::Target {
46391         &self.inner
46392     }
46393 }
46394 impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan12PropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target46395     fn deref_mut(&mut self) -> &mut Self::Target {
46396         &mut self.inner
46397     }
46398 }
46399 impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
46400     #[inline]
driver_id(mut self, driver_id: DriverId) -> Self46401     pub fn driver_id(mut self, driver_id: DriverId) -> Self {
46402         self.inner.driver_id = driver_id;
46403         self
46404     }
46405     #[inline]
driver_name(mut self, driver_name: [c_char; MAX_DRIVER_NAME_SIZE]) -> Self46406     pub fn driver_name(mut self, driver_name: [c_char; MAX_DRIVER_NAME_SIZE]) -> Self {
46407         self.inner.driver_name = driver_name;
46408         self
46409     }
46410     #[inline]
driver_info(mut self, driver_info: [c_char; MAX_DRIVER_INFO_SIZE]) -> Self46411     pub fn driver_info(mut self, driver_info: [c_char; MAX_DRIVER_INFO_SIZE]) -> Self {
46412         self.inner.driver_info = driver_info;
46413         self
46414     }
46415     #[inline]
conformance_version(mut self, conformance_version: ConformanceVersion) -> Self46416     pub fn conformance_version(mut self, conformance_version: ConformanceVersion) -> Self {
46417         self.inner.conformance_version = conformance_version;
46418         self
46419     }
46420     #[inline]
denorm_behavior_independence( mut self, denorm_behavior_independence: ShaderFloatControlsIndependence, ) -> Self46421     pub fn denorm_behavior_independence(
46422         mut self,
46423         denorm_behavior_independence: ShaderFloatControlsIndependence,
46424     ) -> Self {
46425         self.inner.denorm_behavior_independence = denorm_behavior_independence;
46426         self
46427     }
46428     #[inline]
rounding_mode_independence( mut self, rounding_mode_independence: ShaderFloatControlsIndependence, ) -> Self46429     pub fn rounding_mode_independence(
46430         mut self,
46431         rounding_mode_independence: ShaderFloatControlsIndependence,
46432     ) -> Self {
46433         self.inner.rounding_mode_independence = rounding_mode_independence;
46434         self
46435     }
46436     #[inline]
shader_signed_zero_inf_nan_preserve_float16( mut self, shader_signed_zero_inf_nan_preserve_float16: bool, ) -> Self46437     pub fn shader_signed_zero_inf_nan_preserve_float16(
46438         mut self,
46439         shader_signed_zero_inf_nan_preserve_float16: bool,
46440     ) -> Self {
46441         self.inner.shader_signed_zero_inf_nan_preserve_float16 =
46442             shader_signed_zero_inf_nan_preserve_float16.into();
46443         self
46444     }
46445     #[inline]
shader_signed_zero_inf_nan_preserve_float32( mut self, shader_signed_zero_inf_nan_preserve_float32: bool, ) -> Self46446     pub fn shader_signed_zero_inf_nan_preserve_float32(
46447         mut self,
46448         shader_signed_zero_inf_nan_preserve_float32: bool,
46449     ) -> Self {
46450         self.inner.shader_signed_zero_inf_nan_preserve_float32 =
46451             shader_signed_zero_inf_nan_preserve_float32.into();
46452         self
46453     }
46454     #[inline]
shader_signed_zero_inf_nan_preserve_float64( mut self, shader_signed_zero_inf_nan_preserve_float64: bool, ) -> Self46455     pub fn shader_signed_zero_inf_nan_preserve_float64(
46456         mut self,
46457         shader_signed_zero_inf_nan_preserve_float64: bool,
46458     ) -> Self {
46459         self.inner.shader_signed_zero_inf_nan_preserve_float64 =
46460             shader_signed_zero_inf_nan_preserve_float64.into();
46461         self
46462     }
46463     #[inline]
shader_denorm_preserve_float16(mut self, shader_denorm_preserve_float16: bool) -> Self46464     pub fn shader_denorm_preserve_float16(mut self, shader_denorm_preserve_float16: bool) -> Self {
46465         self.inner.shader_denorm_preserve_float16 = shader_denorm_preserve_float16.into();
46466         self
46467     }
46468     #[inline]
shader_denorm_preserve_float32(mut self, shader_denorm_preserve_float32: bool) -> Self46469     pub fn shader_denorm_preserve_float32(mut self, shader_denorm_preserve_float32: bool) -> Self {
46470         self.inner.shader_denorm_preserve_float32 = shader_denorm_preserve_float32.into();
46471         self
46472     }
46473     #[inline]
shader_denorm_preserve_float64(mut self, shader_denorm_preserve_float64: bool) -> Self46474     pub fn shader_denorm_preserve_float64(mut self, shader_denorm_preserve_float64: bool) -> Self {
46475         self.inner.shader_denorm_preserve_float64 = shader_denorm_preserve_float64.into();
46476         self
46477     }
46478     #[inline]
shader_denorm_flush_to_zero_float16( mut self, shader_denorm_flush_to_zero_float16: bool, ) -> Self46479     pub fn shader_denorm_flush_to_zero_float16(
46480         mut self,
46481         shader_denorm_flush_to_zero_float16: bool,
46482     ) -> Self {
46483         self.inner.shader_denorm_flush_to_zero_float16 = shader_denorm_flush_to_zero_float16.into();
46484         self
46485     }
46486     #[inline]
shader_denorm_flush_to_zero_float32( mut self, shader_denorm_flush_to_zero_float32: bool, ) -> Self46487     pub fn shader_denorm_flush_to_zero_float32(
46488         mut self,
46489         shader_denorm_flush_to_zero_float32: bool,
46490     ) -> Self {
46491         self.inner.shader_denorm_flush_to_zero_float32 = shader_denorm_flush_to_zero_float32.into();
46492         self
46493     }
46494     #[inline]
shader_denorm_flush_to_zero_float64( mut self, shader_denorm_flush_to_zero_float64: bool, ) -> Self46495     pub fn shader_denorm_flush_to_zero_float64(
46496         mut self,
46497         shader_denorm_flush_to_zero_float64: bool,
46498     ) -> Self {
46499         self.inner.shader_denorm_flush_to_zero_float64 = shader_denorm_flush_to_zero_float64.into();
46500         self
46501     }
46502     #[inline]
shader_rounding_mode_rte_float16( mut self, shader_rounding_mode_rte_float16: bool, ) -> Self46503     pub fn shader_rounding_mode_rte_float16(
46504         mut self,
46505         shader_rounding_mode_rte_float16: bool,
46506     ) -> Self {
46507         self.inner.shader_rounding_mode_rte_float16 = shader_rounding_mode_rte_float16.into();
46508         self
46509     }
46510     #[inline]
shader_rounding_mode_rte_float32( mut self, shader_rounding_mode_rte_float32: bool, ) -> Self46511     pub fn shader_rounding_mode_rte_float32(
46512         mut self,
46513         shader_rounding_mode_rte_float32: bool,
46514     ) -> Self {
46515         self.inner.shader_rounding_mode_rte_float32 = shader_rounding_mode_rte_float32.into();
46516         self
46517     }
46518     #[inline]
shader_rounding_mode_rte_float64( mut self, shader_rounding_mode_rte_float64: bool, ) -> Self46519     pub fn shader_rounding_mode_rte_float64(
46520         mut self,
46521         shader_rounding_mode_rte_float64: bool,
46522     ) -> Self {
46523         self.inner.shader_rounding_mode_rte_float64 = shader_rounding_mode_rte_float64.into();
46524         self
46525     }
46526     #[inline]
shader_rounding_mode_rtz_float16( mut self, shader_rounding_mode_rtz_float16: bool, ) -> Self46527     pub fn shader_rounding_mode_rtz_float16(
46528         mut self,
46529         shader_rounding_mode_rtz_float16: bool,
46530     ) -> Self {
46531         self.inner.shader_rounding_mode_rtz_float16 = shader_rounding_mode_rtz_float16.into();
46532         self
46533     }
46534     #[inline]
shader_rounding_mode_rtz_float32( mut self, shader_rounding_mode_rtz_float32: bool, ) -> Self46535     pub fn shader_rounding_mode_rtz_float32(
46536         mut self,
46537         shader_rounding_mode_rtz_float32: bool,
46538     ) -> Self {
46539         self.inner.shader_rounding_mode_rtz_float32 = shader_rounding_mode_rtz_float32.into();
46540         self
46541     }
46542     #[inline]
shader_rounding_mode_rtz_float64( mut self, shader_rounding_mode_rtz_float64: bool, ) -> Self46543     pub fn shader_rounding_mode_rtz_float64(
46544         mut self,
46545         shader_rounding_mode_rtz_float64: bool,
46546     ) -> Self {
46547         self.inner.shader_rounding_mode_rtz_float64 = shader_rounding_mode_rtz_float64.into();
46548         self
46549     }
46550     #[inline]
max_update_after_bind_descriptors_in_all_pools( mut self, max_update_after_bind_descriptors_in_all_pools: u32, ) -> Self46551     pub fn max_update_after_bind_descriptors_in_all_pools(
46552         mut self,
46553         max_update_after_bind_descriptors_in_all_pools: u32,
46554     ) -> Self {
46555         self.inner.max_update_after_bind_descriptors_in_all_pools =
46556             max_update_after_bind_descriptors_in_all_pools;
46557         self
46558     }
46559     #[inline]
shader_uniform_buffer_array_non_uniform_indexing_native( mut self, shader_uniform_buffer_array_non_uniform_indexing_native: bool, ) -> Self46560     pub fn shader_uniform_buffer_array_non_uniform_indexing_native(
46561         mut self,
46562         shader_uniform_buffer_array_non_uniform_indexing_native: bool,
46563     ) -> Self {
46564         self.inner
46565             .shader_uniform_buffer_array_non_uniform_indexing_native =
46566             shader_uniform_buffer_array_non_uniform_indexing_native.into();
46567         self
46568     }
46569     #[inline]
shader_sampled_image_array_non_uniform_indexing_native( mut self, shader_sampled_image_array_non_uniform_indexing_native: bool, ) -> Self46570     pub fn shader_sampled_image_array_non_uniform_indexing_native(
46571         mut self,
46572         shader_sampled_image_array_non_uniform_indexing_native: bool,
46573     ) -> Self {
46574         self.inner
46575             .shader_sampled_image_array_non_uniform_indexing_native =
46576             shader_sampled_image_array_non_uniform_indexing_native.into();
46577         self
46578     }
46579     #[inline]
shader_storage_buffer_array_non_uniform_indexing_native( mut self, shader_storage_buffer_array_non_uniform_indexing_native: bool, ) -> Self46580     pub fn shader_storage_buffer_array_non_uniform_indexing_native(
46581         mut self,
46582         shader_storage_buffer_array_non_uniform_indexing_native: bool,
46583     ) -> Self {
46584         self.inner
46585             .shader_storage_buffer_array_non_uniform_indexing_native =
46586             shader_storage_buffer_array_non_uniform_indexing_native.into();
46587         self
46588     }
46589     #[inline]
shader_storage_image_array_non_uniform_indexing_native( mut self, shader_storage_image_array_non_uniform_indexing_native: bool, ) -> Self46590     pub fn shader_storage_image_array_non_uniform_indexing_native(
46591         mut self,
46592         shader_storage_image_array_non_uniform_indexing_native: bool,
46593     ) -> Self {
46594         self.inner
46595             .shader_storage_image_array_non_uniform_indexing_native =
46596             shader_storage_image_array_non_uniform_indexing_native.into();
46597         self
46598     }
46599     #[inline]
shader_input_attachment_array_non_uniform_indexing_native( mut self, shader_input_attachment_array_non_uniform_indexing_native: bool, ) -> Self46600     pub fn shader_input_attachment_array_non_uniform_indexing_native(
46601         mut self,
46602         shader_input_attachment_array_non_uniform_indexing_native: bool,
46603     ) -> Self {
46604         self.inner
46605             .shader_input_attachment_array_non_uniform_indexing_native =
46606             shader_input_attachment_array_non_uniform_indexing_native.into();
46607         self
46608     }
46609     #[inline]
robust_buffer_access_update_after_bind( mut self, robust_buffer_access_update_after_bind: bool, ) -> Self46610     pub fn robust_buffer_access_update_after_bind(
46611         mut self,
46612         robust_buffer_access_update_after_bind: bool,
46613     ) -> Self {
46614         self.inner.robust_buffer_access_update_after_bind =
46615             robust_buffer_access_update_after_bind.into();
46616         self
46617     }
46618     #[inline]
quad_divergent_implicit_lod(mut self, quad_divergent_implicit_lod: bool) -> Self46619     pub fn quad_divergent_implicit_lod(mut self, quad_divergent_implicit_lod: bool) -> Self {
46620         self.inner.quad_divergent_implicit_lod = quad_divergent_implicit_lod.into();
46621         self
46622     }
46623     #[inline]
max_per_stage_descriptor_update_after_bind_samplers( mut self, max_per_stage_descriptor_update_after_bind_samplers: u32, ) -> Self46624     pub fn max_per_stage_descriptor_update_after_bind_samplers(
46625         mut self,
46626         max_per_stage_descriptor_update_after_bind_samplers: u32,
46627     ) -> Self {
46628         self.inner
46629             .max_per_stage_descriptor_update_after_bind_samplers =
46630             max_per_stage_descriptor_update_after_bind_samplers;
46631         self
46632     }
46633     #[inline]
max_per_stage_descriptor_update_after_bind_uniform_buffers( mut self, max_per_stage_descriptor_update_after_bind_uniform_buffers: u32, ) -> Self46634     pub fn max_per_stage_descriptor_update_after_bind_uniform_buffers(
46635         mut self,
46636         max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
46637     ) -> Self {
46638         self.inner
46639             .max_per_stage_descriptor_update_after_bind_uniform_buffers =
46640             max_per_stage_descriptor_update_after_bind_uniform_buffers;
46641         self
46642     }
46643     #[inline]
max_per_stage_descriptor_update_after_bind_storage_buffers( mut self, max_per_stage_descriptor_update_after_bind_storage_buffers: u32, ) -> Self46644     pub fn max_per_stage_descriptor_update_after_bind_storage_buffers(
46645         mut self,
46646         max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
46647     ) -> Self {
46648         self.inner
46649             .max_per_stage_descriptor_update_after_bind_storage_buffers =
46650             max_per_stage_descriptor_update_after_bind_storage_buffers;
46651         self
46652     }
46653     #[inline]
max_per_stage_descriptor_update_after_bind_sampled_images( mut self, max_per_stage_descriptor_update_after_bind_sampled_images: u32, ) -> Self46654     pub fn max_per_stage_descriptor_update_after_bind_sampled_images(
46655         mut self,
46656         max_per_stage_descriptor_update_after_bind_sampled_images: u32,
46657     ) -> Self {
46658         self.inner
46659             .max_per_stage_descriptor_update_after_bind_sampled_images =
46660             max_per_stage_descriptor_update_after_bind_sampled_images;
46661         self
46662     }
46663     #[inline]
max_per_stage_descriptor_update_after_bind_storage_images( mut self, max_per_stage_descriptor_update_after_bind_storage_images: u32, ) -> Self46664     pub fn max_per_stage_descriptor_update_after_bind_storage_images(
46665         mut self,
46666         max_per_stage_descriptor_update_after_bind_storage_images: u32,
46667     ) -> Self {
46668         self.inner
46669             .max_per_stage_descriptor_update_after_bind_storage_images =
46670             max_per_stage_descriptor_update_after_bind_storage_images;
46671         self
46672     }
46673     #[inline]
max_per_stage_descriptor_update_after_bind_input_attachments( mut self, max_per_stage_descriptor_update_after_bind_input_attachments: u32, ) -> Self46674     pub fn max_per_stage_descriptor_update_after_bind_input_attachments(
46675         mut self,
46676         max_per_stage_descriptor_update_after_bind_input_attachments: u32,
46677     ) -> Self {
46678         self.inner
46679             .max_per_stage_descriptor_update_after_bind_input_attachments =
46680             max_per_stage_descriptor_update_after_bind_input_attachments;
46681         self
46682     }
46683     #[inline]
max_per_stage_update_after_bind_resources( mut self, max_per_stage_update_after_bind_resources: u32, ) -> Self46684     pub fn max_per_stage_update_after_bind_resources(
46685         mut self,
46686         max_per_stage_update_after_bind_resources: u32,
46687     ) -> Self {
46688         self.inner.max_per_stage_update_after_bind_resources =
46689             max_per_stage_update_after_bind_resources;
46690         self
46691     }
46692     #[inline]
max_descriptor_set_update_after_bind_samplers( mut self, max_descriptor_set_update_after_bind_samplers: u32, ) -> Self46693     pub fn max_descriptor_set_update_after_bind_samplers(
46694         mut self,
46695         max_descriptor_set_update_after_bind_samplers: u32,
46696     ) -> Self {
46697         self.inner.max_descriptor_set_update_after_bind_samplers =
46698             max_descriptor_set_update_after_bind_samplers;
46699         self
46700     }
46701     #[inline]
max_descriptor_set_update_after_bind_uniform_buffers( mut self, max_descriptor_set_update_after_bind_uniform_buffers: u32, ) -> Self46702     pub fn max_descriptor_set_update_after_bind_uniform_buffers(
46703         mut self,
46704         max_descriptor_set_update_after_bind_uniform_buffers: u32,
46705     ) -> Self {
46706         self.inner
46707             .max_descriptor_set_update_after_bind_uniform_buffers =
46708             max_descriptor_set_update_after_bind_uniform_buffers;
46709         self
46710     }
46711     #[inline]
max_descriptor_set_update_after_bind_uniform_buffers_dynamic( mut self, max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32, ) -> Self46712     pub fn max_descriptor_set_update_after_bind_uniform_buffers_dynamic(
46713         mut self,
46714         max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
46715     ) -> Self {
46716         self.inner
46717             .max_descriptor_set_update_after_bind_uniform_buffers_dynamic =
46718             max_descriptor_set_update_after_bind_uniform_buffers_dynamic;
46719         self
46720     }
46721     #[inline]
max_descriptor_set_update_after_bind_storage_buffers( mut self, max_descriptor_set_update_after_bind_storage_buffers: u32, ) -> Self46722     pub fn max_descriptor_set_update_after_bind_storage_buffers(
46723         mut self,
46724         max_descriptor_set_update_after_bind_storage_buffers: u32,
46725     ) -> Self {
46726         self.inner
46727             .max_descriptor_set_update_after_bind_storage_buffers =
46728             max_descriptor_set_update_after_bind_storage_buffers;
46729         self
46730     }
46731     #[inline]
max_descriptor_set_update_after_bind_storage_buffers_dynamic( mut self, max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32, ) -> Self46732     pub fn max_descriptor_set_update_after_bind_storage_buffers_dynamic(
46733         mut self,
46734         max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
46735     ) -> Self {
46736         self.inner
46737             .max_descriptor_set_update_after_bind_storage_buffers_dynamic =
46738             max_descriptor_set_update_after_bind_storage_buffers_dynamic;
46739         self
46740     }
46741     #[inline]
max_descriptor_set_update_after_bind_sampled_images( mut self, max_descriptor_set_update_after_bind_sampled_images: u32, ) -> Self46742     pub fn max_descriptor_set_update_after_bind_sampled_images(
46743         mut self,
46744         max_descriptor_set_update_after_bind_sampled_images: u32,
46745     ) -> Self {
46746         self.inner
46747             .max_descriptor_set_update_after_bind_sampled_images =
46748             max_descriptor_set_update_after_bind_sampled_images;
46749         self
46750     }
46751     #[inline]
max_descriptor_set_update_after_bind_storage_images( mut self, max_descriptor_set_update_after_bind_storage_images: u32, ) -> Self46752     pub fn max_descriptor_set_update_after_bind_storage_images(
46753         mut self,
46754         max_descriptor_set_update_after_bind_storage_images: u32,
46755     ) -> Self {
46756         self.inner
46757             .max_descriptor_set_update_after_bind_storage_images =
46758             max_descriptor_set_update_after_bind_storage_images;
46759         self
46760     }
46761     #[inline]
max_descriptor_set_update_after_bind_input_attachments( mut self, max_descriptor_set_update_after_bind_input_attachments: u32, ) -> Self46762     pub fn max_descriptor_set_update_after_bind_input_attachments(
46763         mut self,
46764         max_descriptor_set_update_after_bind_input_attachments: u32,
46765     ) -> Self {
46766         self.inner
46767             .max_descriptor_set_update_after_bind_input_attachments =
46768             max_descriptor_set_update_after_bind_input_attachments;
46769         self
46770     }
46771     #[inline]
supported_depth_resolve_modes( mut self, supported_depth_resolve_modes: ResolveModeFlags, ) -> Self46772     pub fn supported_depth_resolve_modes(
46773         mut self,
46774         supported_depth_resolve_modes: ResolveModeFlags,
46775     ) -> Self {
46776         self.inner.supported_depth_resolve_modes = supported_depth_resolve_modes;
46777         self
46778     }
46779     #[inline]
supported_stencil_resolve_modes( mut self, supported_stencil_resolve_modes: ResolveModeFlags, ) -> Self46780     pub fn supported_stencil_resolve_modes(
46781         mut self,
46782         supported_stencil_resolve_modes: ResolveModeFlags,
46783     ) -> Self {
46784         self.inner.supported_stencil_resolve_modes = supported_stencil_resolve_modes;
46785         self
46786     }
46787     #[inline]
independent_resolve_none(mut self, independent_resolve_none: bool) -> Self46788     pub fn independent_resolve_none(mut self, independent_resolve_none: bool) -> Self {
46789         self.inner.independent_resolve_none = independent_resolve_none.into();
46790         self
46791     }
46792     #[inline]
independent_resolve(mut self, independent_resolve: bool) -> Self46793     pub fn independent_resolve(mut self, independent_resolve: bool) -> Self {
46794         self.inner.independent_resolve = independent_resolve.into();
46795         self
46796     }
46797     #[inline]
filter_minmax_single_component_formats( mut self, filter_minmax_single_component_formats: bool, ) -> Self46798     pub fn filter_minmax_single_component_formats(
46799         mut self,
46800         filter_minmax_single_component_formats: bool,
46801     ) -> Self {
46802         self.inner.filter_minmax_single_component_formats =
46803             filter_minmax_single_component_formats.into();
46804         self
46805     }
46806     #[inline]
filter_minmax_image_component_mapping( mut self, filter_minmax_image_component_mapping: bool, ) -> Self46807     pub fn filter_minmax_image_component_mapping(
46808         mut self,
46809         filter_minmax_image_component_mapping: bool,
46810     ) -> Self {
46811         self.inner.filter_minmax_image_component_mapping =
46812             filter_minmax_image_component_mapping.into();
46813         self
46814     }
46815     #[inline]
max_timeline_semaphore_value_difference( mut self, max_timeline_semaphore_value_difference: u64, ) -> Self46816     pub fn max_timeline_semaphore_value_difference(
46817         mut self,
46818         max_timeline_semaphore_value_difference: u64,
46819     ) -> Self {
46820         self.inner.max_timeline_semaphore_value_difference =
46821             max_timeline_semaphore_value_difference;
46822         self
46823     }
46824     #[inline]
framebuffer_integer_color_sample_counts( mut self, framebuffer_integer_color_sample_counts: SampleCountFlags, ) -> Self46825     pub fn framebuffer_integer_color_sample_counts(
46826         mut self,
46827         framebuffer_integer_color_sample_counts: SampleCountFlags,
46828     ) -> Self {
46829         self.inner.framebuffer_integer_color_sample_counts =
46830             framebuffer_integer_color_sample_counts;
46831         self
46832     }
46833     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46834     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46835     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceVulkan12Properties46836     pub fn build(self) -> PhysicalDeviceVulkan12Properties {
46837         self.inner
46838     }
46839 }
46840 #[repr(C)]
46841 #[cfg_attr(feature = "debug", derive(Debug))]
46842 #[derive(Copy, Clone)]
46843 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkan13Features.html>"]
46844 pub struct PhysicalDeviceVulkan13Features {
46845     pub s_type: StructureType,
46846     pub p_next: *mut c_void,
46847     pub robust_image_access: Bool32,
46848     pub inline_uniform_block: Bool32,
46849     pub descriptor_binding_inline_uniform_block_update_after_bind: Bool32,
46850     pub pipeline_creation_cache_control: Bool32,
46851     pub private_data: Bool32,
46852     pub shader_demote_to_helper_invocation: Bool32,
46853     pub shader_terminate_invocation: Bool32,
46854     pub subgroup_size_control: Bool32,
46855     pub compute_full_subgroups: Bool32,
46856     pub synchronization2: Bool32,
46857     pub texture_compression_astc_hdr: Bool32,
46858     pub shader_zero_initialize_workgroup_memory: Bool32,
46859     pub dynamic_rendering: Bool32,
46860     pub shader_integer_dot_product: Bool32,
46861     pub maintenance4: Bool32,
46862 }
46863 impl ::std::default::Default for PhysicalDeviceVulkan13Features {
46864     #[inline]
default() -> Self46865     fn default() -> Self {
46866         Self {
46867             s_type: Self::STRUCTURE_TYPE,
46868             p_next: ::std::ptr::null_mut(),
46869             robust_image_access: Bool32::default(),
46870             inline_uniform_block: Bool32::default(),
46871             descriptor_binding_inline_uniform_block_update_after_bind: Bool32::default(),
46872             pipeline_creation_cache_control: Bool32::default(),
46873             private_data: Bool32::default(),
46874             shader_demote_to_helper_invocation: Bool32::default(),
46875             shader_terminate_invocation: Bool32::default(),
46876             subgroup_size_control: Bool32::default(),
46877             compute_full_subgroups: Bool32::default(),
46878             synchronization2: Bool32::default(),
46879             texture_compression_astc_hdr: Bool32::default(),
46880             shader_zero_initialize_workgroup_memory: Bool32::default(),
46881             dynamic_rendering: Bool32::default(),
46882             shader_integer_dot_product: Bool32::default(),
46883             maintenance4: Bool32::default(),
46884         }
46885     }
46886 }
46887 unsafe impl TaggedStructure for PhysicalDeviceVulkan13Features {
46888     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
46889 }
46890 impl PhysicalDeviceVulkan13Features {
builder<'a>() -> PhysicalDeviceVulkan13FeaturesBuilder<'a>46891     pub fn builder<'a>() -> PhysicalDeviceVulkan13FeaturesBuilder<'a> {
46892         PhysicalDeviceVulkan13FeaturesBuilder {
46893             inner: Self::default(),
46894             marker: ::std::marker::PhantomData,
46895         }
46896     }
46897 }
46898 #[repr(transparent)]
46899 pub struct PhysicalDeviceVulkan13FeaturesBuilder<'a> {
46900     inner: PhysicalDeviceVulkan13Features,
46901     marker: ::std::marker::PhantomData<&'a ()>,
46902 }
46903 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan13FeaturesBuilder<'_> {}
46904 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan13Features {}
46905 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan13FeaturesBuilder<'_> {}
46906 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan13Features {}
46907 impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan13FeaturesBuilder<'a> {
46908     type Target = PhysicalDeviceVulkan13Features;
deref(&self) -> &Self::Target46909     fn deref(&self) -> &Self::Target {
46910         &self.inner
46911     }
46912 }
46913 impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan13FeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target46914     fn deref_mut(&mut self) -> &mut Self::Target {
46915         &mut self.inner
46916     }
46917 }
46918 impl<'a> PhysicalDeviceVulkan13FeaturesBuilder<'a> {
46919     #[inline]
robust_image_access(mut self, robust_image_access: bool) -> Self46920     pub fn robust_image_access(mut self, robust_image_access: bool) -> Self {
46921         self.inner.robust_image_access = robust_image_access.into();
46922         self
46923     }
46924     #[inline]
inline_uniform_block(mut self, inline_uniform_block: bool) -> Self46925     pub fn inline_uniform_block(mut self, inline_uniform_block: bool) -> Self {
46926         self.inner.inline_uniform_block = inline_uniform_block.into();
46927         self
46928     }
46929     #[inline]
descriptor_binding_inline_uniform_block_update_after_bind( mut self, descriptor_binding_inline_uniform_block_update_after_bind: bool, ) -> Self46930     pub fn descriptor_binding_inline_uniform_block_update_after_bind(
46931         mut self,
46932         descriptor_binding_inline_uniform_block_update_after_bind: bool,
46933     ) -> Self {
46934         self.inner
46935             .descriptor_binding_inline_uniform_block_update_after_bind =
46936             descriptor_binding_inline_uniform_block_update_after_bind.into();
46937         self
46938     }
46939     #[inline]
pipeline_creation_cache_control( mut self, pipeline_creation_cache_control: bool, ) -> Self46940     pub fn pipeline_creation_cache_control(
46941         mut self,
46942         pipeline_creation_cache_control: bool,
46943     ) -> Self {
46944         self.inner.pipeline_creation_cache_control = pipeline_creation_cache_control.into();
46945         self
46946     }
46947     #[inline]
private_data(mut self, private_data: bool) -> Self46948     pub fn private_data(mut self, private_data: bool) -> Self {
46949         self.inner.private_data = private_data.into();
46950         self
46951     }
46952     #[inline]
shader_demote_to_helper_invocation( mut self, shader_demote_to_helper_invocation: bool, ) -> Self46953     pub fn shader_demote_to_helper_invocation(
46954         mut self,
46955         shader_demote_to_helper_invocation: bool,
46956     ) -> Self {
46957         self.inner.shader_demote_to_helper_invocation = shader_demote_to_helper_invocation.into();
46958         self
46959     }
46960     #[inline]
shader_terminate_invocation(mut self, shader_terminate_invocation: bool) -> Self46961     pub fn shader_terminate_invocation(mut self, shader_terminate_invocation: bool) -> Self {
46962         self.inner.shader_terminate_invocation = shader_terminate_invocation.into();
46963         self
46964     }
46965     #[inline]
subgroup_size_control(mut self, subgroup_size_control: bool) -> Self46966     pub fn subgroup_size_control(mut self, subgroup_size_control: bool) -> Self {
46967         self.inner.subgroup_size_control = subgroup_size_control.into();
46968         self
46969     }
46970     #[inline]
compute_full_subgroups(mut self, compute_full_subgroups: bool) -> Self46971     pub fn compute_full_subgroups(mut self, compute_full_subgroups: bool) -> Self {
46972         self.inner.compute_full_subgroups = compute_full_subgroups.into();
46973         self
46974     }
46975     #[inline]
synchronization2(mut self, synchronization2: bool) -> Self46976     pub fn synchronization2(mut self, synchronization2: bool) -> Self {
46977         self.inner.synchronization2 = synchronization2.into();
46978         self
46979     }
46980     #[inline]
texture_compression_astc_hdr(mut self, texture_compression_astc_hdr: bool) -> Self46981     pub fn texture_compression_astc_hdr(mut self, texture_compression_astc_hdr: bool) -> Self {
46982         self.inner.texture_compression_astc_hdr = texture_compression_astc_hdr.into();
46983         self
46984     }
46985     #[inline]
shader_zero_initialize_workgroup_memory( mut self, shader_zero_initialize_workgroup_memory: bool, ) -> Self46986     pub fn shader_zero_initialize_workgroup_memory(
46987         mut self,
46988         shader_zero_initialize_workgroup_memory: bool,
46989     ) -> Self {
46990         self.inner.shader_zero_initialize_workgroup_memory =
46991             shader_zero_initialize_workgroup_memory.into();
46992         self
46993     }
46994     #[inline]
dynamic_rendering(mut self, dynamic_rendering: bool) -> Self46995     pub fn dynamic_rendering(mut self, dynamic_rendering: bool) -> Self {
46996         self.inner.dynamic_rendering = dynamic_rendering.into();
46997         self
46998     }
46999     #[inline]
shader_integer_dot_product(mut self, shader_integer_dot_product: bool) -> Self47000     pub fn shader_integer_dot_product(mut self, shader_integer_dot_product: bool) -> Self {
47001         self.inner.shader_integer_dot_product = shader_integer_dot_product.into();
47002         self
47003     }
47004     #[inline]
maintenance4(mut self, maintenance4: bool) -> Self47005     pub fn maintenance4(mut self, maintenance4: bool) -> Self {
47006         self.inner.maintenance4 = maintenance4.into();
47007         self
47008     }
47009     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47010     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47011     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceVulkan13Features47012     pub fn build(self) -> PhysicalDeviceVulkan13Features {
47013         self.inner
47014     }
47015 }
47016 #[repr(C)]
47017 #[cfg_attr(feature = "debug", derive(Debug))]
47018 #[derive(Copy, Clone)]
47019 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkan13Properties.html>"]
47020 pub struct PhysicalDeviceVulkan13Properties {
47021     pub s_type: StructureType,
47022     pub p_next: *mut c_void,
47023     pub min_subgroup_size: u32,
47024     pub max_subgroup_size: u32,
47025     pub max_compute_workgroup_subgroups: u32,
47026     pub required_subgroup_size_stages: ShaderStageFlags,
47027     pub max_inline_uniform_block_size: u32,
47028     pub max_per_stage_descriptor_inline_uniform_blocks: u32,
47029     pub max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32,
47030     pub max_descriptor_set_inline_uniform_blocks: u32,
47031     pub max_descriptor_set_update_after_bind_inline_uniform_blocks: u32,
47032     pub max_inline_uniform_total_size: u32,
47033     pub integer_dot_product8_bit_unsigned_accelerated: Bool32,
47034     pub integer_dot_product8_bit_signed_accelerated: Bool32,
47035     pub integer_dot_product8_bit_mixed_signedness_accelerated: Bool32,
47036     pub integer_dot_product4x8_bit_packed_unsigned_accelerated: Bool32,
47037     pub integer_dot_product4x8_bit_packed_signed_accelerated: Bool32,
47038     pub integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: Bool32,
47039     pub integer_dot_product16_bit_unsigned_accelerated: Bool32,
47040     pub integer_dot_product16_bit_signed_accelerated: Bool32,
47041     pub integer_dot_product16_bit_mixed_signedness_accelerated: Bool32,
47042     pub integer_dot_product32_bit_unsigned_accelerated: Bool32,
47043     pub integer_dot_product32_bit_signed_accelerated: Bool32,
47044     pub integer_dot_product32_bit_mixed_signedness_accelerated: Bool32,
47045     pub integer_dot_product64_bit_unsigned_accelerated: Bool32,
47046     pub integer_dot_product64_bit_signed_accelerated: Bool32,
47047     pub integer_dot_product64_bit_mixed_signedness_accelerated: Bool32,
47048     pub integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: Bool32,
47049     pub integer_dot_product_accumulating_saturating8_bit_signed_accelerated: Bool32,
47050     pub integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: Bool32,
47051     pub integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: Bool32,
47052     pub integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: Bool32,
47053     pub integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated:
47054         Bool32,
47055     pub integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: Bool32,
47056     pub integer_dot_product_accumulating_saturating16_bit_signed_accelerated: Bool32,
47057     pub integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: Bool32,
47058     pub integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: Bool32,
47059     pub integer_dot_product_accumulating_saturating32_bit_signed_accelerated: Bool32,
47060     pub integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: Bool32,
47061     pub integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: Bool32,
47062     pub integer_dot_product_accumulating_saturating64_bit_signed_accelerated: Bool32,
47063     pub integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: Bool32,
47064     pub storage_texel_buffer_offset_alignment_bytes: DeviceSize,
47065     pub storage_texel_buffer_offset_single_texel_alignment: Bool32,
47066     pub uniform_texel_buffer_offset_alignment_bytes: DeviceSize,
47067     pub uniform_texel_buffer_offset_single_texel_alignment: Bool32,
47068     pub max_buffer_size: DeviceSize,
47069 }
47070 impl ::std::default::Default for PhysicalDeviceVulkan13Properties {
47071     #[inline]
default() -> Self47072     fn default() -> Self {
47073         Self { s_type : Self :: STRUCTURE_TYPE , p_next : :: std :: ptr :: null_mut () , min_subgroup_size : u32 :: default () , max_subgroup_size : u32 :: default () , max_compute_workgroup_subgroups : u32 :: default () , required_subgroup_size_stages : ShaderStageFlags :: default () , max_inline_uniform_block_size : u32 :: default () , max_per_stage_descriptor_inline_uniform_blocks : u32 :: default () , max_per_stage_descriptor_update_after_bind_inline_uniform_blocks : u32 :: default () , max_descriptor_set_inline_uniform_blocks : u32 :: default () , max_descriptor_set_update_after_bind_inline_uniform_blocks : u32 :: default () , max_inline_uniform_total_size : u32 :: default () , integer_dot_product8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product64_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated : Bool32 :: default () , storage_texel_buffer_offset_alignment_bytes : DeviceSize :: default () , storage_texel_buffer_offset_single_texel_alignment : Bool32 :: default () , uniform_texel_buffer_offset_alignment_bytes : DeviceSize :: default () , uniform_texel_buffer_offset_single_texel_alignment : Bool32 :: default () , max_buffer_size : DeviceSize :: default () }
47074     }
47075 }
47076 unsafe impl TaggedStructure for PhysicalDeviceVulkan13Properties {
47077     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES;
47078 }
47079 impl PhysicalDeviceVulkan13Properties {
builder<'a>() -> PhysicalDeviceVulkan13PropertiesBuilder<'a>47080     pub fn builder<'a>() -> PhysicalDeviceVulkan13PropertiesBuilder<'a> {
47081         PhysicalDeviceVulkan13PropertiesBuilder {
47082             inner: Self::default(),
47083             marker: ::std::marker::PhantomData,
47084         }
47085     }
47086 }
47087 #[repr(transparent)]
47088 pub struct PhysicalDeviceVulkan13PropertiesBuilder<'a> {
47089     inner: PhysicalDeviceVulkan13Properties,
47090     marker: ::std::marker::PhantomData<&'a ()>,
47091 }
47092 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan13PropertiesBuilder<'_> {}
47093 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan13Properties {}
47094 impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan13PropertiesBuilder<'a> {
47095     type Target = PhysicalDeviceVulkan13Properties;
deref(&self) -> &Self::Target47096     fn deref(&self) -> &Self::Target {
47097         &self.inner
47098     }
47099 }
47100 impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan13PropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target47101     fn deref_mut(&mut self) -> &mut Self::Target {
47102         &mut self.inner
47103     }
47104 }
47105 impl<'a> PhysicalDeviceVulkan13PropertiesBuilder<'a> {
47106     #[inline]
min_subgroup_size(mut self, min_subgroup_size: u32) -> Self47107     pub fn min_subgroup_size(mut self, min_subgroup_size: u32) -> Self {
47108         self.inner.min_subgroup_size = min_subgroup_size;
47109         self
47110     }
47111     #[inline]
max_subgroup_size(mut self, max_subgroup_size: u32) -> Self47112     pub fn max_subgroup_size(mut self, max_subgroup_size: u32) -> Self {
47113         self.inner.max_subgroup_size = max_subgroup_size;
47114         self
47115     }
47116     #[inline]
max_compute_workgroup_subgroups(mut self, max_compute_workgroup_subgroups: u32) -> Self47117     pub fn max_compute_workgroup_subgroups(mut self, max_compute_workgroup_subgroups: u32) -> Self {
47118         self.inner.max_compute_workgroup_subgroups = max_compute_workgroup_subgroups;
47119         self
47120     }
47121     #[inline]
required_subgroup_size_stages( mut self, required_subgroup_size_stages: ShaderStageFlags, ) -> Self47122     pub fn required_subgroup_size_stages(
47123         mut self,
47124         required_subgroup_size_stages: ShaderStageFlags,
47125     ) -> Self {
47126         self.inner.required_subgroup_size_stages = required_subgroup_size_stages;
47127         self
47128     }
47129     #[inline]
max_inline_uniform_block_size(mut self, max_inline_uniform_block_size: u32) -> Self47130     pub fn max_inline_uniform_block_size(mut self, max_inline_uniform_block_size: u32) -> Self {
47131         self.inner.max_inline_uniform_block_size = max_inline_uniform_block_size;
47132         self
47133     }
47134     #[inline]
max_per_stage_descriptor_inline_uniform_blocks( mut self, max_per_stage_descriptor_inline_uniform_blocks: u32, ) -> Self47135     pub fn max_per_stage_descriptor_inline_uniform_blocks(
47136         mut self,
47137         max_per_stage_descriptor_inline_uniform_blocks: u32,
47138     ) -> Self {
47139         self.inner.max_per_stage_descriptor_inline_uniform_blocks =
47140             max_per_stage_descriptor_inline_uniform_blocks;
47141         self
47142     }
47143     #[inline]
max_per_stage_descriptor_update_after_bind_inline_uniform_blocks( mut self, max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32, ) -> Self47144     pub fn max_per_stage_descriptor_update_after_bind_inline_uniform_blocks(
47145         mut self,
47146         max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32,
47147     ) -> Self {
47148         self.inner
47149             .max_per_stage_descriptor_update_after_bind_inline_uniform_blocks =
47150             max_per_stage_descriptor_update_after_bind_inline_uniform_blocks;
47151         self
47152     }
47153     #[inline]
max_descriptor_set_inline_uniform_blocks( mut self, max_descriptor_set_inline_uniform_blocks: u32, ) -> Self47154     pub fn max_descriptor_set_inline_uniform_blocks(
47155         mut self,
47156         max_descriptor_set_inline_uniform_blocks: u32,
47157     ) -> Self {
47158         self.inner.max_descriptor_set_inline_uniform_blocks =
47159             max_descriptor_set_inline_uniform_blocks;
47160         self
47161     }
47162     #[inline]
max_descriptor_set_update_after_bind_inline_uniform_blocks( mut self, max_descriptor_set_update_after_bind_inline_uniform_blocks: u32, ) -> Self47163     pub fn max_descriptor_set_update_after_bind_inline_uniform_blocks(
47164         mut self,
47165         max_descriptor_set_update_after_bind_inline_uniform_blocks: u32,
47166     ) -> Self {
47167         self.inner
47168             .max_descriptor_set_update_after_bind_inline_uniform_blocks =
47169             max_descriptor_set_update_after_bind_inline_uniform_blocks;
47170         self
47171     }
47172     #[inline]
max_inline_uniform_total_size(mut self, max_inline_uniform_total_size: u32) -> Self47173     pub fn max_inline_uniform_total_size(mut self, max_inline_uniform_total_size: u32) -> Self {
47174         self.inner.max_inline_uniform_total_size = max_inline_uniform_total_size;
47175         self
47176     }
47177     #[inline]
integer_dot_product8_bit_unsigned_accelerated( mut self, integer_dot_product8_bit_unsigned_accelerated: bool, ) -> Self47178     pub fn integer_dot_product8_bit_unsigned_accelerated(
47179         mut self,
47180         integer_dot_product8_bit_unsigned_accelerated: bool,
47181     ) -> Self {
47182         self.inner.integer_dot_product8_bit_unsigned_accelerated =
47183             integer_dot_product8_bit_unsigned_accelerated.into();
47184         self
47185     }
47186     #[inline]
integer_dot_product8_bit_signed_accelerated( mut self, integer_dot_product8_bit_signed_accelerated: bool, ) -> Self47187     pub fn integer_dot_product8_bit_signed_accelerated(
47188         mut self,
47189         integer_dot_product8_bit_signed_accelerated: bool,
47190     ) -> Self {
47191         self.inner.integer_dot_product8_bit_signed_accelerated =
47192             integer_dot_product8_bit_signed_accelerated.into();
47193         self
47194     }
47195     #[inline]
integer_dot_product8_bit_mixed_signedness_accelerated( mut self, integer_dot_product8_bit_mixed_signedness_accelerated: bool, ) -> Self47196     pub fn integer_dot_product8_bit_mixed_signedness_accelerated(
47197         mut self,
47198         integer_dot_product8_bit_mixed_signedness_accelerated: bool,
47199     ) -> Self {
47200         self.inner
47201             .integer_dot_product8_bit_mixed_signedness_accelerated =
47202             integer_dot_product8_bit_mixed_signedness_accelerated.into();
47203         self
47204     }
47205     #[inline]
integer_dot_product4x8_bit_packed_unsigned_accelerated( mut self, integer_dot_product4x8_bit_packed_unsigned_accelerated: bool, ) -> Self47206     pub fn integer_dot_product4x8_bit_packed_unsigned_accelerated(
47207         mut self,
47208         integer_dot_product4x8_bit_packed_unsigned_accelerated: bool,
47209     ) -> Self {
47210         self.inner
47211             .integer_dot_product4x8_bit_packed_unsigned_accelerated =
47212             integer_dot_product4x8_bit_packed_unsigned_accelerated.into();
47213         self
47214     }
47215     #[inline]
integer_dot_product4x8_bit_packed_signed_accelerated( mut self, integer_dot_product4x8_bit_packed_signed_accelerated: bool, ) -> Self47216     pub fn integer_dot_product4x8_bit_packed_signed_accelerated(
47217         mut self,
47218         integer_dot_product4x8_bit_packed_signed_accelerated: bool,
47219     ) -> Self {
47220         self.inner
47221             .integer_dot_product4x8_bit_packed_signed_accelerated =
47222             integer_dot_product4x8_bit_packed_signed_accelerated.into();
47223         self
47224     }
47225     #[inline]
integer_dot_product4x8_bit_packed_mixed_signedness_accelerated( mut self, integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: bool, ) -> Self47226     pub fn integer_dot_product4x8_bit_packed_mixed_signedness_accelerated(
47227         mut self,
47228         integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: bool,
47229     ) -> Self {
47230         self.inner
47231             .integer_dot_product4x8_bit_packed_mixed_signedness_accelerated =
47232             integer_dot_product4x8_bit_packed_mixed_signedness_accelerated.into();
47233         self
47234     }
47235     #[inline]
integer_dot_product16_bit_unsigned_accelerated( mut self, integer_dot_product16_bit_unsigned_accelerated: bool, ) -> Self47236     pub fn integer_dot_product16_bit_unsigned_accelerated(
47237         mut self,
47238         integer_dot_product16_bit_unsigned_accelerated: bool,
47239     ) -> Self {
47240         self.inner.integer_dot_product16_bit_unsigned_accelerated =
47241             integer_dot_product16_bit_unsigned_accelerated.into();
47242         self
47243     }
47244     #[inline]
integer_dot_product16_bit_signed_accelerated( mut self, integer_dot_product16_bit_signed_accelerated: bool, ) -> Self47245     pub fn integer_dot_product16_bit_signed_accelerated(
47246         mut self,
47247         integer_dot_product16_bit_signed_accelerated: bool,
47248     ) -> Self {
47249         self.inner.integer_dot_product16_bit_signed_accelerated =
47250             integer_dot_product16_bit_signed_accelerated.into();
47251         self
47252     }
47253     #[inline]
integer_dot_product16_bit_mixed_signedness_accelerated( mut self, integer_dot_product16_bit_mixed_signedness_accelerated: bool, ) -> Self47254     pub fn integer_dot_product16_bit_mixed_signedness_accelerated(
47255         mut self,
47256         integer_dot_product16_bit_mixed_signedness_accelerated: bool,
47257     ) -> Self {
47258         self.inner
47259             .integer_dot_product16_bit_mixed_signedness_accelerated =
47260             integer_dot_product16_bit_mixed_signedness_accelerated.into();
47261         self
47262     }
47263     #[inline]
integer_dot_product32_bit_unsigned_accelerated( mut self, integer_dot_product32_bit_unsigned_accelerated: bool, ) -> Self47264     pub fn integer_dot_product32_bit_unsigned_accelerated(
47265         mut self,
47266         integer_dot_product32_bit_unsigned_accelerated: bool,
47267     ) -> Self {
47268         self.inner.integer_dot_product32_bit_unsigned_accelerated =
47269             integer_dot_product32_bit_unsigned_accelerated.into();
47270         self
47271     }
47272     #[inline]
integer_dot_product32_bit_signed_accelerated( mut self, integer_dot_product32_bit_signed_accelerated: bool, ) -> Self47273     pub fn integer_dot_product32_bit_signed_accelerated(
47274         mut self,
47275         integer_dot_product32_bit_signed_accelerated: bool,
47276     ) -> Self {
47277         self.inner.integer_dot_product32_bit_signed_accelerated =
47278             integer_dot_product32_bit_signed_accelerated.into();
47279         self
47280     }
47281     #[inline]
integer_dot_product32_bit_mixed_signedness_accelerated( mut self, integer_dot_product32_bit_mixed_signedness_accelerated: bool, ) -> Self47282     pub fn integer_dot_product32_bit_mixed_signedness_accelerated(
47283         mut self,
47284         integer_dot_product32_bit_mixed_signedness_accelerated: bool,
47285     ) -> Self {
47286         self.inner
47287             .integer_dot_product32_bit_mixed_signedness_accelerated =
47288             integer_dot_product32_bit_mixed_signedness_accelerated.into();
47289         self
47290     }
47291     #[inline]
integer_dot_product64_bit_unsigned_accelerated( mut self, integer_dot_product64_bit_unsigned_accelerated: bool, ) -> Self47292     pub fn integer_dot_product64_bit_unsigned_accelerated(
47293         mut self,
47294         integer_dot_product64_bit_unsigned_accelerated: bool,
47295     ) -> Self {
47296         self.inner.integer_dot_product64_bit_unsigned_accelerated =
47297             integer_dot_product64_bit_unsigned_accelerated.into();
47298         self
47299     }
47300     #[inline]
integer_dot_product64_bit_signed_accelerated( mut self, integer_dot_product64_bit_signed_accelerated: bool, ) -> Self47301     pub fn integer_dot_product64_bit_signed_accelerated(
47302         mut self,
47303         integer_dot_product64_bit_signed_accelerated: bool,
47304     ) -> Self {
47305         self.inner.integer_dot_product64_bit_signed_accelerated =
47306             integer_dot_product64_bit_signed_accelerated.into();
47307         self
47308     }
47309     #[inline]
integer_dot_product64_bit_mixed_signedness_accelerated( mut self, integer_dot_product64_bit_mixed_signedness_accelerated: bool, ) -> Self47310     pub fn integer_dot_product64_bit_mixed_signedness_accelerated(
47311         mut self,
47312         integer_dot_product64_bit_mixed_signedness_accelerated: bool,
47313     ) -> Self {
47314         self.inner
47315             .integer_dot_product64_bit_mixed_signedness_accelerated =
47316             integer_dot_product64_bit_mixed_signedness_accelerated.into();
47317         self
47318     }
47319     #[inline]
integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated( mut self, integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: bool, ) -> Self47320     pub fn integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated(
47321         mut self,
47322         integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: bool,
47323     ) -> Self {
47324         self.inner
47325             .integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated =
47326             integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated.into();
47327         self
47328     }
47329     #[inline]
integer_dot_product_accumulating_saturating8_bit_signed_accelerated( mut self, integer_dot_product_accumulating_saturating8_bit_signed_accelerated: bool, ) -> Self47330     pub fn integer_dot_product_accumulating_saturating8_bit_signed_accelerated(
47331         mut self,
47332         integer_dot_product_accumulating_saturating8_bit_signed_accelerated: bool,
47333     ) -> Self {
47334         self.inner
47335             .integer_dot_product_accumulating_saturating8_bit_signed_accelerated =
47336             integer_dot_product_accumulating_saturating8_bit_signed_accelerated.into();
47337         self
47338     }
47339     #[inline]
integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated( mut self, integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: bool, ) -> Self47340     pub fn integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated(
47341         mut self,
47342         integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: bool,
47343     ) -> Self {
47344         self.inner
47345             .integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated =
47346             integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated.into();
47347         self
47348     }
47349     #[inline]
integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated( mut self, integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: bool, ) -> Self47350     pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated(
47351         mut self,
47352         integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: bool,
47353     ) -> Self {
47354         self.inner
47355             .integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated =
47356             integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated.into();
47357         self
47358     }
47359     #[inline]
integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated( mut self, integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: bool, ) -> Self47360     pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated(
47361         mut self,
47362         integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: bool,
47363     ) -> Self {
47364         self.inner
47365             .integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated =
47366             integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated.into();
47367         self
47368     }
47369     #[inline]
integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated( mut self, integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : bool, ) -> Self47370     pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated(
47371         mut self,
47372         integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : bool,
47373     ) -> Self {
47374         self . inner . integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated . into () ;
47375         self
47376     }
47377     #[inline]
integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated( mut self, integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: bool, ) -> Self47378     pub fn integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated(
47379         mut self,
47380         integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: bool,
47381     ) -> Self {
47382         self.inner
47383             .integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated =
47384             integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated.into();
47385         self
47386     }
47387     #[inline]
integer_dot_product_accumulating_saturating16_bit_signed_accelerated( mut self, integer_dot_product_accumulating_saturating16_bit_signed_accelerated: bool, ) -> Self47388     pub fn integer_dot_product_accumulating_saturating16_bit_signed_accelerated(
47389         mut self,
47390         integer_dot_product_accumulating_saturating16_bit_signed_accelerated: bool,
47391     ) -> Self {
47392         self.inner
47393             .integer_dot_product_accumulating_saturating16_bit_signed_accelerated =
47394             integer_dot_product_accumulating_saturating16_bit_signed_accelerated.into();
47395         self
47396     }
47397     #[inline]
integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated( mut self, integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: bool, ) -> Self47398     pub fn integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated(
47399         mut self,
47400         integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: bool,
47401     ) -> Self {
47402         self.inner
47403             .integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated =
47404             integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated.into();
47405         self
47406     }
47407     #[inline]
integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated( mut self, integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: bool, ) -> Self47408     pub fn integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated(
47409         mut self,
47410         integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: bool,
47411     ) -> Self {
47412         self.inner
47413             .integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated =
47414             integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated.into();
47415         self
47416     }
47417     #[inline]
integer_dot_product_accumulating_saturating32_bit_signed_accelerated( mut self, integer_dot_product_accumulating_saturating32_bit_signed_accelerated: bool, ) -> Self47418     pub fn integer_dot_product_accumulating_saturating32_bit_signed_accelerated(
47419         mut self,
47420         integer_dot_product_accumulating_saturating32_bit_signed_accelerated: bool,
47421     ) -> Self {
47422         self.inner
47423             .integer_dot_product_accumulating_saturating32_bit_signed_accelerated =
47424             integer_dot_product_accumulating_saturating32_bit_signed_accelerated.into();
47425         self
47426     }
47427     #[inline]
integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated( mut self, integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: bool, ) -> Self47428     pub fn integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated(
47429         mut self,
47430         integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: bool,
47431     ) -> Self {
47432         self.inner
47433             .integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated =
47434             integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated.into();
47435         self
47436     }
47437     #[inline]
integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated( mut self, integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: bool, ) -> Self47438     pub fn integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated(
47439         mut self,
47440         integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: bool,
47441     ) -> Self {
47442         self.inner
47443             .integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated =
47444             integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated.into();
47445         self
47446     }
47447     #[inline]
integer_dot_product_accumulating_saturating64_bit_signed_accelerated( mut self, integer_dot_product_accumulating_saturating64_bit_signed_accelerated: bool, ) -> Self47448     pub fn integer_dot_product_accumulating_saturating64_bit_signed_accelerated(
47449         mut self,
47450         integer_dot_product_accumulating_saturating64_bit_signed_accelerated: bool,
47451     ) -> Self {
47452         self.inner
47453             .integer_dot_product_accumulating_saturating64_bit_signed_accelerated =
47454             integer_dot_product_accumulating_saturating64_bit_signed_accelerated.into();
47455         self
47456     }
47457     #[inline]
integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated( mut self, integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: bool, ) -> Self47458     pub fn integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated(
47459         mut self,
47460         integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: bool,
47461     ) -> Self {
47462         self.inner
47463             .integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated =
47464             integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated.into();
47465         self
47466     }
47467     #[inline]
storage_texel_buffer_offset_alignment_bytes( mut self, storage_texel_buffer_offset_alignment_bytes: DeviceSize, ) -> Self47468     pub fn storage_texel_buffer_offset_alignment_bytes(
47469         mut self,
47470         storage_texel_buffer_offset_alignment_bytes: DeviceSize,
47471     ) -> Self {
47472         self.inner.storage_texel_buffer_offset_alignment_bytes =
47473             storage_texel_buffer_offset_alignment_bytes;
47474         self
47475     }
47476     #[inline]
storage_texel_buffer_offset_single_texel_alignment( mut self, storage_texel_buffer_offset_single_texel_alignment: bool, ) -> Self47477     pub fn storage_texel_buffer_offset_single_texel_alignment(
47478         mut self,
47479         storage_texel_buffer_offset_single_texel_alignment: bool,
47480     ) -> Self {
47481         self.inner
47482             .storage_texel_buffer_offset_single_texel_alignment =
47483             storage_texel_buffer_offset_single_texel_alignment.into();
47484         self
47485     }
47486     #[inline]
uniform_texel_buffer_offset_alignment_bytes( mut self, uniform_texel_buffer_offset_alignment_bytes: DeviceSize, ) -> Self47487     pub fn uniform_texel_buffer_offset_alignment_bytes(
47488         mut self,
47489         uniform_texel_buffer_offset_alignment_bytes: DeviceSize,
47490     ) -> Self {
47491         self.inner.uniform_texel_buffer_offset_alignment_bytes =
47492             uniform_texel_buffer_offset_alignment_bytes;
47493         self
47494     }
47495     #[inline]
uniform_texel_buffer_offset_single_texel_alignment( mut self, uniform_texel_buffer_offset_single_texel_alignment: bool, ) -> Self47496     pub fn uniform_texel_buffer_offset_single_texel_alignment(
47497         mut self,
47498         uniform_texel_buffer_offset_single_texel_alignment: bool,
47499     ) -> Self {
47500         self.inner
47501             .uniform_texel_buffer_offset_single_texel_alignment =
47502             uniform_texel_buffer_offset_single_texel_alignment.into();
47503         self
47504     }
47505     #[inline]
max_buffer_size(mut self, max_buffer_size: DeviceSize) -> Self47506     pub fn max_buffer_size(mut self, max_buffer_size: DeviceSize) -> Self {
47507         self.inner.max_buffer_size = max_buffer_size;
47508         self
47509     }
47510     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47511     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47512     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceVulkan13Properties47513     pub fn build(self) -> PhysicalDeviceVulkan13Properties {
47514         self.inner
47515     }
47516 }
47517 #[repr(C)]
47518 #[cfg_attr(feature = "debug", derive(Debug))]
47519 #[derive(Copy, Clone)]
47520 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCompilerControlCreateInfoAMD.html>"]
47521 pub struct PipelineCompilerControlCreateInfoAMD {
47522     pub s_type: StructureType,
47523     pub p_next: *const c_void,
47524     pub compiler_control_flags: PipelineCompilerControlFlagsAMD,
47525 }
47526 impl ::std::default::Default for PipelineCompilerControlCreateInfoAMD {
47527     #[inline]
default() -> Self47528     fn default() -> Self {
47529         Self {
47530             s_type: Self::STRUCTURE_TYPE,
47531             p_next: ::std::ptr::null(),
47532             compiler_control_flags: PipelineCompilerControlFlagsAMD::default(),
47533         }
47534     }
47535 }
47536 unsafe impl TaggedStructure for PipelineCompilerControlCreateInfoAMD {
47537     const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
47538 }
47539 impl PipelineCompilerControlCreateInfoAMD {
builder<'a>() -> PipelineCompilerControlCreateInfoAMDBuilder<'a>47540     pub fn builder<'a>() -> PipelineCompilerControlCreateInfoAMDBuilder<'a> {
47541         PipelineCompilerControlCreateInfoAMDBuilder {
47542             inner: Self::default(),
47543             marker: ::std::marker::PhantomData,
47544         }
47545     }
47546 }
47547 #[repr(transparent)]
47548 pub struct PipelineCompilerControlCreateInfoAMDBuilder<'a> {
47549     inner: PipelineCompilerControlCreateInfoAMD,
47550     marker: ::std::marker::PhantomData<&'a ()>,
47551 }
47552 unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCompilerControlCreateInfoAMDBuilder<'_> {}
47553 unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCompilerControlCreateInfoAMD {}
47554 unsafe impl ExtendsComputePipelineCreateInfo for PipelineCompilerControlCreateInfoAMDBuilder<'_> {}
47555 unsafe impl ExtendsComputePipelineCreateInfo for PipelineCompilerControlCreateInfoAMD {}
47556 impl<'a> ::std::ops::Deref for PipelineCompilerControlCreateInfoAMDBuilder<'a> {
47557     type Target = PipelineCompilerControlCreateInfoAMD;
deref(&self) -> &Self::Target47558     fn deref(&self) -> &Self::Target {
47559         &self.inner
47560     }
47561 }
47562 impl<'a> ::std::ops::DerefMut for PipelineCompilerControlCreateInfoAMDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target47563     fn deref_mut(&mut self) -> &mut Self::Target {
47564         &mut self.inner
47565     }
47566 }
47567 impl<'a> PipelineCompilerControlCreateInfoAMDBuilder<'a> {
47568     #[inline]
compiler_control_flags( mut self, compiler_control_flags: PipelineCompilerControlFlagsAMD, ) -> Self47569     pub fn compiler_control_flags(
47570         mut self,
47571         compiler_control_flags: PipelineCompilerControlFlagsAMD,
47572     ) -> Self {
47573         self.inner.compiler_control_flags = compiler_control_flags;
47574         self
47575     }
47576     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47577     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47578     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineCompilerControlCreateInfoAMD47579     pub fn build(self) -> PipelineCompilerControlCreateInfoAMD {
47580         self.inner
47581     }
47582 }
47583 #[repr(C)]
47584 #[cfg_attr(feature = "debug", derive(Debug))]
47585 #[derive(Copy, Clone)]
47586 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCoherentMemoryFeaturesAMD.html>"]
47587 pub struct PhysicalDeviceCoherentMemoryFeaturesAMD {
47588     pub s_type: StructureType,
47589     pub p_next: *mut c_void,
47590     pub device_coherent_memory: Bool32,
47591 }
47592 impl ::std::default::Default for PhysicalDeviceCoherentMemoryFeaturesAMD {
47593     #[inline]
default() -> Self47594     fn default() -> Self {
47595         Self {
47596             s_type: Self::STRUCTURE_TYPE,
47597             p_next: ::std::ptr::null_mut(),
47598             device_coherent_memory: Bool32::default(),
47599         }
47600     }
47601 }
47602 unsafe impl TaggedStructure for PhysicalDeviceCoherentMemoryFeaturesAMD {
47603     const STRUCTURE_TYPE: StructureType =
47604         StructureType::PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
47605 }
47606 impl PhysicalDeviceCoherentMemoryFeaturesAMD {
builder<'a>() -> PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a>47607     pub fn builder<'a>() -> PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
47608         PhysicalDeviceCoherentMemoryFeaturesAMDBuilder {
47609             inner: Self::default(),
47610             marker: ::std::marker::PhantomData,
47611         }
47612     }
47613 }
47614 #[repr(transparent)]
47615 pub struct PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
47616     inner: PhysicalDeviceCoherentMemoryFeaturesAMD,
47617     marker: ::std::marker::PhantomData<&'a ()>,
47618 }
47619 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'_> {}
47620 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCoherentMemoryFeaturesAMD {}
47621 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'_> {}
47622 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoherentMemoryFeaturesAMD {}
47623 impl<'a> ::std::ops::Deref for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
47624     type Target = PhysicalDeviceCoherentMemoryFeaturesAMD;
deref(&self) -> &Self::Target47625     fn deref(&self) -> &Self::Target {
47626         &self.inner
47627     }
47628 }
47629 impl<'a> ::std::ops::DerefMut for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target47630     fn deref_mut(&mut self) -> &mut Self::Target {
47631         &mut self.inner
47632     }
47633 }
47634 impl<'a> PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
47635     #[inline]
device_coherent_memory(mut self, device_coherent_memory: bool) -> Self47636     pub fn device_coherent_memory(mut self, device_coherent_memory: bool) -> Self {
47637         self.inner.device_coherent_memory = device_coherent_memory.into();
47638         self
47639     }
47640     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47641     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47642     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceCoherentMemoryFeaturesAMD47643     pub fn build(self) -> PhysicalDeviceCoherentMemoryFeaturesAMD {
47644         self.inner
47645     }
47646 }
47647 #[repr(C)]
47648 #[derive(Copy, Clone)]
47649 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceToolProperties.html>"]
47650 pub struct PhysicalDeviceToolProperties {
47651     pub s_type: StructureType,
47652     pub p_next: *mut c_void,
47653     pub name: [c_char; MAX_EXTENSION_NAME_SIZE],
47654     pub version: [c_char; MAX_EXTENSION_NAME_SIZE],
47655     pub purposes: ToolPurposeFlags,
47656     pub description: [c_char; MAX_DESCRIPTION_SIZE],
47657     pub layer: [c_char; MAX_EXTENSION_NAME_SIZE],
47658 }
47659 #[cfg(feature = "debug")]
47660 impl fmt::Debug for PhysicalDeviceToolProperties {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result47661     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
47662         fmt.debug_struct("PhysicalDeviceToolProperties")
47663             .field("s_type", &self.s_type)
47664             .field("p_next", &self.p_next)
47665             .field("name", &unsafe {
47666                 ::std::ffi::CStr::from_ptr(self.name.as_ptr())
47667             })
47668             .field("version", &unsafe {
47669                 ::std::ffi::CStr::from_ptr(self.version.as_ptr())
47670             })
47671             .field("purposes", &self.purposes)
47672             .field("description", &unsafe {
47673                 ::std::ffi::CStr::from_ptr(self.description.as_ptr())
47674             })
47675             .field("layer", &unsafe {
47676                 ::std::ffi::CStr::from_ptr(self.layer.as_ptr())
47677             })
47678             .finish()
47679     }
47680 }
47681 impl ::std::default::Default for PhysicalDeviceToolProperties {
47682     #[inline]
default() -> Self47683     fn default() -> Self {
47684         Self {
47685             s_type: Self::STRUCTURE_TYPE,
47686             p_next: ::std::ptr::null_mut(),
47687             name: unsafe { ::std::mem::zeroed() },
47688             version: unsafe { ::std::mem::zeroed() },
47689             purposes: ToolPurposeFlags::default(),
47690             description: unsafe { ::std::mem::zeroed() },
47691             layer: unsafe { ::std::mem::zeroed() },
47692         }
47693     }
47694 }
47695 unsafe impl TaggedStructure for PhysicalDeviceToolProperties {
47696     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_TOOL_PROPERTIES;
47697 }
47698 impl PhysicalDeviceToolProperties {
builder<'a>() -> PhysicalDeviceToolPropertiesBuilder<'a>47699     pub fn builder<'a>() -> PhysicalDeviceToolPropertiesBuilder<'a> {
47700         PhysicalDeviceToolPropertiesBuilder {
47701             inner: Self::default(),
47702             marker: ::std::marker::PhantomData,
47703         }
47704     }
47705 }
47706 #[repr(transparent)]
47707 pub struct PhysicalDeviceToolPropertiesBuilder<'a> {
47708     inner: PhysicalDeviceToolProperties,
47709     marker: ::std::marker::PhantomData<&'a ()>,
47710 }
47711 impl<'a> ::std::ops::Deref for PhysicalDeviceToolPropertiesBuilder<'a> {
47712     type Target = PhysicalDeviceToolProperties;
deref(&self) -> &Self::Target47713     fn deref(&self) -> &Self::Target {
47714         &self.inner
47715     }
47716 }
47717 impl<'a> ::std::ops::DerefMut for PhysicalDeviceToolPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target47718     fn deref_mut(&mut self) -> &mut Self::Target {
47719         &mut self.inner
47720     }
47721 }
47722 impl<'a> PhysicalDeviceToolPropertiesBuilder<'a> {
47723     #[inline]
name(mut self, name: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self47724     pub fn name(mut self, name: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self {
47725         self.inner.name = name;
47726         self
47727     }
47728     #[inline]
version(mut self, version: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self47729     pub fn version(mut self, version: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self {
47730         self.inner.version = version;
47731         self
47732     }
47733     #[inline]
purposes(mut self, purposes: ToolPurposeFlags) -> Self47734     pub fn purposes(mut self, purposes: ToolPurposeFlags) -> Self {
47735         self.inner.purposes = purposes;
47736         self
47737     }
47738     #[inline]
description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self47739     pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
47740         self.inner.description = description;
47741         self
47742     }
47743     #[inline]
layer(mut self, layer: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self47744     pub fn layer(mut self, layer: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self {
47745         self.inner.layer = layer;
47746         self
47747     }
47748     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47749     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47750     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceToolProperties47751     pub fn build(self) -> PhysicalDeviceToolProperties {
47752         self.inner
47753     }
47754 }
47755 #[repr(C)]
47756 #[derive(Copy, Clone)]
47757 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerCustomBorderColorCreateInfoEXT.html>"]
47758 pub struct SamplerCustomBorderColorCreateInfoEXT {
47759     pub s_type: StructureType,
47760     pub p_next: *const c_void,
47761     pub custom_border_color: ClearColorValue,
47762     pub format: Format,
47763 }
47764 #[cfg(feature = "debug")]
47765 impl fmt::Debug for SamplerCustomBorderColorCreateInfoEXT {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result47766     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
47767         fmt.debug_struct("SamplerCustomBorderColorCreateInfoEXT")
47768             .field("s_type", &self.s_type)
47769             .field("p_next", &self.p_next)
47770             .field("custom_border_color", &"union")
47771             .field("format", &self.format)
47772             .finish()
47773     }
47774 }
47775 impl ::std::default::Default for SamplerCustomBorderColorCreateInfoEXT {
47776     #[inline]
default() -> Self47777     fn default() -> Self {
47778         Self {
47779             s_type: Self::STRUCTURE_TYPE,
47780             p_next: ::std::ptr::null(),
47781             custom_border_color: ClearColorValue::default(),
47782             format: Format::default(),
47783         }
47784     }
47785 }
47786 unsafe impl TaggedStructure for SamplerCustomBorderColorCreateInfoEXT {
47787     const STRUCTURE_TYPE: StructureType =
47788         StructureType::SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT;
47789 }
47790 impl SamplerCustomBorderColorCreateInfoEXT {
builder<'a>() -> SamplerCustomBorderColorCreateInfoEXTBuilder<'a>47791     pub fn builder<'a>() -> SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
47792         SamplerCustomBorderColorCreateInfoEXTBuilder {
47793             inner: Self::default(),
47794             marker: ::std::marker::PhantomData,
47795         }
47796     }
47797 }
47798 #[repr(transparent)]
47799 pub struct SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
47800     inner: SamplerCustomBorderColorCreateInfoEXT,
47801     marker: ::std::marker::PhantomData<&'a ()>,
47802 }
47803 unsafe impl ExtendsSamplerCreateInfo for SamplerCustomBorderColorCreateInfoEXTBuilder<'_> {}
47804 unsafe impl ExtendsSamplerCreateInfo for SamplerCustomBorderColorCreateInfoEXT {}
47805 impl<'a> ::std::ops::Deref for SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
47806     type Target = SamplerCustomBorderColorCreateInfoEXT;
deref(&self) -> &Self::Target47807     fn deref(&self) -> &Self::Target {
47808         &self.inner
47809     }
47810 }
47811 impl<'a> ::std::ops::DerefMut for SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target47812     fn deref_mut(&mut self) -> &mut Self::Target {
47813         &mut self.inner
47814     }
47815 }
47816 impl<'a> SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
47817     #[inline]
custom_border_color(mut self, custom_border_color: ClearColorValue) -> Self47818     pub fn custom_border_color(mut self, custom_border_color: ClearColorValue) -> Self {
47819         self.inner.custom_border_color = custom_border_color;
47820         self
47821     }
47822     #[inline]
format(mut self, format: Format) -> Self47823     pub fn format(mut self, format: Format) -> Self {
47824         self.inner.format = format;
47825         self
47826     }
47827     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47828     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47829     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SamplerCustomBorderColorCreateInfoEXT47830     pub fn build(self) -> SamplerCustomBorderColorCreateInfoEXT {
47831         self.inner
47832     }
47833 }
47834 #[repr(C)]
47835 #[cfg_attr(feature = "debug", derive(Debug))]
47836 #[derive(Copy, Clone)]
47837 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCustomBorderColorPropertiesEXT.html>"]
47838 pub struct PhysicalDeviceCustomBorderColorPropertiesEXT {
47839     pub s_type: StructureType,
47840     pub p_next: *mut c_void,
47841     pub max_custom_border_color_samplers: u32,
47842 }
47843 impl ::std::default::Default for PhysicalDeviceCustomBorderColorPropertiesEXT {
47844     #[inline]
default() -> Self47845     fn default() -> Self {
47846         Self {
47847             s_type: Self::STRUCTURE_TYPE,
47848             p_next: ::std::ptr::null_mut(),
47849             max_custom_border_color_samplers: u32::default(),
47850         }
47851     }
47852 }
47853 unsafe impl TaggedStructure for PhysicalDeviceCustomBorderColorPropertiesEXT {
47854     const STRUCTURE_TYPE: StructureType =
47855         StructureType::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT;
47856 }
47857 impl PhysicalDeviceCustomBorderColorPropertiesEXT {
builder<'a>() -> PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a>47858     pub fn builder<'a>() -> PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> {
47859         PhysicalDeviceCustomBorderColorPropertiesEXTBuilder {
47860             inner: Self::default(),
47861             marker: ::std::marker::PhantomData,
47862         }
47863     }
47864 }
47865 #[repr(transparent)]
47866 pub struct PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> {
47867     inner: PhysicalDeviceCustomBorderColorPropertiesEXT,
47868     marker: ::std::marker::PhantomData<&'a ()>,
47869 }
47870 unsafe impl ExtendsPhysicalDeviceProperties2
47871     for PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'_>
47872 {
47873 }
47874 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCustomBorderColorPropertiesEXT {}
47875 impl<'a> ::std::ops::Deref for PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> {
47876     type Target = PhysicalDeviceCustomBorderColorPropertiesEXT;
deref(&self) -> &Self::Target47877     fn deref(&self) -> &Self::Target {
47878         &self.inner
47879     }
47880 }
47881 impl<'a> ::std::ops::DerefMut for PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target47882     fn deref_mut(&mut self) -> &mut Self::Target {
47883         &mut self.inner
47884     }
47885 }
47886 impl<'a> PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> {
47887     #[inline]
max_custom_border_color_samplers( mut self, max_custom_border_color_samplers: u32, ) -> Self47888     pub fn max_custom_border_color_samplers(
47889         mut self,
47890         max_custom_border_color_samplers: u32,
47891     ) -> Self {
47892         self.inner.max_custom_border_color_samplers = max_custom_border_color_samplers;
47893         self
47894     }
47895     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47896     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47897     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceCustomBorderColorPropertiesEXT47898     pub fn build(self) -> PhysicalDeviceCustomBorderColorPropertiesEXT {
47899         self.inner
47900     }
47901 }
47902 #[repr(C)]
47903 #[cfg_attr(feature = "debug", derive(Debug))]
47904 #[derive(Copy, Clone)]
47905 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCustomBorderColorFeaturesEXT.html>"]
47906 pub struct PhysicalDeviceCustomBorderColorFeaturesEXT {
47907     pub s_type: StructureType,
47908     pub p_next: *mut c_void,
47909     pub custom_border_colors: Bool32,
47910     pub custom_border_color_without_format: Bool32,
47911 }
47912 impl ::std::default::Default for PhysicalDeviceCustomBorderColorFeaturesEXT {
47913     #[inline]
default() -> Self47914     fn default() -> Self {
47915         Self {
47916             s_type: Self::STRUCTURE_TYPE,
47917             p_next: ::std::ptr::null_mut(),
47918             custom_border_colors: Bool32::default(),
47919             custom_border_color_without_format: Bool32::default(),
47920         }
47921     }
47922 }
47923 unsafe impl TaggedStructure for PhysicalDeviceCustomBorderColorFeaturesEXT {
47924     const STRUCTURE_TYPE: StructureType =
47925         StructureType::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
47926 }
47927 impl PhysicalDeviceCustomBorderColorFeaturesEXT {
builder<'a>() -> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a>47928     pub fn builder<'a>() -> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
47929         PhysicalDeviceCustomBorderColorFeaturesEXTBuilder {
47930             inner: Self::default(),
47931             marker: ::std::marker::PhantomData,
47932         }
47933     }
47934 }
47935 #[repr(transparent)]
47936 pub struct PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
47937     inner: PhysicalDeviceCustomBorderColorFeaturesEXT,
47938     marker: ::std::marker::PhantomData<&'a ()>,
47939 }
47940 unsafe impl ExtendsPhysicalDeviceFeatures2
47941     for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'_>
47942 {
47943 }
47944 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCustomBorderColorFeaturesEXT {}
47945 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'_> {}
47946 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCustomBorderColorFeaturesEXT {}
47947 impl<'a> ::std::ops::Deref for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
47948     type Target = PhysicalDeviceCustomBorderColorFeaturesEXT;
deref(&self) -> &Self::Target47949     fn deref(&self) -> &Self::Target {
47950         &self.inner
47951     }
47952 }
47953 impl<'a> ::std::ops::DerefMut for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target47954     fn deref_mut(&mut self) -> &mut Self::Target {
47955         &mut self.inner
47956     }
47957 }
47958 impl<'a> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
47959     #[inline]
custom_border_colors(mut self, custom_border_colors: bool) -> Self47960     pub fn custom_border_colors(mut self, custom_border_colors: bool) -> Self {
47961         self.inner.custom_border_colors = custom_border_colors.into();
47962         self
47963     }
47964     #[inline]
custom_border_color_without_format( mut self, custom_border_color_without_format: bool, ) -> Self47965     pub fn custom_border_color_without_format(
47966         mut self,
47967         custom_border_color_without_format: bool,
47968     ) -> Self {
47969         self.inner.custom_border_color_without_format = custom_border_color_without_format.into();
47970         self
47971     }
47972     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47973     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47974     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceCustomBorderColorFeaturesEXT47975     pub fn build(self) -> PhysicalDeviceCustomBorderColorFeaturesEXT {
47976         self.inner
47977     }
47978 }
47979 #[repr(C)]
47980 #[cfg_attr(feature = "debug", derive(Debug))]
47981 #[derive(Copy, Clone)]
47982 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerBorderColorComponentMappingCreateInfoEXT.html>"]
47983 pub struct SamplerBorderColorComponentMappingCreateInfoEXT {
47984     pub s_type: StructureType,
47985     pub p_next: *const c_void,
47986     pub components: ComponentMapping,
47987     pub srgb: Bool32,
47988 }
47989 impl ::std::default::Default for SamplerBorderColorComponentMappingCreateInfoEXT {
47990     #[inline]
default() -> Self47991     fn default() -> Self {
47992         Self {
47993             s_type: Self::STRUCTURE_TYPE,
47994             p_next: ::std::ptr::null(),
47995             components: ComponentMapping::default(),
47996             srgb: Bool32::default(),
47997         }
47998     }
47999 }
48000 unsafe impl TaggedStructure for SamplerBorderColorComponentMappingCreateInfoEXT {
48001     const STRUCTURE_TYPE: StructureType =
48002         StructureType::SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT;
48003 }
48004 impl SamplerBorderColorComponentMappingCreateInfoEXT {
builder<'a>() -> SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a>48005     pub fn builder<'a>() -> SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> {
48006         SamplerBorderColorComponentMappingCreateInfoEXTBuilder {
48007             inner: Self::default(),
48008             marker: ::std::marker::PhantomData,
48009         }
48010     }
48011 }
48012 #[repr(transparent)]
48013 pub struct SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> {
48014     inner: SamplerBorderColorComponentMappingCreateInfoEXT,
48015     marker: ::std::marker::PhantomData<&'a ()>,
48016 }
48017 unsafe impl ExtendsSamplerCreateInfo
48018     for SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'_>
48019 {
48020 }
48021 unsafe impl ExtendsSamplerCreateInfo for SamplerBorderColorComponentMappingCreateInfoEXT {}
48022 impl<'a> ::std::ops::Deref for SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> {
48023     type Target = SamplerBorderColorComponentMappingCreateInfoEXT;
deref(&self) -> &Self::Target48024     fn deref(&self) -> &Self::Target {
48025         &self.inner
48026     }
48027 }
48028 impl<'a> ::std::ops::DerefMut for SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target48029     fn deref_mut(&mut self) -> &mut Self::Target {
48030         &mut self.inner
48031     }
48032 }
48033 impl<'a> SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> {
48034     #[inline]
components(mut self, components: ComponentMapping) -> Self48035     pub fn components(mut self, components: ComponentMapping) -> Self {
48036         self.inner.components = components;
48037         self
48038     }
48039     #[inline]
srgb(mut self, srgb: bool) -> Self48040     pub fn srgb(mut self, srgb: bool) -> Self {
48041         self.inner.srgb = srgb.into();
48042         self
48043     }
48044     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48045     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48046     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SamplerBorderColorComponentMappingCreateInfoEXT48047     pub fn build(self) -> SamplerBorderColorComponentMappingCreateInfoEXT {
48048         self.inner
48049     }
48050 }
48051 #[repr(C)]
48052 #[cfg_attr(feature = "debug", derive(Debug))]
48053 #[derive(Copy, Clone)]
48054 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceBorderColorSwizzleFeaturesEXT.html>"]
48055 pub struct PhysicalDeviceBorderColorSwizzleFeaturesEXT {
48056     pub s_type: StructureType,
48057     pub p_next: *mut c_void,
48058     pub border_color_swizzle: Bool32,
48059     pub border_color_swizzle_from_image: Bool32,
48060 }
48061 impl ::std::default::Default for PhysicalDeviceBorderColorSwizzleFeaturesEXT {
48062     #[inline]
default() -> Self48063     fn default() -> Self {
48064         Self {
48065             s_type: Self::STRUCTURE_TYPE,
48066             p_next: ::std::ptr::null_mut(),
48067             border_color_swizzle: Bool32::default(),
48068             border_color_swizzle_from_image: Bool32::default(),
48069         }
48070     }
48071 }
48072 unsafe impl TaggedStructure for PhysicalDeviceBorderColorSwizzleFeaturesEXT {
48073     const STRUCTURE_TYPE: StructureType =
48074         StructureType::PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
48075 }
48076 impl PhysicalDeviceBorderColorSwizzleFeaturesEXT {
builder<'a>() -> PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a>48077     pub fn builder<'a>() -> PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> {
48078         PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder {
48079             inner: Self::default(),
48080             marker: ::std::marker::PhantomData,
48081         }
48082     }
48083 }
48084 #[repr(transparent)]
48085 pub struct PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> {
48086     inner: PhysicalDeviceBorderColorSwizzleFeaturesEXT,
48087     marker: ::std::marker::PhantomData<&'a ()>,
48088 }
48089 unsafe impl ExtendsPhysicalDeviceFeatures2
48090     for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'_>
48091 {
48092 }
48093 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBorderColorSwizzleFeaturesEXT {}
48094 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'_> {}
48095 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBorderColorSwizzleFeaturesEXT {}
48096 impl<'a> ::std::ops::Deref for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> {
48097     type Target = PhysicalDeviceBorderColorSwizzleFeaturesEXT;
deref(&self) -> &Self::Target48098     fn deref(&self) -> &Self::Target {
48099         &self.inner
48100     }
48101 }
48102 impl<'a> ::std::ops::DerefMut for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target48103     fn deref_mut(&mut self) -> &mut Self::Target {
48104         &mut self.inner
48105     }
48106 }
48107 impl<'a> PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> {
48108     #[inline]
border_color_swizzle(mut self, border_color_swizzle: bool) -> Self48109     pub fn border_color_swizzle(mut self, border_color_swizzle: bool) -> Self {
48110         self.inner.border_color_swizzle = border_color_swizzle.into();
48111         self
48112     }
48113     #[inline]
border_color_swizzle_from_image( mut self, border_color_swizzle_from_image: bool, ) -> Self48114     pub fn border_color_swizzle_from_image(
48115         mut self,
48116         border_color_swizzle_from_image: bool,
48117     ) -> Self {
48118         self.inner.border_color_swizzle_from_image = border_color_swizzle_from_image.into();
48119         self
48120     }
48121     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48122     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48123     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceBorderColorSwizzleFeaturesEXT48124     pub fn build(self) -> PhysicalDeviceBorderColorSwizzleFeaturesEXT {
48125         self.inner
48126     }
48127 }
48128 #[repr(C)]
48129 #[derive(Copy, Clone)]
48130 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceOrHostAddressKHR.html>"]
48131 pub union DeviceOrHostAddressKHR {
48132     pub device_address: DeviceAddress,
48133     pub host_address: *mut c_void,
48134 }
48135 impl ::std::default::Default for DeviceOrHostAddressKHR {
48136     #[inline]
default() -> Self48137     fn default() -> Self {
48138         unsafe { ::std::mem::zeroed() }
48139     }
48140 }
48141 #[repr(C)]
48142 #[derive(Copy, Clone)]
48143 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceOrHostAddressConstKHR.html>"]
48144 pub union DeviceOrHostAddressConstKHR {
48145     pub device_address: DeviceAddress,
48146     pub host_address: *const c_void,
48147 }
48148 impl ::std::default::Default for DeviceOrHostAddressConstKHR {
48149     #[inline]
default() -> Self48150     fn default() -> Self {
48151         unsafe { ::std::mem::zeroed() }
48152     }
48153 }
48154 #[repr(C)]
48155 #[derive(Copy, Clone)]
48156 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryTrianglesDataKHR.html>"]
48157 pub struct AccelerationStructureGeometryTrianglesDataKHR {
48158     pub s_type: StructureType,
48159     pub p_next: *const c_void,
48160     pub vertex_format: Format,
48161     pub vertex_data: DeviceOrHostAddressConstKHR,
48162     pub vertex_stride: DeviceSize,
48163     pub max_vertex: u32,
48164     pub index_type: IndexType,
48165     pub index_data: DeviceOrHostAddressConstKHR,
48166     pub transform_data: DeviceOrHostAddressConstKHR,
48167 }
48168 #[cfg(feature = "debug")]
48169 impl fmt::Debug for AccelerationStructureGeometryTrianglesDataKHR {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result48170     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
48171         fmt.debug_struct("AccelerationStructureGeometryTrianglesDataKHR")
48172             .field("s_type", &self.s_type)
48173             .field("p_next", &self.p_next)
48174             .field("vertex_format", &self.vertex_format)
48175             .field("vertex_data", &"union")
48176             .field("vertex_stride", &self.vertex_stride)
48177             .field("max_vertex", &self.max_vertex)
48178             .field("index_type", &self.index_type)
48179             .field("index_data", &"union")
48180             .field("transform_data", &"union")
48181             .finish()
48182     }
48183 }
48184 impl ::std::default::Default for AccelerationStructureGeometryTrianglesDataKHR {
48185     #[inline]
default() -> Self48186     fn default() -> Self {
48187         Self {
48188             s_type: Self::STRUCTURE_TYPE,
48189             p_next: ::std::ptr::null(),
48190             vertex_format: Format::default(),
48191             vertex_data: DeviceOrHostAddressConstKHR::default(),
48192             vertex_stride: DeviceSize::default(),
48193             max_vertex: u32::default(),
48194             index_type: IndexType::default(),
48195             index_data: DeviceOrHostAddressConstKHR::default(),
48196             transform_data: DeviceOrHostAddressConstKHR::default(),
48197         }
48198     }
48199 }
48200 unsafe impl TaggedStructure for AccelerationStructureGeometryTrianglesDataKHR {
48201     const STRUCTURE_TYPE: StructureType =
48202         StructureType::ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR;
48203 }
48204 impl AccelerationStructureGeometryTrianglesDataKHR {
builder<'a>() -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a>48205     pub fn builder<'a>() -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
48206         AccelerationStructureGeometryTrianglesDataKHRBuilder {
48207             inner: Self::default(),
48208             marker: ::std::marker::PhantomData,
48209         }
48210     }
48211 }
48212 #[repr(transparent)]
48213 pub struct AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
48214     inner: AccelerationStructureGeometryTrianglesDataKHR,
48215     marker: ::std::marker::PhantomData<&'a ()>,
48216 }
48217 pub unsafe trait ExtendsAccelerationStructureGeometryTrianglesDataKHR {}
48218 impl<'a> ::std::ops::Deref for AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
48219     type Target = AccelerationStructureGeometryTrianglesDataKHR;
deref(&self) -> &Self::Target48220     fn deref(&self) -> &Self::Target {
48221         &self.inner
48222     }
48223 }
48224 impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target48225     fn deref_mut(&mut self) -> &mut Self::Target {
48226         &mut self.inner
48227     }
48228 }
48229 impl<'a> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
48230     #[inline]
vertex_format(mut self, vertex_format: Format) -> Self48231     pub fn vertex_format(mut self, vertex_format: Format) -> Self {
48232         self.inner.vertex_format = vertex_format;
48233         self
48234     }
48235     #[inline]
vertex_data(mut self, vertex_data: DeviceOrHostAddressConstKHR) -> Self48236     pub fn vertex_data(mut self, vertex_data: DeviceOrHostAddressConstKHR) -> Self {
48237         self.inner.vertex_data = vertex_data;
48238         self
48239     }
48240     #[inline]
vertex_stride(mut self, vertex_stride: DeviceSize) -> Self48241     pub fn vertex_stride(mut self, vertex_stride: DeviceSize) -> Self {
48242         self.inner.vertex_stride = vertex_stride;
48243         self
48244     }
48245     #[inline]
max_vertex(mut self, max_vertex: u32) -> Self48246     pub fn max_vertex(mut self, max_vertex: u32) -> Self {
48247         self.inner.max_vertex = max_vertex;
48248         self
48249     }
48250     #[inline]
index_type(mut self, index_type: IndexType) -> Self48251     pub fn index_type(mut self, index_type: IndexType) -> Self {
48252         self.inner.index_type = index_type;
48253         self
48254     }
48255     #[inline]
index_data(mut self, index_data: DeviceOrHostAddressConstKHR) -> Self48256     pub fn index_data(mut self, index_data: DeviceOrHostAddressConstKHR) -> Self {
48257         self.inner.index_data = index_data;
48258         self
48259     }
48260     #[inline]
transform_data(mut self, transform_data: DeviceOrHostAddressConstKHR) -> Self48261     pub fn transform_data(mut self, transform_data: DeviceOrHostAddressConstKHR) -> Self {
48262         self.inner.transform_data = transform_data;
48263         self
48264     }
48265     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
48266     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
48267     #[doc = r" valid extension structs can be pushed into the chain."]
48268     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
48269     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsAccelerationStructureGeometryTrianglesDataKHR>( mut self, next: &'a mut T, ) -> Self48270     pub fn push_next<T: ExtendsAccelerationStructureGeometryTrianglesDataKHR>(
48271         mut self,
48272         next: &'a mut T,
48273     ) -> Self {
48274         unsafe {
48275             let next_ptr = <*const T>::cast(next);
48276             let last_next = ptr_chain_iter(next).last().unwrap();
48277             (*last_next).p_next = self.inner.p_next as _;
48278             self.inner.p_next = next_ptr;
48279         }
48280         self
48281     }
48282     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48283     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48284     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureGeometryTrianglesDataKHR48285     pub fn build(self) -> AccelerationStructureGeometryTrianglesDataKHR {
48286         self.inner
48287     }
48288 }
48289 #[repr(C)]
48290 #[derive(Copy, Clone)]
48291 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryAabbsDataKHR.html>"]
48292 pub struct AccelerationStructureGeometryAabbsDataKHR {
48293     pub s_type: StructureType,
48294     pub p_next: *const c_void,
48295     pub data: DeviceOrHostAddressConstKHR,
48296     pub stride: DeviceSize,
48297 }
48298 #[cfg(feature = "debug")]
48299 impl fmt::Debug for AccelerationStructureGeometryAabbsDataKHR {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result48300     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
48301         fmt.debug_struct("AccelerationStructureGeometryAabbsDataKHR")
48302             .field("s_type", &self.s_type)
48303             .field("p_next", &self.p_next)
48304             .field("data", &"union")
48305             .field("stride", &self.stride)
48306             .finish()
48307     }
48308 }
48309 impl ::std::default::Default for AccelerationStructureGeometryAabbsDataKHR {
48310     #[inline]
default() -> Self48311     fn default() -> Self {
48312         Self {
48313             s_type: Self::STRUCTURE_TYPE,
48314             p_next: ::std::ptr::null(),
48315             data: DeviceOrHostAddressConstKHR::default(),
48316             stride: DeviceSize::default(),
48317         }
48318     }
48319 }
48320 unsafe impl TaggedStructure for AccelerationStructureGeometryAabbsDataKHR {
48321     const STRUCTURE_TYPE: StructureType =
48322         StructureType::ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR;
48323 }
48324 impl AccelerationStructureGeometryAabbsDataKHR {
builder<'a>() -> AccelerationStructureGeometryAabbsDataKHRBuilder<'a>48325     pub fn builder<'a>() -> AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
48326         AccelerationStructureGeometryAabbsDataKHRBuilder {
48327             inner: Self::default(),
48328             marker: ::std::marker::PhantomData,
48329         }
48330     }
48331 }
48332 #[repr(transparent)]
48333 pub struct AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
48334     inner: AccelerationStructureGeometryAabbsDataKHR,
48335     marker: ::std::marker::PhantomData<&'a ()>,
48336 }
48337 impl<'a> ::std::ops::Deref for AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
48338     type Target = AccelerationStructureGeometryAabbsDataKHR;
deref(&self) -> &Self::Target48339     fn deref(&self) -> &Self::Target {
48340         &self.inner
48341     }
48342 }
48343 impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target48344     fn deref_mut(&mut self) -> &mut Self::Target {
48345         &mut self.inner
48346     }
48347 }
48348 impl<'a> AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
48349     #[inline]
data(mut self, data: DeviceOrHostAddressConstKHR) -> Self48350     pub fn data(mut self, data: DeviceOrHostAddressConstKHR) -> Self {
48351         self.inner.data = data;
48352         self
48353     }
48354     #[inline]
stride(mut self, stride: DeviceSize) -> Self48355     pub fn stride(mut self, stride: DeviceSize) -> Self {
48356         self.inner.stride = stride;
48357         self
48358     }
48359     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48360     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48361     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureGeometryAabbsDataKHR48362     pub fn build(self) -> AccelerationStructureGeometryAabbsDataKHR {
48363         self.inner
48364     }
48365 }
48366 #[repr(C)]
48367 #[derive(Copy, Clone)]
48368 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryInstancesDataKHR.html>"]
48369 pub struct AccelerationStructureGeometryInstancesDataKHR {
48370     pub s_type: StructureType,
48371     pub p_next: *const c_void,
48372     pub array_of_pointers: Bool32,
48373     pub data: DeviceOrHostAddressConstKHR,
48374 }
48375 #[cfg(feature = "debug")]
48376 impl fmt::Debug for AccelerationStructureGeometryInstancesDataKHR {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result48377     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
48378         fmt.debug_struct("AccelerationStructureGeometryInstancesDataKHR")
48379             .field("s_type", &self.s_type)
48380             .field("p_next", &self.p_next)
48381             .field("array_of_pointers", &self.array_of_pointers)
48382             .field("data", &"union")
48383             .finish()
48384     }
48385 }
48386 impl ::std::default::Default for AccelerationStructureGeometryInstancesDataKHR {
48387     #[inline]
default() -> Self48388     fn default() -> Self {
48389         Self {
48390             s_type: Self::STRUCTURE_TYPE,
48391             p_next: ::std::ptr::null(),
48392             array_of_pointers: Bool32::default(),
48393             data: DeviceOrHostAddressConstKHR::default(),
48394         }
48395     }
48396 }
48397 unsafe impl TaggedStructure for AccelerationStructureGeometryInstancesDataKHR {
48398     const STRUCTURE_TYPE: StructureType =
48399         StructureType::ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR;
48400 }
48401 impl AccelerationStructureGeometryInstancesDataKHR {
builder<'a>() -> AccelerationStructureGeometryInstancesDataKHRBuilder<'a>48402     pub fn builder<'a>() -> AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
48403         AccelerationStructureGeometryInstancesDataKHRBuilder {
48404             inner: Self::default(),
48405             marker: ::std::marker::PhantomData,
48406         }
48407     }
48408 }
48409 #[repr(transparent)]
48410 pub struct AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
48411     inner: AccelerationStructureGeometryInstancesDataKHR,
48412     marker: ::std::marker::PhantomData<&'a ()>,
48413 }
48414 impl<'a> ::std::ops::Deref for AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
48415     type Target = AccelerationStructureGeometryInstancesDataKHR;
deref(&self) -> &Self::Target48416     fn deref(&self) -> &Self::Target {
48417         &self.inner
48418     }
48419 }
48420 impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target48421     fn deref_mut(&mut self) -> &mut Self::Target {
48422         &mut self.inner
48423     }
48424 }
48425 impl<'a> AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
48426     #[inline]
array_of_pointers(mut self, array_of_pointers: bool) -> Self48427     pub fn array_of_pointers(mut self, array_of_pointers: bool) -> Self {
48428         self.inner.array_of_pointers = array_of_pointers.into();
48429         self
48430     }
48431     #[inline]
data(mut self, data: DeviceOrHostAddressConstKHR) -> Self48432     pub fn data(mut self, data: DeviceOrHostAddressConstKHR) -> Self {
48433         self.inner.data = data;
48434         self
48435     }
48436     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48437     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48438     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureGeometryInstancesDataKHR48439     pub fn build(self) -> AccelerationStructureGeometryInstancesDataKHR {
48440         self.inner
48441     }
48442 }
48443 #[repr(C)]
48444 #[derive(Copy, Clone)]
48445 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryDataKHR.html>"]
48446 pub union AccelerationStructureGeometryDataKHR {
48447     pub triangles: AccelerationStructureGeometryTrianglesDataKHR,
48448     pub aabbs: AccelerationStructureGeometryAabbsDataKHR,
48449     pub instances: AccelerationStructureGeometryInstancesDataKHR,
48450 }
48451 impl ::std::default::Default for AccelerationStructureGeometryDataKHR {
48452     #[inline]
default() -> Self48453     fn default() -> Self {
48454         unsafe { ::std::mem::zeroed() }
48455     }
48456 }
48457 #[repr(C)]
48458 #[derive(Copy, Clone)]
48459 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryKHR.html>"]
48460 pub struct AccelerationStructureGeometryKHR {
48461     pub s_type: StructureType,
48462     pub p_next: *const c_void,
48463     pub geometry_type: GeometryTypeKHR,
48464     pub geometry: AccelerationStructureGeometryDataKHR,
48465     pub flags: GeometryFlagsKHR,
48466 }
48467 #[cfg(feature = "debug")]
48468 impl fmt::Debug for AccelerationStructureGeometryKHR {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result48469     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
48470         fmt.debug_struct("AccelerationStructureGeometryKHR")
48471             .field("s_type", &self.s_type)
48472             .field("p_next", &self.p_next)
48473             .field("geometry_type", &self.geometry_type)
48474             .field("geometry", &"union")
48475             .field("flags", &self.flags)
48476             .finish()
48477     }
48478 }
48479 impl ::std::default::Default for AccelerationStructureGeometryKHR {
48480     #[inline]
default() -> Self48481     fn default() -> Self {
48482         Self {
48483             s_type: Self::STRUCTURE_TYPE,
48484             p_next: ::std::ptr::null(),
48485             geometry_type: GeometryTypeKHR::default(),
48486             geometry: AccelerationStructureGeometryDataKHR::default(),
48487             flags: GeometryFlagsKHR::default(),
48488         }
48489     }
48490 }
48491 unsafe impl TaggedStructure for AccelerationStructureGeometryKHR {
48492     const STRUCTURE_TYPE: StructureType = StructureType::ACCELERATION_STRUCTURE_GEOMETRY_KHR;
48493 }
48494 impl AccelerationStructureGeometryKHR {
builder<'a>() -> AccelerationStructureGeometryKHRBuilder<'a>48495     pub fn builder<'a>() -> AccelerationStructureGeometryKHRBuilder<'a> {
48496         AccelerationStructureGeometryKHRBuilder {
48497             inner: Self::default(),
48498             marker: ::std::marker::PhantomData,
48499         }
48500     }
48501 }
48502 #[repr(transparent)]
48503 pub struct AccelerationStructureGeometryKHRBuilder<'a> {
48504     inner: AccelerationStructureGeometryKHR,
48505     marker: ::std::marker::PhantomData<&'a ()>,
48506 }
48507 impl<'a> ::std::ops::Deref for AccelerationStructureGeometryKHRBuilder<'a> {
48508     type Target = AccelerationStructureGeometryKHR;
deref(&self) -> &Self::Target48509     fn deref(&self) -> &Self::Target {
48510         &self.inner
48511     }
48512 }
48513 impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target48514     fn deref_mut(&mut self) -> &mut Self::Target {
48515         &mut self.inner
48516     }
48517 }
48518 impl<'a> AccelerationStructureGeometryKHRBuilder<'a> {
48519     #[inline]
geometry_type(mut self, geometry_type: GeometryTypeKHR) -> Self48520     pub fn geometry_type(mut self, geometry_type: GeometryTypeKHR) -> Self {
48521         self.inner.geometry_type = geometry_type;
48522         self
48523     }
48524     #[inline]
geometry(mut self, geometry: AccelerationStructureGeometryDataKHR) -> Self48525     pub fn geometry(mut self, geometry: AccelerationStructureGeometryDataKHR) -> Self {
48526         self.inner.geometry = geometry;
48527         self
48528     }
48529     #[inline]
flags(mut self, flags: GeometryFlagsKHR) -> Self48530     pub fn flags(mut self, flags: GeometryFlagsKHR) -> Self {
48531         self.inner.flags = flags;
48532         self
48533     }
48534     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48535     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48536     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureGeometryKHR48537     pub fn build(self) -> AccelerationStructureGeometryKHR {
48538         self.inner
48539     }
48540 }
48541 #[repr(C)]
48542 #[derive(Copy, Clone)]
48543 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureBuildGeometryInfoKHR.html>"]
48544 pub struct AccelerationStructureBuildGeometryInfoKHR {
48545     pub s_type: StructureType,
48546     pub p_next: *const c_void,
48547     pub ty: AccelerationStructureTypeKHR,
48548     pub flags: BuildAccelerationStructureFlagsKHR,
48549     pub mode: BuildAccelerationStructureModeKHR,
48550     pub src_acceleration_structure: AccelerationStructureKHR,
48551     pub dst_acceleration_structure: AccelerationStructureKHR,
48552     pub geometry_count: u32,
48553     pub p_geometries: *const AccelerationStructureGeometryKHR,
48554     pub pp_geometries: *const *const AccelerationStructureGeometryKHR,
48555     pub scratch_data: DeviceOrHostAddressKHR,
48556 }
48557 #[cfg(feature = "debug")]
48558 impl fmt::Debug for AccelerationStructureBuildGeometryInfoKHR {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result48559     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
48560         fmt.debug_struct("AccelerationStructureBuildGeometryInfoKHR")
48561             .field("s_type", &self.s_type)
48562             .field("p_next", &self.p_next)
48563             .field("ty", &self.ty)
48564             .field("flags", &self.flags)
48565             .field("mode", &self.mode)
48566             .field(
48567                 "src_acceleration_structure",
48568                 &self.src_acceleration_structure,
48569             )
48570             .field(
48571                 "dst_acceleration_structure",
48572                 &self.dst_acceleration_structure,
48573             )
48574             .field("geometry_count", &self.geometry_count)
48575             .field("p_geometries", &self.p_geometries)
48576             .field("pp_geometries", &self.pp_geometries)
48577             .field("scratch_data", &"union")
48578             .finish()
48579     }
48580 }
48581 impl ::std::default::Default for AccelerationStructureBuildGeometryInfoKHR {
48582     #[inline]
default() -> Self48583     fn default() -> Self {
48584         Self {
48585             s_type: Self::STRUCTURE_TYPE,
48586             p_next: ::std::ptr::null(),
48587             ty: AccelerationStructureTypeKHR::default(),
48588             flags: BuildAccelerationStructureFlagsKHR::default(),
48589             mode: BuildAccelerationStructureModeKHR::default(),
48590             src_acceleration_structure: AccelerationStructureKHR::default(),
48591             dst_acceleration_structure: AccelerationStructureKHR::default(),
48592             geometry_count: u32::default(),
48593             p_geometries: ::std::ptr::null(),
48594             pp_geometries: ::std::ptr::null(),
48595             scratch_data: DeviceOrHostAddressKHR::default(),
48596         }
48597     }
48598 }
48599 unsafe impl TaggedStructure for AccelerationStructureBuildGeometryInfoKHR {
48600     const STRUCTURE_TYPE: StructureType =
48601         StructureType::ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR;
48602 }
48603 impl AccelerationStructureBuildGeometryInfoKHR {
builder<'a>() -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a>48604     pub fn builder<'a>() -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
48605         AccelerationStructureBuildGeometryInfoKHRBuilder {
48606             inner: Self::default(),
48607             marker: ::std::marker::PhantomData,
48608         }
48609     }
48610 }
48611 #[repr(transparent)]
48612 pub struct AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
48613     inner: AccelerationStructureBuildGeometryInfoKHR,
48614     marker: ::std::marker::PhantomData<&'a ()>,
48615 }
48616 impl<'a> ::std::ops::Deref for AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
48617     type Target = AccelerationStructureBuildGeometryInfoKHR;
deref(&self) -> &Self::Target48618     fn deref(&self) -> &Self::Target {
48619         &self.inner
48620     }
48621 }
48622 impl<'a> ::std::ops::DerefMut for AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target48623     fn deref_mut(&mut self) -> &mut Self::Target {
48624         &mut self.inner
48625     }
48626 }
48627 impl<'a> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
48628     #[inline]
ty(mut self, ty: AccelerationStructureTypeKHR) -> Self48629     pub fn ty(mut self, ty: AccelerationStructureTypeKHR) -> Self {
48630         self.inner.ty = ty;
48631         self
48632     }
48633     #[inline]
flags(mut self, flags: BuildAccelerationStructureFlagsKHR) -> Self48634     pub fn flags(mut self, flags: BuildAccelerationStructureFlagsKHR) -> Self {
48635         self.inner.flags = flags;
48636         self
48637     }
48638     #[inline]
mode(mut self, mode: BuildAccelerationStructureModeKHR) -> Self48639     pub fn mode(mut self, mode: BuildAccelerationStructureModeKHR) -> Self {
48640         self.inner.mode = mode;
48641         self
48642     }
48643     #[inline]
src_acceleration_structure( mut self, src_acceleration_structure: AccelerationStructureKHR, ) -> Self48644     pub fn src_acceleration_structure(
48645         mut self,
48646         src_acceleration_structure: AccelerationStructureKHR,
48647     ) -> Self {
48648         self.inner.src_acceleration_structure = src_acceleration_structure;
48649         self
48650     }
48651     #[inline]
dst_acceleration_structure( mut self, dst_acceleration_structure: AccelerationStructureKHR, ) -> Self48652     pub fn dst_acceleration_structure(
48653         mut self,
48654         dst_acceleration_structure: AccelerationStructureKHR,
48655     ) -> Self {
48656         self.inner.dst_acceleration_structure = dst_acceleration_structure;
48657         self
48658     }
48659     #[inline]
geometries(mut self, geometries: &'a [AccelerationStructureGeometryKHR]) -> Self48660     pub fn geometries(mut self, geometries: &'a [AccelerationStructureGeometryKHR]) -> Self {
48661         self.inner.geometry_count = geometries.len() as _;
48662         self.inner.p_geometries = geometries.as_ptr();
48663         self
48664     }
48665     #[inline]
geometries_ptrs( mut self, geometries_ptrs: &'a [&'a AccelerationStructureGeometryKHR], ) -> Self48666     pub fn geometries_ptrs(
48667         mut self,
48668         geometries_ptrs: &'a [&'a AccelerationStructureGeometryKHR],
48669     ) -> Self {
48670         self.inner.geometry_count = geometries_ptrs.len() as _;
48671         self.inner.pp_geometries = geometries_ptrs.as_ptr().cast();
48672         self
48673     }
48674     #[inline]
scratch_data(mut self, scratch_data: DeviceOrHostAddressKHR) -> Self48675     pub fn scratch_data(mut self, scratch_data: DeviceOrHostAddressKHR) -> Self {
48676         self.inner.scratch_data = scratch_data;
48677         self
48678     }
48679     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48680     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48681     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureBuildGeometryInfoKHR48682     pub fn build(self) -> AccelerationStructureBuildGeometryInfoKHR {
48683         self.inner
48684     }
48685 }
48686 #[repr(C)]
48687 #[cfg_attr(feature = "debug", derive(Debug))]
48688 #[derive(Copy, Clone, Default)]
48689 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureBuildRangeInfoKHR.html>"]
48690 pub struct AccelerationStructureBuildRangeInfoKHR {
48691     pub primitive_count: u32,
48692     pub primitive_offset: u32,
48693     pub first_vertex: u32,
48694     pub transform_offset: u32,
48695 }
48696 impl AccelerationStructureBuildRangeInfoKHR {
builder<'a>() -> AccelerationStructureBuildRangeInfoKHRBuilder<'a>48697     pub fn builder<'a>() -> AccelerationStructureBuildRangeInfoKHRBuilder<'a> {
48698         AccelerationStructureBuildRangeInfoKHRBuilder {
48699             inner: Self::default(),
48700             marker: ::std::marker::PhantomData,
48701         }
48702     }
48703 }
48704 #[repr(transparent)]
48705 pub struct AccelerationStructureBuildRangeInfoKHRBuilder<'a> {
48706     inner: AccelerationStructureBuildRangeInfoKHR,
48707     marker: ::std::marker::PhantomData<&'a ()>,
48708 }
48709 impl<'a> ::std::ops::Deref for AccelerationStructureBuildRangeInfoKHRBuilder<'a> {
48710     type Target = AccelerationStructureBuildRangeInfoKHR;
deref(&self) -> &Self::Target48711     fn deref(&self) -> &Self::Target {
48712         &self.inner
48713     }
48714 }
48715 impl<'a> ::std::ops::DerefMut for AccelerationStructureBuildRangeInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target48716     fn deref_mut(&mut self) -> &mut Self::Target {
48717         &mut self.inner
48718     }
48719 }
48720 impl<'a> AccelerationStructureBuildRangeInfoKHRBuilder<'a> {
48721     #[inline]
primitive_count(mut self, primitive_count: u32) -> Self48722     pub fn primitive_count(mut self, primitive_count: u32) -> Self {
48723         self.inner.primitive_count = primitive_count;
48724         self
48725     }
48726     #[inline]
primitive_offset(mut self, primitive_offset: u32) -> Self48727     pub fn primitive_offset(mut self, primitive_offset: u32) -> Self {
48728         self.inner.primitive_offset = primitive_offset;
48729         self
48730     }
48731     #[inline]
first_vertex(mut self, first_vertex: u32) -> Self48732     pub fn first_vertex(mut self, first_vertex: u32) -> Self {
48733         self.inner.first_vertex = first_vertex;
48734         self
48735     }
48736     #[inline]
transform_offset(mut self, transform_offset: u32) -> Self48737     pub fn transform_offset(mut self, transform_offset: u32) -> Self {
48738         self.inner.transform_offset = transform_offset;
48739         self
48740     }
48741     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48742     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48743     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureBuildRangeInfoKHR48744     pub fn build(self) -> AccelerationStructureBuildRangeInfoKHR {
48745         self.inner
48746     }
48747 }
48748 #[repr(C)]
48749 #[cfg_attr(feature = "debug", derive(Debug))]
48750 #[derive(Copy, Clone)]
48751 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureCreateInfoKHR.html>"]
48752 pub struct AccelerationStructureCreateInfoKHR {
48753     pub s_type: StructureType,
48754     pub p_next: *const c_void,
48755     pub create_flags: AccelerationStructureCreateFlagsKHR,
48756     pub buffer: Buffer,
48757     pub offset: DeviceSize,
48758     pub size: DeviceSize,
48759     pub ty: AccelerationStructureTypeKHR,
48760     pub device_address: DeviceAddress,
48761 }
48762 impl ::std::default::Default for AccelerationStructureCreateInfoKHR {
48763     #[inline]
default() -> Self48764     fn default() -> Self {
48765         Self {
48766             s_type: Self::STRUCTURE_TYPE,
48767             p_next: ::std::ptr::null(),
48768             create_flags: AccelerationStructureCreateFlagsKHR::default(),
48769             buffer: Buffer::default(),
48770             offset: DeviceSize::default(),
48771             size: DeviceSize::default(),
48772             ty: AccelerationStructureTypeKHR::default(),
48773             device_address: DeviceAddress::default(),
48774         }
48775     }
48776 }
48777 unsafe impl TaggedStructure for AccelerationStructureCreateInfoKHR {
48778     const STRUCTURE_TYPE: StructureType = StructureType::ACCELERATION_STRUCTURE_CREATE_INFO_KHR;
48779 }
48780 impl AccelerationStructureCreateInfoKHR {
builder<'a>() -> AccelerationStructureCreateInfoKHRBuilder<'a>48781     pub fn builder<'a>() -> AccelerationStructureCreateInfoKHRBuilder<'a> {
48782         AccelerationStructureCreateInfoKHRBuilder {
48783             inner: Self::default(),
48784             marker: ::std::marker::PhantomData,
48785         }
48786     }
48787 }
48788 #[repr(transparent)]
48789 pub struct AccelerationStructureCreateInfoKHRBuilder<'a> {
48790     inner: AccelerationStructureCreateInfoKHR,
48791     marker: ::std::marker::PhantomData<&'a ()>,
48792 }
48793 pub unsafe trait ExtendsAccelerationStructureCreateInfoKHR {}
48794 impl<'a> ::std::ops::Deref for AccelerationStructureCreateInfoKHRBuilder<'a> {
48795     type Target = AccelerationStructureCreateInfoKHR;
deref(&self) -> &Self::Target48796     fn deref(&self) -> &Self::Target {
48797         &self.inner
48798     }
48799 }
48800 impl<'a> ::std::ops::DerefMut for AccelerationStructureCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target48801     fn deref_mut(&mut self) -> &mut Self::Target {
48802         &mut self.inner
48803     }
48804 }
48805 impl<'a> AccelerationStructureCreateInfoKHRBuilder<'a> {
48806     #[inline]
create_flags(mut self, create_flags: AccelerationStructureCreateFlagsKHR) -> Self48807     pub fn create_flags(mut self, create_flags: AccelerationStructureCreateFlagsKHR) -> Self {
48808         self.inner.create_flags = create_flags;
48809         self
48810     }
48811     #[inline]
buffer(mut self, buffer: Buffer) -> Self48812     pub fn buffer(mut self, buffer: Buffer) -> Self {
48813         self.inner.buffer = buffer;
48814         self
48815     }
48816     #[inline]
offset(mut self, offset: DeviceSize) -> Self48817     pub fn offset(mut self, offset: DeviceSize) -> Self {
48818         self.inner.offset = offset;
48819         self
48820     }
48821     #[inline]
size(mut self, size: DeviceSize) -> Self48822     pub fn size(mut self, size: DeviceSize) -> Self {
48823         self.inner.size = size;
48824         self
48825     }
48826     #[inline]
ty(mut self, ty: AccelerationStructureTypeKHR) -> Self48827     pub fn ty(mut self, ty: AccelerationStructureTypeKHR) -> Self {
48828         self.inner.ty = ty;
48829         self
48830     }
48831     #[inline]
device_address(mut self, device_address: DeviceAddress) -> Self48832     pub fn device_address(mut self, device_address: DeviceAddress) -> Self {
48833         self.inner.device_address = device_address;
48834         self
48835     }
48836     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
48837     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
48838     #[doc = r" valid extension structs can be pushed into the chain."]
48839     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
48840     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsAccelerationStructureCreateInfoKHR>( mut self, next: &'a mut T, ) -> Self48841     pub fn push_next<T: ExtendsAccelerationStructureCreateInfoKHR>(
48842         mut self,
48843         next: &'a mut T,
48844     ) -> Self {
48845         unsafe {
48846             let next_ptr = <*const T>::cast(next);
48847             let last_next = ptr_chain_iter(next).last().unwrap();
48848             (*last_next).p_next = self.inner.p_next as _;
48849             self.inner.p_next = next_ptr;
48850         }
48851         self
48852     }
48853     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48854     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48855     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureCreateInfoKHR48856     pub fn build(self) -> AccelerationStructureCreateInfoKHR {
48857         self.inner
48858     }
48859 }
48860 #[repr(C)]
48861 #[cfg_attr(feature = "debug", derive(Debug))]
48862 #[derive(Copy, Clone, Default)]
48863 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAabbPositionsKHR.html>"]
48864 pub struct AabbPositionsKHR {
48865     pub min_x: f32,
48866     pub min_y: f32,
48867     pub min_z: f32,
48868     pub max_x: f32,
48869     pub max_y: f32,
48870     pub max_z: f32,
48871 }
48872 impl AabbPositionsKHR {
builder<'a>() -> AabbPositionsKHRBuilder<'a>48873     pub fn builder<'a>() -> AabbPositionsKHRBuilder<'a> {
48874         AabbPositionsKHRBuilder {
48875             inner: Self::default(),
48876             marker: ::std::marker::PhantomData,
48877         }
48878     }
48879 }
48880 #[repr(transparent)]
48881 pub struct AabbPositionsKHRBuilder<'a> {
48882     inner: AabbPositionsKHR,
48883     marker: ::std::marker::PhantomData<&'a ()>,
48884 }
48885 impl<'a> ::std::ops::Deref for AabbPositionsKHRBuilder<'a> {
48886     type Target = AabbPositionsKHR;
deref(&self) -> &Self::Target48887     fn deref(&self) -> &Self::Target {
48888         &self.inner
48889     }
48890 }
48891 impl<'a> ::std::ops::DerefMut for AabbPositionsKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target48892     fn deref_mut(&mut self) -> &mut Self::Target {
48893         &mut self.inner
48894     }
48895 }
48896 impl<'a> AabbPositionsKHRBuilder<'a> {
48897     #[inline]
min_x(mut self, min_x: f32) -> Self48898     pub fn min_x(mut self, min_x: f32) -> Self {
48899         self.inner.min_x = min_x;
48900         self
48901     }
48902     #[inline]
min_y(mut self, min_y: f32) -> Self48903     pub fn min_y(mut self, min_y: f32) -> Self {
48904         self.inner.min_y = min_y;
48905         self
48906     }
48907     #[inline]
min_z(mut self, min_z: f32) -> Self48908     pub fn min_z(mut self, min_z: f32) -> Self {
48909         self.inner.min_z = min_z;
48910         self
48911     }
48912     #[inline]
max_x(mut self, max_x: f32) -> Self48913     pub fn max_x(mut self, max_x: f32) -> Self {
48914         self.inner.max_x = max_x;
48915         self
48916     }
48917     #[inline]
max_y(mut self, max_y: f32) -> Self48918     pub fn max_y(mut self, max_y: f32) -> Self {
48919         self.inner.max_y = max_y;
48920         self
48921     }
48922     #[inline]
max_z(mut self, max_z: f32) -> Self48923     pub fn max_z(mut self, max_z: f32) -> Self {
48924         self.inner.max_z = max_z;
48925         self
48926     }
48927     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48928     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48929     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AabbPositionsKHR48930     pub fn build(self) -> AabbPositionsKHR {
48931         self.inner
48932     }
48933 }
48934 #[repr(C)]
48935 #[derive(Copy, Clone)]
48936 pub struct TransformMatrixKHR {
48937     pub matrix: [f32; 12],
48938 }
48939 #[repr(C)]
48940 #[derive(Copy, Clone)]
48941 pub union AccelerationStructureReferenceKHR {
48942     pub device_handle: DeviceAddress,
48943     pub host_handle: AccelerationStructureKHR,
48944 }
48945 #[repr(C)]
48946 #[derive(Copy, Clone)]
48947 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureInstanceKHR.html>"]
48948 pub struct AccelerationStructureInstanceKHR {
48949     pub transform: TransformMatrixKHR,
48950     #[doc = r" Use [`Packed24_8::new(instance_custom_index, mask)`][Packed24_8::new()] to construct this field"]
48951     pub instance_custom_index_and_mask: Packed24_8,
48952     #[doc = r" Use [`Packed24_8::new(instance_shader_binding_table_record_offset, flags)`][Packed24_8::new()] to construct this field"]
48953     pub instance_shader_binding_table_record_offset_and_flags: Packed24_8,
48954     pub acceleration_structure_reference: AccelerationStructureReferenceKHR,
48955 }
48956 #[repr(C)]
48957 #[cfg_attr(feature = "debug", derive(Debug))]
48958 #[derive(Copy, Clone)]
48959 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureDeviceAddressInfoKHR.html>"]
48960 pub struct AccelerationStructureDeviceAddressInfoKHR {
48961     pub s_type: StructureType,
48962     pub p_next: *const c_void,
48963     pub acceleration_structure: AccelerationStructureKHR,
48964 }
48965 impl ::std::default::Default for AccelerationStructureDeviceAddressInfoKHR {
48966     #[inline]
default() -> Self48967     fn default() -> Self {
48968         Self {
48969             s_type: Self::STRUCTURE_TYPE,
48970             p_next: ::std::ptr::null(),
48971             acceleration_structure: AccelerationStructureKHR::default(),
48972         }
48973     }
48974 }
48975 unsafe impl TaggedStructure for AccelerationStructureDeviceAddressInfoKHR {
48976     const STRUCTURE_TYPE: StructureType =
48977         StructureType::ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR;
48978 }
48979 impl AccelerationStructureDeviceAddressInfoKHR {
builder<'a>() -> AccelerationStructureDeviceAddressInfoKHRBuilder<'a>48980     pub fn builder<'a>() -> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
48981         AccelerationStructureDeviceAddressInfoKHRBuilder {
48982             inner: Self::default(),
48983             marker: ::std::marker::PhantomData,
48984         }
48985     }
48986 }
48987 #[repr(transparent)]
48988 pub struct AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
48989     inner: AccelerationStructureDeviceAddressInfoKHR,
48990     marker: ::std::marker::PhantomData<&'a ()>,
48991 }
48992 impl<'a> ::std::ops::Deref for AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
48993     type Target = AccelerationStructureDeviceAddressInfoKHR;
deref(&self) -> &Self::Target48994     fn deref(&self) -> &Self::Target {
48995         &self.inner
48996     }
48997 }
48998 impl<'a> ::std::ops::DerefMut for AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target48999     fn deref_mut(&mut self) -> &mut Self::Target {
49000         &mut self.inner
49001     }
49002 }
49003 impl<'a> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
49004     #[inline]
acceleration_structure( mut self, acceleration_structure: AccelerationStructureKHR, ) -> Self49005     pub fn acceleration_structure(
49006         mut self,
49007         acceleration_structure: AccelerationStructureKHR,
49008     ) -> Self {
49009         self.inner.acceleration_structure = acceleration_structure;
49010         self
49011     }
49012     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49013     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49014     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureDeviceAddressInfoKHR49015     pub fn build(self) -> AccelerationStructureDeviceAddressInfoKHR {
49016         self.inner
49017     }
49018 }
49019 #[repr(C)]
49020 #[cfg_attr(feature = "debug", derive(Debug))]
49021 #[derive(Copy, Clone)]
49022 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureVersionInfoKHR.html>"]
49023 pub struct AccelerationStructureVersionInfoKHR {
49024     pub s_type: StructureType,
49025     pub p_next: *const c_void,
49026     pub p_version_data: *const [u8; 2 * UUID_SIZE],
49027 }
49028 impl ::std::default::Default for AccelerationStructureVersionInfoKHR {
49029     #[inline]
default() -> Self49030     fn default() -> Self {
49031         Self {
49032             s_type: Self::STRUCTURE_TYPE,
49033             p_next: ::std::ptr::null(),
49034             p_version_data: ::std::ptr::null(),
49035         }
49036     }
49037 }
49038 unsafe impl TaggedStructure for AccelerationStructureVersionInfoKHR {
49039     const STRUCTURE_TYPE: StructureType = StructureType::ACCELERATION_STRUCTURE_VERSION_INFO_KHR;
49040 }
49041 impl AccelerationStructureVersionInfoKHR {
builder<'a>() -> AccelerationStructureVersionInfoKHRBuilder<'a>49042     pub fn builder<'a>() -> AccelerationStructureVersionInfoKHRBuilder<'a> {
49043         AccelerationStructureVersionInfoKHRBuilder {
49044             inner: Self::default(),
49045             marker: ::std::marker::PhantomData,
49046         }
49047     }
49048 }
49049 #[repr(transparent)]
49050 pub struct AccelerationStructureVersionInfoKHRBuilder<'a> {
49051     inner: AccelerationStructureVersionInfoKHR,
49052     marker: ::std::marker::PhantomData<&'a ()>,
49053 }
49054 impl<'a> ::std::ops::Deref for AccelerationStructureVersionInfoKHRBuilder<'a> {
49055     type Target = AccelerationStructureVersionInfoKHR;
deref(&self) -> &Self::Target49056     fn deref(&self) -> &Self::Target {
49057         &self.inner
49058     }
49059 }
49060 impl<'a> ::std::ops::DerefMut for AccelerationStructureVersionInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target49061     fn deref_mut(&mut self) -> &mut Self::Target {
49062         &mut self.inner
49063     }
49064 }
49065 impl<'a> AccelerationStructureVersionInfoKHRBuilder<'a> {
49066     #[inline]
version_data(mut self, version_data: &'a [u8; 2 * UUID_SIZE]) -> Self49067     pub fn version_data(mut self, version_data: &'a [u8; 2 * UUID_SIZE]) -> Self {
49068         self.inner.p_version_data = version_data;
49069         self
49070     }
49071     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49072     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49073     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureVersionInfoKHR49074     pub fn build(self) -> AccelerationStructureVersionInfoKHR {
49075         self.inner
49076     }
49077 }
49078 #[repr(C)]
49079 #[cfg_attr(feature = "debug", derive(Debug))]
49080 #[derive(Copy, Clone)]
49081 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyAccelerationStructureInfoKHR.html>"]
49082 pub struct CopyAccelerationStructureInfoKHR {
49083     pub s_type: StructureType,
49084     pub p_next: *const c_void,
49085     pub src: AccelerationStructureKHR,
49086     pub dst: AccelerationStructureKHR,
49087     pub mode: CopyAccelerationStructureModeKHR,
49088 }
49089 impl ::std::default::Default for CopyAccelerationStructureInfoKHR {
49090     #[inline]
default() -> Self49091     fn default() -> Self {
49092         Self {
49093             s_type: Self::STRUCTURE_TYPE,
49094             p_next: ::std::ptr::null(),
49095             src: AccelerationStructureKHR::default(),
49096             dst: AccelerationStructureKHR::default(),
49097             mode: CopyAccelerationStructureModeKHR::default(),
49098         }
49099     }
49100 }
49101 unsafe impl TaggedStructure for CopyAccelerationStructureInfoKHR {
49102     const STRUCTURE_TYPE: StructureType = StructureType::COPY_ACCELERATION_STRUCTURE_INFO_KHR;
49103 }
49104 impl CopyAccelerationStructureInfoKHR {
builder<'a>() -> CopyAccelerationStructureInfoKHRBuilder<'a>49105     pub fn builder<'a>() -> CopyAccelerationStructureInfoKHRBuilder<'a> {
49106         CopyAccelerationStructureInfoKHRBuilder {
49107             inner: Self::default(),
49108             marker: ::std::marker::PhantomData,
49109         }
49110     }
49111 }
49112 #[repr(transparent)]
49113 pub struct CopyAccelerationStructureInfoKHRBuilder<'a> {
49114     inner: CopyAccelerationStructureInfoKHR,
49115     marker: ::std::marker::PhantomData<&'a ()>,
49116 }
49117 impl<'a> ::std::ops::Deref for CopyAccelerationStructureInfoKHRBuilder<'a> {
49118     type Target = CopyAccelerationStructureInfoKHR;
deref(&self) -> &Self::Target49119     fn deref(&self) -> &Self::Target {
49120         &self.inner
49121     }
49122 }
49123 impl<'a> ::std::ops::DerefMut for CopyAccelerationStructureInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target49124     fn deref_mut(&mut self) -> &mut Self::Target {
49125         &mut self.inner
49126     }
49127 }
49128 impl<'a> CopyAccelerationStructureInfoKHRBuilder<'a> {
49129     #[inline]
src(mut self, src: AccelerationStructureKHR) -> Self49130     pub fn src(mut self, src: AccelerationStructureKHR) -> Self {
49131         self.inner.src = src;
49132         self
49133     }
49134     #[inline]
dst(mut self, dst: AccelerationStructureKHR) -> Self49135     pub fn dst(mut self, dst: AccelerationStructureKHR) -> Self {
49136         self.inner.dst = dst;
49137         self
49138     }
49139     #[inline]
mode(mut self, mode: CopyAccelerationStructureModeKHR) -> Self49140     pub fn mode(mut self, mode: CopyAccelerationStructureModeKHR) -> Self {
49141         self.inner.mode = mode;
49142         self
49143     }
49144     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49145     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49146     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CopyAccelerationStructureInfoKHR49147     pub fn build(self) -> CopyAccelerationStructureInfoKHR {
49148         self.inner
49149     }
49150 }
49151 #[repr(C)]
49152 #[derive(Copy, Clone)]
49153 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyAccelerationStructureToMemoryInfoKHR.html>"]
49154 pub struct CopyAccelerationStructureToMemoryInfoKHR {
49155     pub s_type: StructureType,
49156     pub p_next: *const c_void,
49157     pub src: AccelerationStructureKHR,
49158     pub dst: DeviceOrHostAddressKHR,
49159     pub mode: CopyAccelerationStructureModeKHR,
49160 }
49161 #[cfg(feature = "debug")]
49162 impl fmt::Debug for CopyAccelerationStructureToMemoryInfoKHR {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result49163     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
49164         fmt.debug_struct("CopyAccelerationStructureToMemoryInfoKHR")
49165             .field("s_type", &self.s_type)
49166             .field("p_next", &self.p_next)
49167             .field("src", &self.src)
49168             .field("dst", &"union")
49169             .field("mode", &self.mode)
49170             .finish()
49171     }
49172 }
49173 impl ::std::default::Default for CopyAccelerationStructureToMemoryInfoKHR {
49174     #[inline]
default() -> Self49175     fn default() -> Self {
49176         Self {
49177             s_type: Self::STRUCTURE_TYPE,
49178             p_next: ::std::ptr::null(),
49179             src: AccelerationStructureKHR::default(),
49180             dst: DeviceOrHostAddressKHR::default(),
49181             mode: CopyAccelerationStructureModeKHR::default(),
49182         }
49183     }
49184 }
49185 unsafe impl TaggedStructure for CopyAccelerationStructureToMemoryInfoKHR {
49186     const STRUCTURE_TYPE: StructureType =
49187         StructureType::COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR;
49188 }
49189 impl CopyAccelerationStructureToMemoryInfoKHR {
builder<'a>() -> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a>49190     pub fn builder<'a>() -> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
49191         CopyAccelerationStructureToMemoryInfoKHRBuilder {
49192             inner: Self::default(),
49193             marker: ::std::marker::PhantomData,
49194         }
49195     }
49196 }
49197 #[repr(transparent)]
49198 pub struct CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
49199     inner: CopyAccelerationStructureToMemoryInfoKHR,
49200     marker: ::std::marker::PhantomData<&'a ()>,
49201 }
49202 impl<'a> ::std::ops::Deref for CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
49203     type Target = CopyAccelerationStructureToMemoryInfoKHR;
deref(&self) -> &Self::Target49204     fn deref(&self) -> &Self::Target {
49205         &self.inner
49206     }
49207 }
49208 impl<'a> ::std::ops::DerefMut for CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target49209     fn deref_mut(&mut self) -> &mut Self::Target {
49210         &mut self.inner
49211     }
49212 }
49213 impl<'a> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
49214     #[inline]
src(mut self, src: AccelerationStructureKHR) -> Self49215     pub fn src(mut self, src: AccelerationStructureKHR) -> Self {
49216         self.inner.src = src;
49217         self
49218     }
49219     #[inline]
dst(mut self, dst: DeviceOrHostAddressKHR) -> Self49220     pub fn dst(mut self, dst: DeviceOrHostAddressKHR) -> Self {
49221         self.inner.dst = dst;
49222         self
49223     }
49224     #[inline]
mode(mut self, mode: CopyAccelerationStructureModeKHR) -> Self49225     pub fn mode(mut self, mode: CopyAccelerationStructureModeKHR) -> Self {
49226         self.inner.mode = mode;
49227         self
49228     }
49229     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49230     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49231     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CopyAccelerationStructureToMemoryInfoKHR49232     pub fn build(self) -> CopyAccelerationStructureToMemoryInfoKHR {
49233         self.inner
49234     }
49235 }
49236 #[repr(C)]
49237 #[derive(Copy, Clone)]
49238 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyMemoryToAccelerationStructureInfoKHR.html>"]
49239 pub struct CopyMemoryToAccelerationStructureInfoKHR {
49240     pub s_type: StructureType,
49241     pub p_next: *const c_void,
49242     pub src: DeviceOrHostAddressConstKHR,
49243     pub dst: AccelerationStructureKHR,
49244     pub mode: CopyAccelerationStructureModeKHR,
49245 }
49246 #[cfg(feature = "debug")]
49247 impl fmt::Debug for CopyMemoryToAccelerationStructureInfoKHR {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result49248     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
49249         fmt.debug_struct("CopyMemoryToAccelerationStructureInfoKHR")
49250             .field("s_type", &self.s_type)
49251             .field("p_next", &self.p_next)
49252             .field("src", &"union")
49253             .field("dst", &self.dst)
49254             .field("mode", &self.mode)
49255             .finish()
49256     }
49257 }
49258 impl ::std::default::Default for CopyMemoryToAccelerationStructureInfoKHR {
49259     #[inline]
default() -> Self49260     fn default() -> Self {
49261         Self {
49262             s_type: Self::STRUCTURE_TYPE,
49263             p_next: ::std::ptr::null(),
49264             src: DeviceOrHostAddressConstKHR::default(),
49265             dst: AccelerationStructureKHR::default(),
49266             mode: CopyAccelerationStructureModeKHR::default(),
49267         }
49268     }
49269 }
49270 unsafe impl TaggedStructure for CopyMemoryToAccelerationStructureInfoKHR {
49271     const STRUCTURE_TYPE: StructureType =
49272         StructureType::COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR;
49273 }
49274 impl CopyMemoryToAccelerationStructureInfoKHR {
builder<'a>() -> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a>49275     pub fn builder<'a>() -> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
49276         CopyMemoryToAccelerationStructureInfoKHRBuilder {
49277             inner: Self::default(),
49278             marker: ::std::marker::PhantomData,
49279         }
49280     }
49281 }
49282 #[repr(transparent)]
49283 pub struct CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
49284     inner: CopyMemoryToAccelerationStructureInfoKHR,
49285     marker: ::std::marker::PhantomData<&'a ()>,
49286 }
49287 impl<'a> ::std::ops::Deref for CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
49288     type Target = CopyMemoryToAccelerationStructureInfoKHR;
deref(&self) -> &Self::Target49289     fn deref(&self) -> &Self::Target {
49290         &self.inner
49291     }
49292 }
49293 impl<'a> ::std::ops::DerefMut for CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target49294     fn deref_mut(&mut self) -> &mut Self::Target {
49295         &mut self.inner
49296     }
49297 }
49298 impl<'a> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
49299     #[inline]
src(mut self, src: DeviceOrHostAddressConstKHR) -> Self49300     pub fn src(mut self, src: DeviceOrHostAddressConstKHR) -> Self {
49301         self.inner.src = src;
49302         self
49303     }
49304     #[inline]
dst(mut self, dst: AccelerationStructureKHR) -> Self49305     pub fn dst(mut self, dst: AccelerationStructureKHR) -> Self {
49306         self.inner.dst = dst;
49307         self
49308     }
49309     #[inline]
mode(mut self, mode: CopyAccelerationStructureModeKHR) -> Self49310     pub fn mode(mut self, mode: CopyAccelerationStructureModeKHR) -> Self {
49311         self.inner.mode = mode;
49312         self
49313     }
49314     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49315     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49316     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CopyMemoryToAccelerationStructureInfoKHR49317     pub fn build(self) -> CopyMemoryToAccelerationStructureInfoKHR {
49318         self.inner
49319     }
49320 }
49321 #[repr(C)]
49322 #[cfg_attr(feature = "debug", derive(Debug))]
49323 #[derive(Copy, Clone)]
49324 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRayTracingPipelineInterfaceCreateInfoKHR.html>"]
49325 pub struct RayTracingPipelineInterfaceCreateInfoKHR {
49326     pub s_type: StructureType,
49327     pub p_next: *const c_void,
49328     pub max_pipeline_ray_payload_size: u32,
49329     pub max_pipeline_ray_hit_attribute_size: u32,
49330 }
49331 impl ::std::default::Default for RayTracingPipelineInterfaceCreateInfoKHR {
49332     #[inline]
default() -> Self49333     fn default() -> Self {
49334         Self {
49335             s_type: Self::STRUCTURE_TYPE,
49336             p_next: ::std::ptr::null(),
49337             max_pipeline_ray_payload_size: u32::default(),
49338             max_pipeline_ray_hit_attribute_size: u32::default(),
49339         }
49340     }
49341 }
49342 unsafe impl TaggedStructure for RayTracingPipelineInterfaceCreateInfoKHR {
49343     const STRUCTURE_TYPE: StructureType =
49344         StructureType::RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR;
49345 }
49346 impl RayTracingPipelineInterfaceCreateInfoKHR {
builder<'a>() -> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a>49347     pub fn builder<'a>() -> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
49348         RayTracingPipelineInterfaceCreateInfoKHRBuilder {
49349             inner: Self::default(),
49350             marker: ::std::marker::PhantomData,
49351         }
49352     }
49353 }
49354 #[repr(transparent)]
49355 pub struct RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
49356     inner: RayTracingPipelineInterfaceCreateInfoKHR,
49357     marker: ::std::marker::PhantomData<&'a ()>,
49358 }
49359 impl<'a> ::std::ops::Deref for RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
49360     type Target = RayTracingPipelineInterfaceCreateInfoKHR;
deref(&self) -> &Self::Target49361     fn deref(&self) -> &Self::Target {
49362         &self.inner
49363     }
49364 }
49365 impl<'a> ::std::ops::DerefMut for RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target49366     fn deref_mut(&mut self) -> &mut Self::Target {
49367         &mut self.inner
49368     }
49369 }
49370 impl<'a> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
49371     #[inline]
max_pipeline_ray_payload_size(mut self, max_pipeline_ray_payload_size: u32) -> Self49372     pub fn max_pipeline_ray_payload_size(mut self, max_pipeline_ray_payload_size: u32) -> Self {
49373         self.inner.max_pipeline_ray_payload_size = max_pipeline_ray_payload_size;
49374         self
49375     }
49376     #[inline]
max_pipeline_ray_hit_attribute_size( mut self, max_pipeline_ray_hit_attribute_size: u32, ) -> Self49377     pub fn max_pipeline_ray_hit_attribute_size(
49378         mut self,
49379         max_pipeline_ray_hit_attribute_size: u32,
49380     ) -> Self {
49381         self.inner.max_pipeline_ray_hit_attribute_size = max_pipeline_ray_hit_attribute_size;
49382         self
49383     }
49384     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49385     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49386     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RayTracingPipelineInterfaceCreateInfoKHR49387     pub fn build(self) -> RayTracingPipelineInterfaceCreateInfoKHR {
49388         self.inner
49389     }
49390 }
49391 #[repr(C)]
49392 #[cfg_attr(feature = "debug", derive(Debug))]
49393 #[derive(Copy, Clone)]
49394 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineLibraryCreateInfoKHR.html>"]
49395 pub struct PipelineLibraryCreateInfoKHR {
49396     pub s_type: StructureType,
49397     pub p_next: *const c_void,
49398     pub library_count: u32,
49399     pub p_libraries: *const Pipeline,
49400 }
49401 impl ::std::default::Default for PipelineLibraryCreateInfoKHR {
49402     #[inline]
default() -> Self49403     fn default() -> Self {
49404         Self {
49405             s_type: Self::STRUCTURE_TYPE,
49406             p_next: ::std::ptr::null(),
49407             library_count: u32::default(),
49408             p_libraries: ::std::ptr::null(),
49409         }
49410     }
49411 }
49412 unsafe impl TaggedStructure for PipelineLibraryCreateInfoKHR {
49413     const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_LIBRARY_CREATE_INFO_KHR;
49414 }
49415 impl PipelineLibraryCreateInfoKHR {
builder<'a>() -> PipelineLibraryCreateInfoKHRBuilder<'a>49416     pub fn builder<'a>() -> PipelineLibraryCreateInfoKHRBuilder<'a> {
49417         PipelineLibraryCreateInfoKHRBuilder {
49418             inner: Self::default(),
49419             marker: ::std::marker::PhantomData,
49420         }
49421     }
49422 }
49423 #[repr(transparent)]
49424 pub struct PipelineLibraryCreateInfoKHRBuilder<'a> {
49425     inner: PipelineLibraryCreateInfoKHR,
49426     marker: ::std::marker::PhantomData<&'a ()>,
49427 }
49428 unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineLibraryCreateInfoKHRBuilder<'_> {}
49429 unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineLibraryCreateInfoKHR {}
49430 impl<'a> ::std::ops::Deref for PipelineLibraryCreateInfoKHRBuilder<'a> {
49431     type Target = PipelineLibraryCreateInfoKHR;
deref(&self) -> &Self::Target49432     fn deref(&self) -> &Self::Target {
49433         &self.inner
49434     }
49435 }
49436 impl<'a> ::std::ops::DerefMut for PipelineLibraryCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target49437     fn deref_mut(&mut self) -> &mut Self::Target {
49438         &mut self.inner
49439     }
49440 }
49441 impl<'a> PipelineLibraryCreateInfoKHRBuilder<'a> {
49442     #[inline]
libraries(mut self, libraries: &'a [Pipeline]) -> Self49443     pub fn libraries(mut self, libraries: &'a [Pipeline]) -> Self {
49444         self.inner.library_count = libraries.len() as _;
49445         self.inner.p_libraries = libraries.as_ptr();
49446         self
49447     }
49448     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49449     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49450     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineLibraryCreateInfoKHR49451     pub fn build(self) -> PipelineLibraryCreateInfoKHR {
49452         self.inner
49453     }
49454 }
49455 #[repr(C)]
49456 #[cfg_attr(feature = "debug", derive(Debug))]
49457 #[derive(Copy, Clone)]
49458 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExtendedDynamicStateFeaturesEXT.html>"]
49459 pub struct PhysicalDeviceExtendedDynamicStateFeaturesEXT {
49460     pub s_type: StructureType,
49461     pub p_next: *mut c_void,
49462     pub extended_dynamic_state: Bool32,
49463 }
49464 impl ::std::default::Default for PhysicalDeviceExtendedDynamicStateFeaturesEXT {
49465     #[inline]
default() -> Self49466     fn default() -> Self {
49467         Self {
49468             s_type: Self::STRUCTURE_TYPE,
49469             p_next: ::std::ptr::null_mut(),
49470             extended_dynamic_state: Bool32::default(),
49471         }
49472     }
49473 }
49474 unsafe impl TaggedStructure for PhysicalDeviceExtendedDynamicStateFeaturesEXT {
49475     const STRUCTURE_TYPE: StructureType =
49476         StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
49477 }
49478 impl PhysicalDeviceExtendedDynamicStateFeaturesEXT {
builder<'a>() -> PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a>49479     pub fn builder<'a>() -> PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> {
49480         PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder {
49481             inner: Self::default(),
49482             marker: ::std::marker::PhantomData,
49483         }
49484     }
49485 }
49486 #[repr(transparent)]
49487 pub struct PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> {
49488     inner: PhysicalDeviceExtendedDynamicStateFeaturesEXT,
49489     marker: ::std::marker::PhantomData<&'a ()>,
49490 }
49491 unsafe impl ExtendsPhysicalDeviceFeatures2
49492     for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'_>
49493 {
49494 }
49495 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExtendedDynamicStateFeaturesEXT {}
49496 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'_> {}
49497 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicStateFeaturesEXT {}
49498 impl<'a> ::std::ops::Deref for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> {
49499     type Target = PhysicalDeviceExtendedDynamicStateFeaturesEXT;
deref(&self) -> &Self::Target49500     fn deref(&self) -> &Self::Target {
49501         &self.inner
49502     }
49503 }
49504 impl<'a> ::std::ops::DerefMut for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target49505     fn deref_mut(&mut self) -> &mut Self::Target {
49506         &mut self.inner
49507     }
49508 }
49509 impl<'a> PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> {
49510     #[inline]
extended_dynamic_state(mut self, extended_dynamic_state: bool) -> Self49511     pub fn extended_dynamic_state(mut self, extended_dynamic_state: bool) -> Self {
49512         self.inner.extended_dynamic_state = extended_dynamic_state.into();
49513         self
49514     }
49515     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49516     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49517     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceExtendedDynamicStateFeaturesEXT49518     pub fn build(self) -> PhysicalDeviceExtendedDynamicStateFeaturesEXT {
49519         self.inner
49520     }
49521 }
49522 #[repr(C)]
49523 #[cfg_attr(feature = "debug", derive(Debug))]
49524 #[derive(Copy, Clone)]
49525 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExtendedDynamicState2FeaturesEXT.html>"]
49526 pub struct PhysicalDeviceExtendedDynamicState2FeaturesEXT {
49527     pub s_type: StructureType,
49528     pub p_next: *mut c_void,
49529     pub extended_dynamic_state2: Bool32,
49530     pub extended_dynamic_state2_logic_op: Bool32,
49531     pub extended_dynamic_state2_patch_control_points: Bool32,
49532 }
49533 impl ::std::default::Default for PhysicalDeviceExtendedDynamicState2FeaturesEXT {
49534     #[inline]
default() -> Self49535     fn default() -> Self {
49536         Self {
49537             s_type: Self::STRUCTURE_TYPE,
49538             p_next: ::std::ptr::null_mut(),
49539             extended_dynamic_state2: Bool32::default(),
49540             extended_dynamic_state2_logic_op: Bool32::default(),
49541             extended_dynamic_state2_patch_control_points: Bool32::default(),
49542         }
49543     }
49544 }
49545 unsafe impl TaggedStructure for PhysicalDeviceExtendedDynamicState2FeaturesEXT {
49546     const STRUCTURE_TYPE: StructureType =
49547         StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
49548 }
49549 impl PhysicalDeviceExtendedDynamicState2FeaturesEXT {
builder<'a>() -> PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a>49550     pub fn builder<'a>() -> PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> {
49551         PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder {
49552             inner: Self::default(),
49553             marker: ::std::marker::PhantomData,
49554         }
49555     }
49556 }
49557 #[repr(transparent)]
49558 pub struct PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> {
49559     inner: PhysicalDeviceExtendedDynamicState2FeaturesEXT,
49560     marker: ::std::marker::PhantomData<&'a ()>,
49561 }
49562 unsafe impl ExtendsPhysicalDeviceFeatures2
49563     for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'_>
49564 {
49565 }
49566 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExtendedDynamicState2FeaturesEXT {}
49567 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'_> {}
49568 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicState2FeaturesEXT {}
49569 impl<'a> ::std::ops::Deref for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> {
49570     type Target = PhysicalDeviceExtendedDynamicState2FeaturesEXT;
deref(&self) -> &Self::Target49571     fn deref(&self) -> &Self::Target {
49572         &self.inner
49573     }
49574 }
49575 impl<'a> ::std::ops::DerefMut for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target49576     fn deref_mut(&mut self) -> &mut Self::Target {
49577         &mut self.inner
49578     }
49579 }
49580 impl<'a> PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> {
49581     #[inline]
extended_dynamic_state2(mut self, extended_dynamic_state2: bool) -> Self49582     pub fn extended_dynamic_state2(mut self, extended_dynamic_state2: bool) -> Self {
49583         self.inner.extended_dynamic_state2 = extended_dynamic_state2.into();
49584         self
49585     }
49586     #[inline]
extended_dynamic_state2_logic_op( mut self, extended_dynamic_state2_logic_op: bool, ) -> Self49587     pub fn extended_dynamic_state2_logic_op(
49588         mut self,
49589         extended_dynamic_state2_logic_op: bool,
49590     ) -> Self {
49591         self.inner.extended_dynamic_state2_logic_op = extended_dynamic_state2_logic_op.into();
49592         self
49593     }
49594     #[inline]
extended_dynamic_state2_patch_control_points( mut self, extended_dynamic_state2_patch_control_points: bool, ) -> Self49595     pub fn extended_dynamic_state2_patch_control_points(
49596         mut self,
49597         extended_dynamic_state2_patch_control_points: bool,
49598     ) -> Self {
49599         self.inner.extended_dynamic_state2_patch_control_points =
49600             extended_dynamic_state2_patch_control_points.into();
49601         self
49602     }
49603     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49604     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49605     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceExtendedDynamicState2FeaturesEXT49606     pub fn build(self) -> PhysicalDeviceExtendedDynamicState2FeaturesEXT {
49607         self.inner
49608     }
49609 }
49610 #[repr(C)]
49611 #[cfg_attr(feature = "debug", derive(Debug))]
49612 #[derive(Copy, Clone)]
49613 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.html>"]
49614 pub struct PhysicalDeviceExtendedDynamicState3FeaturesEXT {
49615     pub s_type: StructureType,
49616     pub p_next: *mut c_void,
49617     pub extended_dynamic_state3_tessellation_domain_origin: Bool32,
49618     pub extended_dynamic_state3_depth_clamp_enable: Bool32,
49619     pub extended_dynamic_state3_polygon_mode: Bool32,
49620     pub extended_dynamic_state3_rasterization_samples: Bool32,
49621     pub extended_dynamic_state3_sample_mask: Bool32,
49622     pub extended_dynamic_state3_alpha_to_coverage_enable: Bool32,
49623     pub extended_dynamic_state3_alpha_to_one_enable: Bool32,
49624     pub extended_dynamic_state3_logic_op_enable: Bool32,
49625     pub extended_dynamic_state3_color_blend_enable: Bool32,
49626     pub extended_dynamic_state3_color_blend_equation: Bool32,
49627     pub extended_dynamic_state3_color_write_mask: Bool32,
49628     pub extended_dynamic_state3_rasterization_stream: Bool32,
49629     pub extended_dynamic_state3_conservative_rasterization_mode: Bool32,
49630     pub extended_dynamic_state3_extra_primitive_overestimation_size: Bool32,
49631     pub extended_dynamic_state3_depth_clip_enable: Bool32,
49632     pub extended_dynamic_state3_sample_locations_enable: Bool32,
49633     pub extended_dynamic_state3_color_blend_advanced: Bool32,
49634     pub extended_dynamic_state3_provoking_vertex_mode: Bool32,
49635     pub extended_dynamic_state3_line_rasterization_mode: Bool32,
49636     pub extended_dynamic_state3_line_stipple_enable: Bool32,
49637     pub extended_dynamic_state3_depth_clip_negative_one_to_one: Bool32,
49638     pub extended_dynamic_state3_viewport_w_scaling_enable: Bool32,
49639     pub extended_dynamic_state3_viewport_swizzle: Bool32,
49640     pub extended_dynamic_state3_coverage_to_color_enable: Bool32,
49641     pub extended_dynamic_state3_coverage_to_color_location: Bool32,
49642     pub extended_dynamic_state3_coverage_modulation_mode: Bool32,
49643     pub extended_dynamic_state3_coverage_modulation_table_enable: Bool32,
49644     pub extended_dynamic_state3_coverage_modulation_table: Bool32,
49645     pub extended_dynamic_state3_coverage_reduction_mode: Bool32,
49646     pub extended_dynamic_state3_representative_fragment_test_enable: Bool32,
49647     pub extended_dynamic_state3_shading_rate_image_enable: Bool32,
49648 }
49649 impl ::std::default::Default for PhysicalDeviceExtendedDynamicState3FeaturesEXT {
49650     #[inline]
default() -> Self49651     fn default() -> Self {
49652         Self {
49653             s_type: Self::STRUCTURE_TYPE,
49654             p_next: ::std::ptr::null_mut(),
49655             extended_dynamic_state3_tessellation_domain_origin: Bool32::default(),
49656             extended_dynamic_state3_depth_clamp_enable: Bool32::default(),
49657             extended_dynamic_state3_polygon_mode: Bool32::default(),
49658             extended_dynamic_state3_rasterization_samples: Bool32::default(),
49659             extended_dynamic_state3_sample_mask: Bool32::default(),
49660             extended_dynamic_state3_alpha_to_coverage_enable: Bool32::default(),
49661             extended_dynamic_state3_alpha_to_one_enable: Bool32::default(),
49662             extended_dynamic_state3_logic_op_enable: Bool32::default(),
49663             extended_dynamic_state3_color_blend_enable: Bool32::default(),
49664             extended_dynamic_state3_color_blend_equation: Bool32::default(),
49665             extended_dynamic_state3_color_write_mask: Bool32::default(),
49666             extended_dynamic_state3_rasterization_stream: Bool32::default(),
49667             extended_dynamic_state3_conservative_rasterization_mode: Bool32::default(),
49668             extended_dynamic_state3_extra_primitive_overestimation_size: Bool32::default(),
49669             extended_dynamic_state3_depth_clip_enable: Bool32::default(),
49670             extended_dynamic_state3_sample_locations_enable: Bool32::default(),
49671             extended_dynamic_state3_color_blend_advanced: Bool32::default(),
49672             extended_dynamic_state3_provoking_vertex_mode: Bool32::default(),
49673             extended_dynamic_state3_line_rasterization_mode: Bool32::default(),
49674             extended_dynamic_state3_line_stipple_enable: Bool32::default(),
49675             extended_dynamic_state3_depth_clip_negative_one_to_one: Bool32::default(),
49676             extended_dynamic_state3_viewport_w_scaling_enable: Bool32::default(),
49677             extended_dynamic_state3_viewport_swizzle: Bool32::default(),
49678             extended_dynamic_state3_coverage_to_color_enable: Bool32::default(),
49679             extended_dynamic_state3_coverage_to_color_location: Bool32::default(),
49680             extended_dynamic_state3_coverage_modulation_mode: Bool32::default(),
49681             extended_dynamic_state3_coverage_modulation_table_enable: Bool32::default(),
49682             extended_dynamic_state3_coverage_modulation_table: Bool32::default(),
49683             extended_dynamic_state3_coverage_reduction_mode: Bool32::default(),
49684             extended_dynamic_state3_representative_fragment_test_enable: Bool32::default(),
49685             extended_dynamic_state3_shading_rate_image_enable: Bool32::default(),
49686         }
49687     }
49688 }
49689 unsafe impl TaggedStructure for PhysicalDeviceExtendedDynamicState3FeaturesEXT {
49690     const STRUCTURE_TYPE: StructureType =
49691         StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
49692 }
49693 impl PhysicalDeviceExtendedDynamicState3FeaturesEXT {
builder<'a>() -> PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'a>49694     pub fn builder<'a>() -> PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'a> {
49695         PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder {
49696             inner: Self::default(),
49697             marker: ::std::marker::PhantomData,
49698         }
49699     }
49700 }
49701 #[repr(transparent)]
49702 pub struct PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'a> {
49703     inner: PhysicalDeviceExtendedDynamicState3FeaturesEXT,
49704     marker: ::std::marker::PhantomData<&'a ()>,
49705 }
49706 unsafe impl ExtendsPhysicalDeviceFeatures2
49707     for PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'_>
49708 {
49709 }
49710 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExtendedDynamicState3FeaturesEXT {}
49711 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'_> {}
49712 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicState3FeaturesEXT {}
49713 impl<'a> ::std::ops::Deref for PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'a> {
49714     type Target = PhysicalDeviceExtendedDynamicState3FeaturesEXT;
deref(&self) -> &Self::Target49715     fn deref(&self) -> &Self::Target {
49716         &self.inner
49717     }
49718 }
49719 impl<'a> ::std::ops::DerefMut for PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target49720     fn deref_mut(&mut self) -> &mut Self::Target {
49721         &mut self.inner
49722     }
49723 }
49724 impl<'a> PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'a> {
49725     #[inline]
extended_dynamic_state3_tessellation_domain_origin( mut self, extended_dynamic_state3_tessellation_domain_origin: bool, ) -> Self49726     pub fn extended_dynamic_state3_tessellation_domain_origin(
49727         mut self,
49728         extended_dynamic_state3_tessellation_domain_origin: bool,
49729     ) -> Self {
49730         self.inner
49731             .extended_dynamic_state3_tessellation_domain_origin =
49732             extended_dynamic_state3_tessellation_domain_origin.into();
49733         self
49734     }
49735     #[inline]
extended_dynamic_state3_depth_clamp_enable( mut self, extended_dynamic_state3_depth_clamp_enable: bool, ) -> Self49736     pub fn extended_dynamic_state3_depth_clamp_enable(
49737         mut self,
49738         extended_dynamic_state3_depth_clamp_enable: bool,
49739     ) -> Self {
49740         self.inner.extended_dynamic_state3_depth_clamp_enable =
49741             extended_dynamic_state3_depth_clamp_enable.into();
49742         self
49743     }
49744     #[inline]
extended_dynamic_state3_polygon_mode( mut self, extended_dynamic_state3_polygon_mode: bool, ) -> Self49745     pub fn extended_dynamic_state3_polygon_mode(
49746         mut self,
49747         extended_dynamic_state3_polygon_mode: bool,
49748     ) -> Self {
49749         self.inner.extended_dynamic_state3_polygon_mode =
49750             extended_dynamic_state3_polygon_mode.into();
49751         self
49752     }
49753     #[inline]
extended_dynamic_state3_rasterization_samples( mut self, extended_dynamic_state3_rasterization_samples: bool, ) -> Self49754     pub fn extended_dynamic_state3_rasterization_samples(
49755         mut self,
49756         extended_dynamic_state3_rasterization_samples: bool,
49757     ) -> Self {
49758         self.inner.extended_dynamic_state3_rasterization_samples =
49759             extended_dynamic_state3_rasterization_samples.into();
49760         self
49761     }
49762     #[inline]
extended_dynamic_state3_sample_mask( mut self, extended_dynamic_state3_sample_mask: bool, ) -> Self49763     pub fn extended_dynamic_state3_sample_mask(
49764         mut self,
49765         extended_dynamic_state3_sample_mask: bool,
49766     ) -> Self {
49767         self.inner.extended_dynamic_state3_sample_mask = extended_dynamic_state3_sample_mask.into();
49768         self
49769     }
49770     #[inline]
extended_dynamic_state3_alpha_to_coverage_enable( mut self, extended_dynamic_state3_alpha_to_coverage_enable: bool, ) -> Self49771     pub fn extended_dynamic_state3_alpha_to_coverage_enable(
49772         mut self,
49773         extended_dynamic_state3_alpha_to_coverage_enable: bool,
49774     ) -> Self {
49775         self.inner.extended_dynamic_state3_alpha_to_coverage_enable =
49776             extended_dynamic_state3_alpha_to_coverage_enable.into();
49777         self
49778     }
49779     #[inline]
extended_dynamic_state3_alpha_to_one_enable( mut self, extended_dynamic_state3_alpha_to_one_enable: bool, ) -> Self49780     pub fn extended_dynamic_state3_alpha_to_one_enable(
49781         mut self,
49782         extended_dynamic_state3_alpha_to_one_enable: bool,
49783     ) -> Self {
49784         self.inner.extended_dynamic_state3_alpha_to_one_enable =
49785             extended_dynamic_state3_alpha_to_one_enable.into();
49786         self
49787     }
49788     #[inline]
extended_dynamic_state3_logic_op_enable( mut self, extended_dynamic_state3_logic_op_enable: bool, ) -> Self49789     pub fn extended_dynamic_state3_logic_op_enable(
49790         mut self,
49791         extended_dynamic_state3_logic_op_enable: bool,
49792     ) -> Self {
49793         self.inner.extended_dynamic_state3_logic_op_enable =
49794             extended_dynamic_state3_logic_op_enable.into();
49795         self
49796     }
49797     #[inline]
extended_dynamic_state3_color_blend_enable( mut self, extended_dynamic_state3_color_blend_enable: bool, ) -> Self49798     pub fn extended_dynamic_state3_color_blend_enable(
49799         mut self,
49800         extended_dynamic_state3_color_blend_enable: bool,
49801     ) -> Self {
49802         self.inner.extended_dynamic_state3_color_blend_enable =
49803             extended_dynamic_state3_color_blend_enable.into();
49804         self
49805     }
49806     #[inline]
extended_dynamic_state3_color_blend_equation( mut self, extended_dynamic_state3_color_blend_equation: bool, ) -> Self49807     pub fn extended_dynamic_state3_color_blend_equation(
49808         mut self,
49809         extended_dynamic_state3_color_blend_equation: bool,
49810     ) -> Self {
49811         self.inner.extended_dynamic_state3_color_blend_equation =
49812             extended_dynamic_state3_color_blend_equation.into();
49813         self
49814     }
49815     #[inline]
extended_dynamic_state3_color_write_mask( mut self, extended_dynamic_state3_color_write_mask: bool, ) -> Self49816     pub fn extended_dynamic_state3_color_write_mask(
49817         mut self,
49818         extended_dynamic_state3_color_write_mask: bool,
49819     ) -> Self {
49820         self.inner.extended_dynamic_state3_color_write_mask =
49821             extended_dynamic_state3_color_write_mask.into();
49822         self
49823     }
49824     #[inline]
extended_dynamic_state3_rasterization_stream( mut self, extended_dynamic_state3_rasterization_stream: bool, ) -> Self49825     pub fn extended_dynamic_state3_rasterization_stream(
49826         mut self,
49827         extended_dynamic_state3_rasterization_stream: bool,
49828     ) -> Self {
49829         self.inner.extended_dynamic_state3_rasterization_stream =
49830             extended_dynamic_state3_rasterization_stream.into();
49831         self
49832     }
49833     #[inline]
extended_dynamic_state3_conservative_rasterization_mode( mut self, extended_dynamic_state3_conservative_rasterization_mode: bool, ) -> Self49834     pub fn extended_dynamic_state3_conservative_rasterization_mode(
49835         mut self,
49836         extended_dynamic_state3_conservative_rasterization_mode: bool,
49837     ) -> Self {
49838         self.inner
49839             .extended_dynamic_state3_conservative_rasterization_mode =
49840             extended_dynamic_state3_conservative_rasterization_mode.into();
49841         self
49842     }
49843     #[inline]
extended_dynamic_state3_extra_primitive_overestimation_size( mut self, extended_dynamic_state3_extra_primitive_overestimation_size: bool, ) -> Self49844     pub fn extended_dynamic_state3_extra_primitive_overestimation_size(
49845         mut self,
49846         extended_dynamic_state3_extra_primitive_overestimation_size: bool,
49847     ) -> Self {
49848         self.inner
49849             .extended_dynamic_state3_extra_primitive_overestimation_size =
49850             extended_dynamic_state3_extra_primitive_overestimation_size.into();
49851         self
49852     }
49853     #[inline]
extended_dynamic_state3_depth_clip_enable( mut self, extended_dynamic_state3_depth_clip_enable: bool, ) -> Self49854     pub fn extended_dynamic_state3_depth_clip_enable(
49855         mut self,
49856         extended_dynamic_state3_depth_clip_enable: bool,
49857     ) -> Self {
49858         self.inner.extended_dynamic_state3_depth_clip_enable =
49859             extended_dynamic_state3_depth_clip_enable.into();
49860         self
49861     }
49862     #[inline]
extended_dynamic_state3_sample_locations_enable( mut self, extended_dynamic_state3_sample_locations_enable: bool, ) -> Self49863     pub fn extended_dynamic_state3_sample_locations_enable(
49864         mut self,
49865         extended_dynamic_state3_sample_locations_enable: bool,
49866     ) -> Self {
49867         self.inner.extended_dynamic_state3_sample_locations_enable =
49868             extended_dynamic_state3_sample_locations_enable.into();
49869         self
49870     }
49871     #[inline]
extended_dynamic_state3_color_blend_advanced( mut self, extended_dynamic_state3_color_blend_advanced: bool, ) -> Self49872     pub fn extended_dynamic_state3_color_blend_advanced(
49873         mut self,
49874         extended_dynamic_state3_color_blend_advanced: bool,
49875     ) -> Self {
49876         self.inner.extended_dynamic_state3_color_blend_advanced =
49877             extended_dynamic_state3_color_blend_advanced.into();
49878         self
49879     }
49880     #[inline]
extended_dynamic_state3_provoking_vertex_mode( mut self, extended_dynamic_state3_provoking_vertex_mode: bool, ) -> Self49881     pub fn extended_dynamic_state3_provoking_vertex_mode(
49882         mut self,
49883         extended_dynamic_state3_provoking_vertex_mode: bool,
49884     ) -> Self {
49885         self.inner.extended_dynamic_state3_provoking_vertex_mode =
49886             extended_dynamic_state3_provoking_vertex_mode.into();
49887         self
49888     }
49889     #[inline]
extended_dynamic_state3_line_rasterization_mode( mut self, extended_dynamic_state3_line_rasterization_mode: bool, ) -> Self49890     pub fn extended_dynamic_state3_line_rasterization_mode(
49891         mut self,
49892         extended_dynamic_state3_line_rasterization_mode: bool,
49893     ) -> Self {
49894         self.inner.extended_dynamic_state3_line_rasterization_mode =
49895             extended_dynamic_state3_line_rasterization_mode.into();
49896         self
49897     }
49898     #[inline]
extended_dynamic_state3_line_stipple_enable( mut self, extended_dynamic_state3_line_stipple_enable: bool, ) -> Self49899     pub fn extended_dynamic_state3_line_stipple_enable(
49900         mut self,
49901         extended_dynamic_state3_line_stipple_enable: bool,
49902     ) -> Self {
49903         self.inner.extended_dynamic_state3_line_stipple_enable =
49904             extended_dynamic_state3_line_stipple_enable.into();
49905         self
49906     }
49907     #[inline]
extended_dynamic_state3_depth_clip_negative_one_to_one( mut self, extended_dynamic_state3_depth_clip_negative_one_to_one: bool, ) -> Self49908     pub fn extended_dynamic_state3_depth_clip_negative_one_to_one(
49909         mut self,
49910         extended_dynamic_state3_depth_clip_negative_one_to_one: bool,
49911     ) -> Self {
49912         self.inner
49913             .extended_dynamic_state3_depth_clip_negative_one_to_one =
49914             extended_dynamic_state3_depth_clip_negative_one_to_one.into();
49915         self
49916     }
49917     #[inline]
extended_dynamic_state3_viewport_w_scaling_enable( mut self, extended_dynamic_state3_viewport_w_scaling_enable: bool, ) -> Self49918     pub fn extended_dynamic_state3_viewport_w_scaling_enable(
49919         mut self,
49920         extended_dynamic_state3_viewport_w_scaling_enable: bool,
49921     ) -> Self {
49922         self.inner.extended_dynamic_state3_viewport_w_scaling_enable =
49923             extended_dynamic_state3_viewport_w_scaling_enable.into();
49924         self
49925     }
49926     #[inline]
extended_dynamic_state3_viewport_swizzle( mut self, extended_dynamic_state3_viewport_swizzle: bool, ) -> Self49927     pub fn extended_dynamic_state3_viewport_swizzle(
49928         mut self,
49929         extended_dynamic_state3_viewport_swizzle: bool,
49930     ) -> Self {
49931         self.inner.extended_dynamic_state3_viewport_swizzle =
49932             extended_dynamic_state3_viewport_swizzle.into();
49933         self
49934     }
49935     #[inline]
extended_dynamic_state3_coverage_to_color_enable( mut self, extended_dynamic_state3_coverage_to_color_enable: bool, ) -> Self49936     pub fn extended_dynamic_state3_coverage_to_color_enable(
49937         mut self,
49938         extended_dynamic_state3_coverage_to_color_enable: bool,
49939     ) -> Self {
49940         self.inner.extended_dynamic_state3_coverage_to_color_enable =
49941             extended_dynamic_state3_coverage_to_color_enable.into();
49942         self
49943     }
49944     #[inline]
extended_dynamic_state3_coverage_to_color_location( mut self, extended_dynamic_state3_coverage_to_color_location: bool, ) -> Self49945     pub fn extended_dynamic_state3_coverage_to_color_location(
49946         mut self,
49947         extended_dynamic_state3_coverage_to_color_location: bool,
49948     ) -> Self {
49949         self.inner
49950             .extended_dynamic_state3_coverage_to_color_location =
49951             extended_dynamic_state3_coverage_to_color_location.into();
49952         self
49953     }
49954     #[inline]
extended_dynamic_state3_coverage_modulation_mode( mut self, extended_dynamic_state3_coverage_modulation_mode: bool, ) -> Self49955     pub fn extended_dynamic_state3_coverage_modulation_mode(
49956         mut self,
49957         extended_dynamic_state3_coverage_modulation_mode: bool,
49958     ) -> Self {
49959         self.inner.extended_dynamic_state3_coverage_modulation_mode =
49960             extended_dynamic_state3_coverage_modulation_mode.into();
49961         self
49962     }
49963     #[inline]
extended_dynamic_state3_coverage_modulation_table_enable( mut self, extended_dynamic_state3_coverage_modulation_table_enable: bool, ) -> Self49964     pub fn extended_dynamic_state3_coverage_modulation_table_enable(
49965         mut self,
49966         extended_dynamic_state3_coverage_modulation_table_enable: bool,
49967     ) -> Self {
49968         self.inner
49969             .extended_dynamic_state3_coverage_modulation_table_enable =
49970             extended_dynamic_state3_coverage_modulation_table_enable.into();
49971         self
49972     }
49973     #[inline]
extended_dynamic_state3_coverage_modulation_table( mut self, extended_dynamic_state3_coverage_modulation_table: bool, ) -> Self49974     pub fn extended_dynamic_state3_coverage_modulation_table(
49975         mut self,
49976         extended_dynamic_state3_coverage_modulation_table: bool,
49977     ) -> Self {
49978         self.inner.extended_dynamic_state3_coverage_modulation_table =
49979             extended_dynamic_state3_coverage_modulation_table.into();
49980         self
49981     }
49982     #[inline]
extended_dynamic_state3_coverage_reduction_mode( mut self, extended_dynamic_state3_coverage_reduction_mode: bool, ) -> Self49983     pub fn extended_dynamic_state3_coverage_reduction_mode(
49984         mut self,
49985         extended_dynamic_state3_coverage_reduction_mode: bool,
49986     ) -> Self {
49987         self.inner.extended_dynamic_state3_coverage_reduction_mode =
49988             extended_dynamic_state3_coverage_reduction_mode.into();
49989         self
49990     }
49991     #[inline]
extended_dynamic_state3_representative_fragment_test_enable( mut self, extended_dynamic_state3_representative_fragment_test_enable: bool, ) -> Self49992     pub fn extended_dynamic_state3_representative_fragment_test_enable(
49993         mut self,
49994         extended_dynamic_state3_representative_fragment_test_enable: bool,
49995     ) -> Self {
49996         self.inner
49997             .extended_dynamic_state3_representative_fragment_test_enable =
49998             extended_dynamic_state3_representative_fragment_test_enable.into();
49999         self
50000     }
50001     #[inline]
extended_dynamic_state3_shading_rate_image_enable( mut self, extended_dynamic_state3_shading_rate_image_enable: bool, ) -> Self50002     pub fn extended_dynamic_state3_shading_rate_image_enable(
50003         mut self,
50004         extended_dynamic_state3_shading_rate_image_enable: bool,
50005     ) -> Self {
50006         self.inner.extended_dynamic_state3_shading_rate_image_enable =
50007             extended_dynamic_state3_shading_rate_image_enable.into();
50008         self
50009     }
50010     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50011     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50012     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceExtendedDynamicState3FeaturesEXT50013     pub fn build(self) -> PhysicalDeviceExtendedDynamicState3FeaturesEXT {
50014         self.inner
50015     }
50016 }
50017 #[repr(C)]
50018 #[cfg_attr(feature = "debug", derive(Debug))]
50019 #[derive(Copy, Clone)]
50020 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExtendedDynamicState3PropertiesEXT.html>"]
50021 pub struct PhysicalDeviceExtendedDynamicState3PropertiesEXT {
50022     pub s_type: StructureType,
50023     pub p_next: *mut c_void,
50024     pub dynamic_primitive_topology_unrestricted: Bool32,
50025 }
50026 impl ::std::default::Default for PhysicalDeviceExtendedDynamicState3PropertiesEXT {
50027     #[inline]
default() -> Self50028     fn default() -> Self {
50029         Self {
50030             s_type: Self::STRUCTURE_TYPE,
50031             p_next: ::std::ptr::null_mut(),
50032             dynamic_primitive_topology_unrestricted: Bool32::default(),
50033         }
50034     }
50035 }
50036 unsafe impl TaggedStructure for PhysicalDeviceExtendedDynamicState3PropertiesEXT {
50037     const STRUCTURE_TYPE: StructureType =
50038         StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT;
50039 }
50040 impl PhysicalDeviceExtendedDynamicState3PropertiesEXT {
builder<'a>() -> PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'a>50041     pub fn builder<'a>() -> PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'a> {
50042         PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder {
50043             inner: Self::default(),
50044             marker: ::std::marker::PhantomData,
50045         }
50046     }
50047 }
50048 #[repr(transparent)]
50049 pub struct PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'a> {
50050     inner: PhysicalDeviceExtendedDynamicState3PropertiesEXT,
50051     marker: ::std::marker::PhantomData<&'a ()>,
50052 }
50053 unsafe impl ExtendsPhysicalDeviceProperties2
50054     for PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'_>
50055 {
50056 }
50057 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceExtendedDynamicState3PropertiesEXT {}
50058 impl<'a> ::std::ops::Deref for PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'a> {
50059     type Target = PhysicalDeviceExtendedDynamicState3PropertiesEXT;
deref(&self) -> &Self::Target50060     fn deref(&self) -> &Self::Target {
50061         &self.inner
50062     }
50063 }
50064 impl<'a> ::std::ops::DerefMut for PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target50065     fn deref_mut(&mut self) -> &mut Self::Target {
50066         &mut self.inner
50067     }
50068 }
50069 impl<'a> PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'a> {
50070     #[inline]
dynamic_primitive_topology_unrestricted( mut self, dynamic_primitive_topology_unrestricted: bool, ) -> Self50071     pub fn dynamic_primitive_topology_unrestricted(
50072         mut self,
50073         dynamic_primitive_topology_unrestricted: bool,
50074     ) -> Self {
50075         self.inner.dynamic_primitive_topology_unrestricted =
50076             dynamic_primitive_topology_unrestricted.into();
50077         self
50078     }
50079     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50080     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50081     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceExtendedDynamicState3PropertiesEXT50082     pub fn build(self) -> PhysicalDeviceExtendedDynamicState3PropertiesEXT {
50083         self.inner
50084     }
50085 }
50086 #[repr(C)]
50087 #[cfg_attr(feature = "debug", derive(Debug))]
50088 #[derive(Copy, Clone, Default)]
50089 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkColorBlendEquationEXT.html>"]
50090 pub struct ColorBlendEquationEXT {
50091     pub src_color_blend_factor: BlendFactor,
50092     pub dst_color_blend_factor: BlendFactor,
50093     pub color_blend_op: BlendOp,
50094     pub src_alpha_blend_factor: BlendFactor,
50095     pub dst_alpha_blend_factor: BlendFactor,
50096     pub alpha_blend_op: BlendOp,
50097 }
50098 impl ColorBlendEquationEXT {
builder<'a>() -> ColorBlendEquationEXTBuilder<'a>50099     pub fn builder<'a>() -> ColorBlendEquationEXTBuilder<'a> {
50100         ColorBlendEquationEXTBuilder {
50101             inner: Self::default(),
50102             marker: ::std::marker::PhantomData,
50103         }
50104     }
50105 }
50106 #[repr(transparent)]
50107 pub struct ColorBlendEquationEXTBuilder<'a> {
50108     inner: ColorBlendEquationEXT,
50109     marker: ::std::marker::PhantomData<&'a ()>,
50110 }
50111 impl<'a> ::std::ops::Deref for ColorBlendEquationEXTBuilder<'a> {
50112     type Target = ColorBlendEquationEXT;
deref(&self) -> &Self::Target50113     fn deref(&self) -> &Self::Target {
50114         &self.inner
50115     }
50116 }
50117 impl<'a> ::std::ops::DerefMut for ColorBlendEquationEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target50118     fn deref_mut(&mut self) -> &mut Self::Target {
50119         &mut self.inner
50120     }
50121 }
50122 impl<'a> ColorBlendEquationEXTBuilder<'a> {
50123     #[inline]
src_color_blend_factor(mut self, src_color_blend_factor: BlendFactor) -> Self50124     pub fn src_color_blend_factor(mut self, src_color_blend_factor: BlendFactor) -> Self {
50125         self.inner.src_color_blend_factor = src_color_blend_factor;
50126         self
50127     }
50128     #[inline]
dst_color_blend_factor(mut self, dst_color_blend_factor: BlendFactor) -> Self50129     pub fn dst_color_blend_factor(mut self, dst_color_blend_factor: BlendFactor) -> Self {
50130         self.inner.dst_color_blend_factor = dst_color_blend_factor;
50131         self
50132     }
50133     #[inline]
color_blend_op(mut self, color_blend_op: BlendOp) -> Self50134     pub fn color_blend_op(mut self, color_blend_op: BlendOp) -> Self {
50135         self.inner.color_blend_op = color_blend_op;
50136         self
50137     }
50138     #[inline]
src_alpha_blend_factor(mut self, src_alpha_blend_factor: BlendFactor) -> Self50139     pub fn src_alpha_blend_factor(mut self, src_alpha_blend_factor: BlendFactor) -> Self {
50140         self.inner.src_alpha_blend_factor = src_alpha_blend_factor;
50141         self
50142     }
50143     #[inline]
dst_alpha_blend_factor(mut self, dst_alpha_blend_factor: BlendFactor) -> Self50144     pub fn dst_alpha_blend_factor(mut self, dst_alpha_blend_factor: BlendFactor) -> Self {
50145         self.inner.dst_alpha_blend_factor = dst_alpha_blend_factor;
50146         self
50147     }
50148     #[inline]
alpha_blend_op(mut self, alpha_blend_op: BlendOp) -> Self50149     pub fn alpha_blend_op(mut self, alpha_blend_op: BlendOp) -> Self {
50150         self.inner.alpha_blend_op = alpha_blend_op;
50151         self
50152     }
50153     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50154     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50155     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ColorBlendEquationEXT50156     pub fn build(self) -> ColorBlendEquationEXT {
50157         self.inner
50158     }
50159 }
50160 #[repr(C)]
50161 #[cfg_attr(feature = "debug", derive(Debug))]
50162 #[derive(Copy, Clone, Default)]
50163 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkColorBlendAdvancedEXT.html>"]
50164 pub struct ColorBlendAdvancedEXT {
50165     pub advanced_blend_op: BlendOp,
50166     pub src_premultiplied: Bool32,
50167     pub dst_premultiplied: Bool32,
50168     pub blend_overlap: BlendOverlapEXT,
50169     pub clamp_results: Bool32,
50170 }
50171 impl ColorBlendAdvancedEXT {
builder<'a>() -> ColorBlendAdvancedEXTBuilder<'a>50172     pub fn builder<'a>() -> ColorBlendAdvancedEXTBuilder<'a> {
50173         ColorBlendAdvancedEXTBuilder {
50174             inner: Self::default(),
50175             marker: ::std::marker::PhantomData,
50176         }
50177     }
50178 }
50179 #[repr(transparent)]
50180 pub struct ColorBlendAdvancedEXTBuilder<'a> {
50181     inner: ColorBlendAdvancedEXT,
50182     marker: ::std::marker::PhantomData<&'a ()>,
50183 }
50184 impl<'a> ::std::ops::Deref for ColorBlendAdvancedEXTBuilder<'a> {
50185     type Target = ColorBlendAdvancedEXT;
deref(&self) -> &Self::Target50186     fn deref(&self) -> &Self::Target {
50187         &self.inner
50188     }
50189 }
50190 impl<'a> ::std::ops::DerefMut for ColorBlendAdvancedEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target50191     fn deref_mut(&mut self) -> &mut Self::Target {
50192         &mut self.inner
50193     }
50194 }
50195 impl<'a> ColorBlendAdvancedEXTBuilder<'a> {
50196     #[inline]
advanced_blend_op(mut self, advanced_blend_op: BlendOp) -> Self50197     pub fn advanced_blend_op(mut self, advanced_blend_op: BlendOp) -> Self {
50198         self.inner.advanced_blend_op = advanced_blend_op;
50199         self
50200     }
50201     #[inline]
src_premultiplied(mut self, src_premultiplied: bool) -> Self50202     pub fn src_premultiplied(mut self, src_premultiplied: bool) -> Self {
50203         self.inner.src_premultiplied = src_premultiplied.into();
50204         self
50205     }
50206     #[inline]
dst_premultiplied(mut self, dst_premultiplied: bool) -> Self50207     pub fn dst_premultiplied(mut self, dst_premultiplied: bool) -> Self {
50208         self.inner.dst_premultiplied = dst_premultiplied.into();
50209         self
50210     }
50211     #[inline]
blend_overlap(mut self, blend_overlap: BlendOverlapEXT) -> Self50212     pub fn blend_overlap(mut self, blend_overlap: BlendOverlapEXT) -> Self {
50213         self.inner.blend_overlap = blend_overlap;
50214         self
50215     }
50216     #[inline]
clamp_results(mut self, clamp_results: bool) -> Self50217     pub fn clamp_results(mut self, clamp_results: bool) -> Self {
50218         self.inner.clamp_results = clamp_results.into();
50219         self
50220     }
50221     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50222     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50223     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ColorBlendAdvancedEXT50224     pub fn build(self) -> ColorBlendAdvancedEXT {
50225         self.inner
50226     }
50227 }
50228 #[repr(C)]
50229 #[cfg_attr(feature = "debug", derive(Debug))]
50230 #[derive(Copy, Clone)]
50231 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassTransformBeginInfoQCOM.html>"]
50232 pub struct RenderPassTransformBeginInfoQCOM {
50233     pub s_type: StructureType,
50234     pub p_next: *mut c_void,
50235     pub transform: SurfaceTransformFlagsKHR,
50236 }
50237 impl ::std::default::Default for RenderPassTransformBeginInfoQCOM {
50238     #[inline]
default() -> Self50239     fn default() -> Self {
50240         Self {
50241             s_type: Self::STRUCTURE_TYPE,
50242             p_next: ::std::ptr::null_mut(),
50243             transform: SurfaceTransformFlagsKHR::default(),
50244         }
50245     }
50246 }
50247 unsafe impl TaggedStructure for RenderPassTransformBeginInfoQCOM {
50248     const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM;
50249 }
50250 impl RenderPassTransformBeginInfoQCOM {
builder<'a>() -> RenderPassTransformBeginInfoQCOMBuilder<'a>50251     pub fn builder<'a>() -> RenderPassTransformBeginInfoQCOMBuilder<'a> {
50252         RenderPassTransformBeginInfoQCOMBuilder {
50253             inner: Self::default(),
50254             marker: ::std::marker::PhantomData,
50255         }
50256     }
50257 }
50258 #[repr(transparent)]
50259 pub struct RenderPassTransformBeginInfoQCOMBuilder<'a> {
50260     inner: RenderPassTransformBeginInfoQCOM,
50261     marker: ::std::marker::PhantomData<&'a ()>,
50262 }
50263 unsafe impl ExtendsRenderPassBeginInfo for RenderPassTransformBeginInfoQCOMBuilder<'_> {}
50264 unsafe impl ExtendsRenderPassBeginInfo for RenderPassTransformBeginInfoQCOM {}
50265 impl<'a> ::std::ops::Deref for RenderPassTransformBeginInfoQCOMBuilder<'a> {
50266     type Target = RenderPassTransformBeginInfoQCOM;
deref(&self) -> &Self::Target50267     fn deref(&self) -> &Self::Target {
50268         &self.inner
50269     }
50270 }
50271 impl<'a> ::std::ops::DerefMut for RenderPassTransformBeginInfoQCOMBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target50272     fn deref_mut(&mut self) -> &mut Self::Target {
50273         &mut self.inner
50274     }
50275 }
50276 impl<'a> RenderPassTransformBeginInfoQCOMBuilder<'a> {
50277     #[inline]
transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self50278     pub fn transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self {
50279         self.inner.transform = transform;
50280         self
50281     }
50282     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50283     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50284     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RenderPassTransformBeginInfoQCOM50285     pub fn build(self) -> RenderPassTransformBeginInfoQCOM {
50286         self.inner
50287     }
50288 }
50289 #[repr(C)]
50290 #[cfg_attr(feature = "debug", derive(Debug))]
50291 #[derive(Copy, Clone)]
50292 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyCommandTransformInfoQCOM.html>"]
50293 pub struct CopyCommandTransformInfoQCOM {
50294     pub s_type: StructureType,
50295     pub p_next: *const c_void,
50296     pub transform: SurfaceTransformFlagsKHR,
50297 }
50298 impl ::std::default::Default for CopyCommandTransformInfoQCOM {
50299     #[inline]
default() -> Self50300     fn default() -> Self {
50301         Self {
50302             s_type: Self::STRUCTURE_TYPE,
50303             p_next: ::std::ptr::null(),
50304             transform: SurfaceTransformFlagsKHR::default(),
50305         }
50306     }
50307 }
50308 unsafe impl TaggedStructure for CopyCommandTransformInfoQCOM {
50309     const STRUCTURE_TYPE: StructureType = StructureType::COPY_COMMAND_TRANSFORM_INFO_QCOM;
50310 }
50311 impl CopyCommandTransformInfoQCOM {
builder<'a>() -> CopyCommandTransformInfoQCOMBuilder<'a>50312     pub fn builder<'a>() -> CopyCommandTransformInfoQCOMBuilder<'a> {
50313         CopyCommandTransformInfoQCOMBuilder {
50314             inner: Self::default(),
50315             marker: ::std::marker::PhantomData,
50316         }
50317     }
50318 }
50319 #[repr(transparent)]
50320 pub struct CopyCommandTransformInfoQCOMBuilder<'a> {
50321     inner: CopyCommandTransformInfoQCOM,
50322     marker: ::std::marker::PhantomData<&'a ()>,
50323 }
50324 unsafe impl ExtendsBufferImageCopy2 for CopyCommandTransformInfoQCOMBuilder<'_> {}
50325 unsafe impl ExtendsBufferImageCopy2 for CopyCommandTransformInfoQCOM {}
50326 unsafe impl ExtendsImageBlit2 for CopyCommandTransformInfoQCOMBuilder<'_> {}
50327 unsafe impl ExtendsImageBlit2 for CopyCommandTransformInfoQCOM {}
50328 impl<'a> ::std::ops::Deref for CopyCommandTransformInfoQCOMBuilder<'a> {
50329     type Target = CopyCommandTransformInfoQCOM;
deref(&self) -> &Self::Target50330     fn deref(&self) -> &Self::Target {
50331         &self.inner
50332     }
50333 }
50334 impl<'a> ::std::ops::DerefMut for CopyCommandTransformInfoQCOMBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target50335     fn deref_mut(&mut self) -> &mut Self::Target {
50336         &mut self.inner
50337     }
50338 }
50339 impl<'a> CopyCommandTransformInfoQCOMBuilder<'a> {
50340     #[inline]
transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self50341     pub fn transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self {
50342         self.inner.transform = transform;
50343         self
50344     }
50345     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50346     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50347     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CopyCommandTransformInfoQCOM50348     pub fn build(self) -> CopyCommandTransformInfoQCOM {
50349         self.inner
50350     }
50351 }
50352 #[repr(C)]
50353 #[cfg_attr(feature = "debug", derive(Debug))]
50354 #[derive(Copy, Clone)]
50355 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferInheritanceRenderPassTransformInfoQCOM.html>"]
50356 pub struct CommandBufferInheritanceRenderPassTransformInfoQCOM {
50357     pub s_type: StructureType,
50358     pub p_next: *mut c_void,
50359     pub transform: SurfaceTransformFlagsKHR,
50360     pub render_area: Rect2D,
50361 }
50362 impl ::std::default::Default for CommandBufferInheritanceRenderPassTransformInfoQCOM {
50363     #[inline]
default() -> Self50364     fn default() -> Self {
50365         Self {
50366             s_type: Self::STRUCTURE_TYPE,
50367             p_next: ::std::ptr::null_mut(),
50368             transform: SurfaceTransformFlagsKHR::default(),
50369             render_area: Rect2D::default(),
50370         }
50371     }
50372 }
50373 unsafe impl TaggedStructure for CommandBufferInheritanceRenderPassTransformInfoQCOM {
50374     const STRUCTURE_TYPE: StructureType =
50375         StructureType::COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM;
50376 }
50377 impl CommandBufferInheritanceRenderPassTransformInfoQCOM {
builder<'a>() -> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a>50378     pub fn builder<'a>() -> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
50379         CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder {
50380             inner: Self::default(),
50381             marker: ::std::marker::PhantomData,
50382         }
50383     }
50384 }
50385 #[repr(transparent)]
50386 pub struct CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
50387     inner: CommandBufferInheritanceRenderPassTransformInfoQCOM,
50388     marker: ::std::marker::PhantomData<&'a ()>,
50389 }
50390 unsafe impl ExtendsCommandBufferInheritanceInfo
50391     for CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'_>
50392 {
50393 }
50394 unsafe impl ExtendsCommandBufferInheritanceInfo
50395     for CommandBufferInheritanceRenderPassTransformInfoQCOM
50396 {
50397 }
50398 impl<'a> ::std::ops::Deref for CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
50399     type Target = CommandBufferInheritanceRenderPassTransformInfoQCOM;
deref(&self) -> &Self::Target50400     fn deref(&self) -> &Self::Target {
50401         &self.inner
50402     }
50403 }
50404 impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target50405     fn deref_mut(&mut self) -> &mut Self::Target {
50406         &mut self.inner
50407     }
50408 }
50409 impl<'a> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
50410     #[inline]
transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self50411     pub fn transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self {
50412         self.inner.transform = transform;
50413         self
50414     }
50415     #[inline]
render_area(mut self, render_area: Rect2D) -> Self50416     pub fn render_area(mut self, render_area: Rect2D) -> Self {
50417         self.inner.render_area = render_area;
50418         self
50419     }
50420     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50421     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50422     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CommandBufferInheritanceRenderPassTransformInfoQCOM50423     pub fn build(self) -> CommandBufferInheritanceRenderPassTransformInfoQCOM {
50424         self.inner
50425     }
50426 }
50427 #[repr(C)]
50428 #[cfg_attr(feature = "debug", derive(Debug))]
50429 #[derive(Copy, Clone)]
50430 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDiagnosticsConfigFeaturesNV.html>"]
50431 pub struct PhysicalDeviceDiagnosticsConfigFeaturesNV {
50432     pub s_type: StructureType,
50433     pub p_next: *mut c_void,
50434     pub diagnostics_config: Bool32,
50435 }
50436 impl ::std::default::Default for PhysicalDeviceDiagnosticsConfigFeaturesNV {
50437     #[inline]
default() -> Self50438     fn default() -> Self {
50439         Self {
50440             s_type: Self::STRUCTURE_TYPE,
50441             p_next: ::std::ptr::null_mut(),
50442             diagnostics_config: Bool32::default(),
50443         }
50444     }
50445 }
50446 unsafe impl TaggedStructure for PhysicalDeviceDiagnosticsConfigFeaturesNV {
50447     const STRUCTURE_TYPE: StructureType =
50448         StructureType::PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
50449 }
50450 impl PhysicalDeviceDiagnosticsConfigFeaturesNV {
builder<'a>() -> PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a>50451     pub fn builder<'a>() -> PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
50452         PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder {
50453             inner: Self::default(),
50454             marker: ::std::marker::PhantomData,
50455         }
50456     }
50457 }
50458 #[repr(transparent)]
50459 pub struct PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
50460     inner: PhysicalDeviceDiagnosticsConfigFeaturesNV,
50461     marker: ::std::marker::PhantomData<&'a ()>,
50462 }
50463 unsafe impl ExtendsPhysicalDeviceFeatures2
50464     for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'_>
50465 {
50466 }
50467 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDiagnosticsConfigFeaturesNV {}
50468 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'_> {}
50469 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDiagnosticsConfigFeaturesNV {}
50470 impl<'a> ::std::ops::Deref for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
50471     type Target = PhysicalDeviceDiagnosticsConfigFeaturesNV;
deref(&self) -> &Self::Target50472     fn deref(&self) -> &Self::Target {
50473         &self.inner
50474     }
50475 }
50476 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target50477     fn deref_mut(&mut self) -> &mut Self::Target {
50478         &mut self.inner
50479     }
50480 }
50481 impl<'a> PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
50482     #[inline]
diagnostics_config(mut self, diagnostics_config: bool) -> Self50483     pub fn diagnostics_config(mut self, diagnostics_config: bool) -> Self {
50484         self.inner.diagnostics_config = diagnostics_config.into();
50485         self
50486     }
50487     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50488     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50489     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDiagnosticsConfigFeaturesNV50490     pub fn build(self) -> PhysicalDeviceDiagnosticsConfigFeaturesNV {
50491         self.inner
50492     }
50493 }
50494 #[repr(C)]
50495 #[cfg_attr(feature = "debug", derive(Debug))]
50496 #[derive(Copy, Clone)]
50497 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceDiagnosticsConfigCreateInfoNV.html>"]
50498 pub struct DeviceDiagnosticsConfigCreateInfoNV {
50499     pub s_type: StructureType,
50500     pub p_next: *const c_void,
50501     pub flags: DeviceDiagnosticsConfigFlagsNV,
50502 }
50503 impl ::std::default::Default for DeviceDiagnosticsConfigCreateInfoNV {
50504     #[inline]
default() -> Self50505     fn default() -> Self {
50506         Self {
50507             s_type: Self::STRUCTURE_TYPE,
50508             p_next: ::std::ptr::null(),
50509             flags: DeviceDiagnosticsConfigFlagsNV::default(),
50510         }
50511     }
50512 }
50513 unsafe impl TaggedStructure for DeviceDiagnosticsConfigCreateInfoNV {
50514     const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV;
50515 }
50516 impl DeviceDiagnosticsConfigCreateInfoNV {
builder<'a>() -> DeviceDiagnosticsConfigCreateInfoNVBuilder<'a>50517     pub fn builder<'a>() -> DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
50518         DeviceDiagnosticsConfigCreateInfoNVBuilder {
50519             inner: Self::default(),
50520             marker: ::std::marker::PhantomData,
50521         }
50522     }
50523 }
50524 #[repr(transparent)]
50525 pub struct DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
50526     inner: DeviceDiagnosticsConfigCreateInfoNV,
50527     marker: ::std::marker::PhantomData<&'a ()>,
50528 }
50529 unsafe impl ExtendsDeviceCreateInfo for DeviceDiagnosticsConfigCreateInfoNVBuilder<'_> {}
50530 unsafe impl ExtendsDeviceCreateInfo for DeviceDiagnosticsConfigCreateInfoNV {}
50531 impl<'a> ::std::ops::Deref for DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
50532     type Target = DeviceDiagnosticsConfigCreateInfoNV;
deref(&self) -> &Self::Target50533     fn deref(&self) -> &Self::Target {
50534         &self.inner
50535     }
50536 }
50537 impl<'a> ::std::ops::DerefMut for DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target50538     fn deref_mut(&mut self) -> &mut Self::Target {
50539         &mut self.inner
50540     }
50541 }
50542 impl<'a> DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
50543     #[inline]
flags(mut self, flags: DeviceDiagnosticsConfigFlagsNV) -> Self50544     pub fn flags(mut self, flags: DeviceDiagnosticsConfigFlagsNV) -> Self {
50545         self.inner.flags = flags;
50546         self
50547     }
50548     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50549     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50550     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceDiagnosticsConfigCreateInfoNV50551     pub fn build(self) -> DeviceDiagnosticsConfigCreateInfoNV {
50552         self.inner
50553     }
50554 }
50555 #[repr(C)]
50556 #[cfg_attr(feature = "debug", derive(Debug))]
50557 #[derive(Copy, Clone)]
50558 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures.html>"]
50559 pub struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
50560     pub s_type: StructureType,
50561     pub p_next: *mut c_void,
50562     pub shader_zero_initialize_workgroup_memory: Bool32,
50563 }
50564 impl ::std::default::Default for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
50565     #[inline]
default() -> Self50566     fn default() -> Self {
50567         Self {
50568             s_type: Self::STRUCTURE_TYPE,
50569             p_next: ::std::ptr::null_mut(),
50570             shader_zero_initialize_workgroup_memory: Bool32::default(),
50571         }
50572     }
50573 }
50574 unsafe impl TaggedStructure for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
50575     const STRUCTURE_TYPE: StructureType =
50576         StructureType::PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
50577 }
50578 impl PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
builder<'a>() -> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a>50579     pub fn builder<'a>() -> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> {
50580         PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder {
50581             inner: Self::default(),
50582             marker: ::std::marker::PhantomData,
50583         }
50584     }
50585 }
50586 #[repr(transparent)]
50587 pub struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> {
50588     inner: PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures,
50589     marker: ::std::marker::PhantomData<&'a ()>,
50590 }
50591 unsafe impl ExtendsPhysicalDeviceFeatures2
50592     for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'_>
50593 {
50594 }
50595 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {}
50596 unsafe impl ExtendsDeviceCreateInfo
50597     for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'_>
50598 {
50599 }
50600 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {}
50601 impl<'a> ::std::ops::Deref for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> {
50602     type Target = PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;
deref(&self) -> &Self::Target50603     fn deref(&self) -> &Self::Target {
50604         &self.inner
50605     }
50606 }
50607 impl<'a> ::std::ops::DerefMut for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target50608     fn deref_mut(&mut self) -> &mut Self::Target {
50609         &mut self.inner
50610     }
50611 }
50612 impl<'a> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> {
50613     #[inline]
shader_zero_initialize_workgroup_memory( mut self, shader_zero_initialize_workgroup_memory: bool, ) -> Self50614     pub fn shader_zero_initialize_workgroup_memory(
50615         mut self,
50616         shader_zero_initialize_workgroup_memory: bool,
50617     ) -> Self {
50618         self.inner.shader_zero_initialize_workgroup_memory =
50619             shader_zero_initialize_workgroup_memory.into();
50620         self
50621     }
50622     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50623     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50624     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures50625     pub fn build(self) -> PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
50626         self.inner
50627     }
50628 }
50629 #[repr(C)]
50630 #[cfg_attr(feature = "debug", derive(Debug))]
50631 #[derive(Copy, Clone)]
50632 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.html>"]
50633 pub struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
50634     pub s_type: StructureType,
50635     pub p_next: *mut c_void,
50636     pub shader_subgroup_uniform_control_flow: Bool32,
50637 }
50638 impl ::std::default::Default for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
50639     #[inline]
default() -> Self50640     fn default() -> Self {
50641         Self {
50642             s_type: Self::STRUCTURE_TYPE,
50643             p_next: ::std::ptr::null_mut(),
50644             shader_subgroup_uniform_control_flow: Bool32::default(),
50645         }
50646     }
50647 }
50648 unsafe impl TaggedStructure for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
50649     const STRUCTURE_TYPE: StructureType =
50650         StructureType::PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
50651 }
50652 impl PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
builder<'a>() -> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a>50653     pub fn builder<'a>() -> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> {
50654         PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder {
50655             inner: Self::default(),
50656             marker: ::std::marker::PhantomData,
50657         }
50658     }
50659 }
50660 #[repr(transparent)]
50661 pub struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> {
50662     inner: PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR,
50663     marker: ::std::marker::PhantomData<&'a ()>,
50664 }
50665 unsafe impl ExtendsPhysicalDeviceFeatures2
50666     for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'_>
50667 {
50668 }
50669 unsafe impl ExtendsPhysicalDeviceFeatures2
50670     for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR
50671 {
50672 }
50673 unsafe impl ExtendsDeviceCreateInfo
50674     for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'_>
50675 {
50676 }
50677 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {}
50678 impl<'a> ::std::ops::Deref
50679     for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a>
50680 {
50681     type Target = PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
deref(&self) -> &Self::Target50682     fn deref(&self) -> &Self::Target {
50683         &self.inner
50684     }
50685 }
50686 impl<'a> ::std::ops::DerefMut
50687     for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a>
50688 {
deref_mut(&mut self) -> &mut Self::Target50689     fn deref_mut(&mut self) -> &mut Self::Target {
50690         &mut self.inner
50691     }
50692 }
50693 impl<'a> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> {
50694     #[inline]
shader_subgroup_uniform_control_flow( mut self, shader_subgroup_uniform_control_flow: bool, ) -> Self50695     pub fn shader_subgroup_uniform_control_flow(
50696         mut self,
50697         shader_subgroup_uniform_control_flow: bool,
50698     ) -> Self {
50699         self.inner.shader_subgroup_uniform_control_flow =
50700             shader_subgroup_uniform_control_flow.into();
50701         self
50702     }
50703     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50704     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50705     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR50706     pub fn build(self) -> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
50707         self.inner
50708     }
50709 }
50710 #[repr(C)]
50711 #[cfg_attr(feature = "debug", derive(Debug))]
50712 #[derive(Copy, Clone)]
50713 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRobustness2FeaturesEXT.html>"]
50714 pub struct PhysicalDeviceRobustness2FeaturesEXT {
50715     pub s_type: StructureType,
50716     pub p_next: *mut c_void,
50717     pub robust_buffer_access2: Bool32,
50718     pub robust_image_access2: Bool32,
50719     pub null_descriptor: Bool32,
50720 }
50721 impl ::std::default::Default for PhysicalDeviceRobustness2FeaturesEXT {
50722     #[inline]
default() -> Self50723     fn default() -> Self {
50724         Self {
50725             s_type: Self::STRUCTURE_TYPE,
50726             p_next: ::std::ptr::null_mut(),
50727             robust_buffer_access2: Bool32::default(),
50728             robust_image_access2: Bool32::default(),
50729             null_descriptor: Bool32::default(),
50730         }
50731     }
50732 }
50733 unsafe impl TaggedStructure for PhysicalDeviceRobustness2FeaturesEXT {
50734     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT;
50735 }
50736 impl PhysicalDeviceRobustness2FeaturesEXT {
builder<'a>() -> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a>50737     pub fn builder<'a>() -> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> {
50738         PhysicalDeviceRobustness2FeaturesEXTBuilder {
50739             inner: Self::default(),
50740             marker: ::std::marker::PhantomData,
50741         }
50742     }
50743 }
50744 #[repr(transparent)]
50745 pub struct PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> {
50746     inner: PhysicalDeviceRobustness2FeaturesEXT,
50747     marker: ::std::marker::PhantomData<&'a ()>,
50748 }
50749 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRobustness2FeaturesEXTBuilder<'_> {}
50750 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRobustness2FeaturesEXT {}
50751 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRobustness2FeaturesEXTBuilder<'_> {}
50752 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRobustness2FeaturesEXT {}
50753 impl<'a> ::std::ops::Deref for PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> {
50754     type Target = PhysicalDeviceRobustness2FeaturesEXT;
deref(&self) -> &Self::Target50755     fn deref(&self) -> &Self::Target {
50756         &self.inner
50757     }
50758 }
50759 impl<'a> ::std::ops::DerefMut for PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target50760     fn deref_mut(&mut self) -> &mut Self::Target {
50761         &mut self.inner
50762     }
50763 }
50764 impl<'a> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> {
50765     #[inline]
robust_buffer_access2(mut self, robust_buffer_access2: bool) -> Self50766     pub fn robust_buffer_access2(mut self, robust_buffer_access2: bool) -> Self {
50767         self.inner.robust_buffer_access2 = robust_buffer_access2.into();
50768         self
50769     }
50770     #[inline]
robust_image_access2(mut self, robust_image_access2: bool) -> Self50771     pub fn robust_image_access2(mut self, robust_image_access2: bool) -> Self {
50772         self.inner.robust_image_access2 = robust_image_access2.into();
50773         self
50774     }
50775     #[inline]
null_descriptor(mut self, null_descriptor: bool) -> Self50776     pub fn null_descriptor(mut self, null_descriptor: bool) -> Self {
50777         self.inner.null_descriptor = null_descriptor.into();
50778         self
50779     }
50780     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50781     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50782     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceRobustness2FeaturesEXT50783     pub fn build(self) -> PhysicalDeviceRobustness2FeaturesEXT {
50784         self.inner
50785     }
50786 }
50787 #[repr(C)]
50788 #[cfg_attr(feature = "debug", derive(Debug))]
50789 #[derive(Copy, Clone)]
50790 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRobustness2PropertiesEXT.html>"]
50791 pub struct PhysicalDeviceRobustness2PropertiesEXT {
50792     pub s_type: StructureType,
50793     pub p_next: *mut c_void,
50794     pub robust_storage_buffer_access_size_alignment: DeviceSize,
50795     pub robust_uniform_buffer_access_size_alignment: DeviceSize,
50796 }
50797 impl ::std::default::Default for PhysicalDeviceRobustness2PropertiesEXT {
50798     #[inline]
default() -> Self50799     fn default() -> Self {
50800         Self {
50801             s_type: Self::STRUCTURE_TYPE,
50802             p_next: ::std::ptr::null_mut(),
50803             robust_storage_buffer_access_size_alignment: DeviceSize::default(),
50804             robust_uniform_buffer_access_size_alignment: DeviceSize::default(),
50805         }
50806     }
50807 }
50808 unsafe impl TaggedStructure for PhysicalDeviceRobustness2PropertiesEXT {
50809     const STRUCTURE_TYPE: StructureType =
50810         StructureType::PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT;
50811 }
50812 impl PhysicalDeviceRobustness2PropertiesEXT {
builder<'a>() -> PhysicalDeviceRobustness2PropertiesEXTBuilder<'a>50813     pub fn builder<'a>() -> PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> {
50814         PhysicalDeviceRobustness2PropertiesEXTBuilder {
50815             inner: Self::default(),
50816             marker: ::std::marker::PhantomData,
50817         }
50818     }
50819 }
50820 #[repr(transparent)]
50821 pub struct PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> {
50822     inner: PhysicalDeviceRobustness2PropertiesEXT,
50823     marker: ::std::marker::PhantomData<&'a ()>,
50824 }
50825 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRobustness2PropertiesEXTBuilder<'_> {}
50826 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRobustness2PropertiesEXT {}
50827 impl<'a> ::std::ops::Deref for PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> {
50828     type Target = PhysicalDeviceRobustness2PropertiesEXT;
deref(&self) -> &Self::Target50829     fn deref(&self) -> &Self::Target {
50830         &self.inner
50831     }
50832 }
50833 impl<'a> ::std::ops::DerefMut for PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target50834     fn deref_mut(&mut self) -> &mut Self::Target {
50835         &mut self.inner
50836     }
50837 }
50838 impl<'a> PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> {
50839     #[inline]
robust_storage_buffer_access_size_alignment( mut self, robust_storage_buffer_access_size_alignment: DeviceSize, ) -> Self50840     pub fn robust_storage_buffer_access_size_alignment(
50841         mut self,
50842         robust_storage_buffer_access_size_alignment: DeviceSize,
50843     ) -> Self {
50844         self.inner.robust_storage_buffer_access_size_alignment =
50845             robust_storage_buffer_access_size_alignment;
50846         self
50847     }
50848     #[inline]
robust_uniform_buffer_access_size_alignment( mut self, robust_uniform_buffer_access_size_alignment: DeviceSize, ) -> Self50849     pub fn robust_uniform_buffer_access_size_alignment(
50850         mut self,
50851         robust_uniform_buffer_access_size_alignment: DeviceSize,
50852     ) -> Self {
50853         self.inner.robust_uniform_buffer_access_size_alignment =
50854             robust_uniform_buffer_access_size_alignment;
50855         self
50856     }
50857     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50858     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50859     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceRobustness2PropertiesEXT50860     pub fn build(self) -> PhysicalDeviceRobustness2PropertiesEXT {
50861         self.inner
50862     }
50863 }
50864 #[repr(C)]
50865 #[cfg_attr(feature = "debug", derive(Debug))]
50866 #[derive(Copy, Clone)]
50867 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageRobustnessFeatures.html>"]
50868 pub struct PhysicalDeviceImageRobustnessFeatures {
50869     pub s_type: StructureType,
50870     pub p_next: *mut c_void,
50871     pub robust_image_access: Bool32,
50872 }
50873 impl ::std::default::Default for PhysicalDeviceImageRobustnessFeatures {
50874     #[inline]
default() -> Self50875     fn default() -> Self {
50876         Self {
50877             s_type: Self::STRUCTURE_TYPE,
50878             p_next: ::std::ptr::null_mut(),
50879             robust_image_access: Bool32::default(),
50880         }
50881     }
50882 }
50883 unsafe impl TaggedStructure for PhysicalDeviceImageRobustnessFeatures {
50884     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
50885 }
50886 impl PhysicalDeviceImageRobustnessFeatures {
builder<'a>() -> PhysicalDeviceImageRobustnessFeaturesBuilder<'a>50887     pub fn builder<'a>() -> PhysicalDeviceImageRobustnessFeaturesBuilder<'a> {
50888         PhysicalDeviceImageRobustnessFeaturesBuilder {
50889             inner: Self::default(),
50890             marker: ::std::marker::PhantomData,
50891         }
50892     }
50893 }
50894 #[repr(transparent)]
50895 pub struct PhysicalDeviceImageRobustnessFeaturesBuilder<'a> {
50896     inner: PhysicalDeviceImageRobustnessFeatures,
50897     marker: ::std::marker::PhantomData<&'a ()>,
50898 }
50899 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageRobustnessFeaturesBuilder<'_> {}
50900 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageRobustnessFeatures {}
50901 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageRobustnessFeaturesBuilder<'_> {}
50902 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageRobustnessFeatures {}
50903 impl<'a> ::std::ops::Deref for PhysicalDeviceImageRobustnessFeaturesBuilder<'a> {
50904     type Target = PhysicalDeviceImageRobustnessFeatures;
deref(&self) -> &Self::Target50905     fn deref(&self) -> &Self::Target {
50906         &self.inner
50907     }
50908 }
50909 impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageRobustnessFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target50910     fn deref_mut(&mut self) -> &mut Self::Target {
50911         &mut self.inner
50912     }
50913 }
50914 impl<'a> PhysicalDeviceImageRobustnessFeaturesBuilder<'a> {
50915     #[inline]
robust_image_access(mut self, robust_image_access: bool) -> Self50916     pub fn robust_image_access(mut self, robust_image_access: bool) -> Self {
50917         self.inner.robust_image_access = robust_image_access.into();
50918         self
50919     }
50920     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50921     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50922     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceImageRobustnessFeatures50923     pub fn build(self) -> PhysicalDeviceImageRobustnessFeatures {
50924         self.inner
50925     }
50926 }
50927 #[repr(C)]
50928 #[cfg_attr(feature = "debug", derive(Debug))]
50929 #[derive(Copy, Clone)]
50930 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.html>"]
50931 pub struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
50932     pub s_type: StructureType,
50933     pub p_next: *mut c_void,
50934     pub workgroup_memory_explicit_layout: Bool32,
50935     pub workgroup_memory_explicit_layout_scalar_block_layout: Bool32,
50936     pub workgroup_memory_explicit_layout8_bit_access: Bool32,
50937     pub workgroup_memory_explicit_layout16_bit_access: Bool32,
50938 }
50939 impl ::std::default::Default for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
50940     #[inline]
default() -> Self50941     fn default() -> Self {
50942         Self {
50943             s_type: Self::STRUCTURE_TYPE,
50944             p_next: ::std::ptr::null_mut(),
50945             workgroup_memory_explicit_layout: Bool32::default(),
50946             workgroup_memory_explicit_layout_scalar_block_layout: Bool32::default(),
50947             workgroup_memory_explicit_layout8_bit_access: Bool32::default(),
50948             workgroup_memory_explicit_layout16_bit_access: Bool32::default(),
50949         }
50950     }
50951 }
50952 unsafe impl TaggedStructure for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
50953     const STRUCTURE_TYPE: StructureType =
50954         StructureType::PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
50955 }
50956 impl PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
builder<'a>() -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a>50957     pub fn builder<'a>() -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
50958         PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder {
50959             inner: Self::default(),
50960             marker: ::std::marker::PhantomData,
50961         }
50962     }
50963 }
50964 #[repr(transparent)]
50965 pub struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
50966     inner: PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR,
50967     marker: ::std::marker::PhantomData<&'a ()>,
50968 }
50969 unsafe impl ExtendsPhysicalDeviceFeatures2
50970     for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'_>
50971 {
50972 }
50973 unsafe impl ExtendsPhysicalDeviceFeatures2
50974     for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR
50975 {
50976 }
50977 unsafe impl ExtendsDeviceCreateInfo
50978     for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'_>
50979 {
50980 }
50981 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {}
50982 impl<'a> ::std::ops::Deref for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
50983     type Target = PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
deref(&self) -> &Self::Target50984     fn deref(&self) -> &Self::Target {
50985         &self.inner
50986     }
50987 }
50988 impl<'a> ::std::ops::DerefMut
50989     for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a>
50990 {
deref_mut(&mut self) -> &mut Self::Target50991     fn deref_mut(&mut self) -> &mut Self::Target {
50992         &mut self.inner
50993     }
50994 }
50995 impl<'a> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
50996     #[inline]
workgroup_memory_explicit_layout( mut self, workgroup_memory_explicit_layout: bool, ) -> Self50997     pub fn workgroup_memory_explicit_layout(
50998         mut self,
50999         workgroup_memory_explicit_layout: bool,
51000     ) -> Self {
51001         self.inner.workgroup_memory_explicit_layout = workgroup_memory_explicit_layout.into();
51002         self
51003     }
51004     #[inline]
workgroup_memory_explicit_layout_scalar_block_layout( mut self, workgroup_memory_explicit_layout_scalar_block_layout: bool, ) -> Self51005     pub fn workgroup_memory_explicit_layout_scalar_block_layout(
51006         mut self,
51007         workgroup_memory_explicit_layout_scalar_block_layout: bool,
51008     ) -> Self {
51009         self.inner
51010             .workgroup_memory_explicit_layout_scalar_block_layout =
51011             workgroup_memory_explicit_layout_scalar_block_layout.into();
51012         self
51013     }
51014     #[inline]
workgroup_memory_explicit_layout8_bit_access( mut self, workgroup_memory_explicit_layout8_bit_access: bool, ) -> Self51015     pub fn workgroup_memory_explicit_layout8_bit_access(
51016         mut self,
51017         workgroup_memory_explicit_layout8_bit_access: bool,
51018     ) -> Self {
51019         self.inner.workgroup_memory_explicit_layout8_bit_access =
51020             workgroup_memory_explicit_layout8_bit_access.into();
51021         self
51022     }
51023     #[inline]
workgroup_memory_explicit_layout16_bit_access( mut self, workgroup_memory_explicit_layout16_bit_access: bool, ) -> Self51024     pub fn workgroup_memory_explicit_layout16_bit_access(
51025         mut self,
51026         workgroup_memory_explicit_layout16_bit_access: bool,
51027     ) -> Self {
51028         self.inner.workgroup_memory_explicit_layout16_bit_access =
51029             workgroup_memory_explicit_layout16_bit_access.into();
51030         self
51031     }
51032     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51033     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51034     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR51035     pub fn build(self) -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
51036         self.inner
51037     }
51038 }
51039 #[repr(C)]
51040 #[cfg_attr(feature = "debug", derive(Debug))]
51041 #[derive(Copy, Clone)]
51042 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePortabilitySubsetFeaturesKHR.html>"]
51043 pub struct PhysicalDevicePortabilitySubsetFeaturesKHR {
51044     pub s_type: StructureType,
51045     pub p_next: *mut c_void,
51046     pub constant_alpha_color_blend_factors: Bool32,
51047     pub events: Bool32,
51048     pub image_view_format_reinterpretation: Bool32,
51049     pub image_view_format_swizzle: Bool32,
51050     pub image_view2_d_on3_d_image: Bool32,
51051     pub multisample_array_image: Bool32,
51052     pub mutable_comparison_samplers: Bool32,
51053     pub point_polygons: Bool32,
51054     pub sampler_mip_lod_bias: Bool32,
51055     pub separate_stencil_mask_ref: Bool32,
51056     pub shader_sample_rate_interpolation_functions: Bool32,
51057     pub tessellation_isolines: Bool32,
51058     pub tessellation_point_mode: Bool32,
51059     pub triangle_fans: Bool32,
51060     pub vertex_attribute_access_beyond_stride: Bool32,
51061 }
51062 impl ::std::default::Default for PhysicalDevicePortabilitySubsetFeaturesKHR {
51063     #[inline]
default() -> Self51064     fn default() -> Self {
51065         Self {
51066             s_type: Self::STRUCTURE_TYPE,
51067             p_next: ::std::ptr::null_mut(),
51068             constant_alpha_color_blend_factors: Bool32::default(),
51069             events: Bool32::default(),
51070             image_view_format_reinterpretation: Bool32::default(),
51071             image_view_format_swizzle: Bool32::default(),
51072             image_view2_d_on3_d_image: Bool32::default(),
51073             multisample_array_image: Bool32::default(),
51074             mutable_comparison_samplers: Bool32::default(),
51075             point_polygons: Bool32::default(),
51076             sampler_mip_lod_bias: Bool32::default(),
51077             separate_stencil_mask_ref: Bool32::default(),
51078             shader_sample_rate_interpolation_functions: Bool32::default(),
51079             tessellation_isolines: Bool32::default(),
51080             tessellation_point_mode: Bool32::default(),
51081             triangle_fans: Bool32::default(),
51082             vertex_attribute_access_beyond_stride: Bool32::default(),
51083         }
51084     }
51085 }
51086 unsafe impl TaggedStructure for PhysicalDevicePortabilitySubsetFeaturesKHR {
51087     const STRUCTURE_TYPE: StructureType =
51088         StructureType::PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR;
51089 }
51090 impl PhysicalDevicePortabilitySubsetFeaturesKHR {
builder<'a>() -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a>51091     pub fn builder<'a>() -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
51092         PhysicalDevicePortabilitySubsetFeaturesKHRBuilder {
51093             inner: Self::default(),
51094             marker: ::std::marker::PhantomData,
51095         }
51096     }
51097 }
51098 #[repr(transparent)]
51099 pub struct PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
51100     inner: PhysicalDevicePortabilitySubsetFeaturesKHR,
51101     marker: ::std::marker::PhantomData<&'a ()>,
51102 }
51103 unsafe impl ExtendsPhysicalDeviceFeatures2
51104     for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'_>
51105 {
51106 }
51107 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePortabilitySubsetFeaturesKHR {}
51108 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'_> {}
51109 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePortabilitySubsetFeaturesKHR {}
51110 impl<'a> ::std::ops::Deref for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
51111     type Target = PhysicalDevicePortabilitySubsetFeaturesKHR;
deref(&self) -> &Self::Target51112     fn deref(&self) -> &Self::Target {
51113         &self.inner
51114     }
51115 }
51116 impl<'a> ::std::ops::DerefMut for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target51117     fn deref_mut(&mut self) -> &mut Self::Target {
51118         &mut self.inner
51119     }
51120 }
51121 impl<'a> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
51122     #[inline]
constant_alpha_color_blend_factors( mut self, constant_alpha_color_blend_factors: bool, ) -> Self51123     pub fn constant_alpha_color_blend_factors(
51124         mut self,
51125         constant_alpha_color_blend_factors: bool,
51126     ) -> Self {
51127         self.inner.constant_alpha_color_blend_factors = constant_alpha_color_blend_factors.into();
51128         self
51129     }
51130     #[inline]
events(mut self, events: bool) -> Self51131     pub fn events(mut self, events: bool) -> Self {
51132         self.inner.events = events.into();
51133         self
51134     }
51135     #[inline]
image_view_format_reinterpretation( mut self, image_view_format_reinterpretation: bool, ) -> Self51136     pub fn image_view_format_reinterpretation(
51137         mut self,
51138         image_view_format_reinterpretation: bool,
51139     ) -> Self {
51140         self.inner.image_view_format_reinterpretation = image_view_format_reinterpretation.into();
51141         self
51142     }
51143     #[inline]
image_view_format_swizzle(mut self, image_view_format_swizzle: bool) -> Self51144     pub fn image_view_format_swizzle(mut self, image_view_format_swizzle: bool) -> Self {
51145         self.inner.image_view_format_swizzle = image_view_format_swizzle.into();
51146         self
51147     }
51148     #[inline]
image_view2_d_on3_d_image(mut self, image_view2_d_on3_d_image: bool) -> Self51149     pub fn image_view2_d_on3_d_image(mut self, image_view2_d_on3_d_image: bool) -> Self {
51150         self.inner.image_view2_d_on3_d_image = image_view2_d_on3_d_image.into();
51151         self
51152     }
51153     #[inline]
multisample_array_image(mut self, multisample_array_image: bool) -> Self51154     pub fn multisample_array_image(mut self, multisample_array_image: bool) -> Self {
51155         self.inner.multisample_array_image = multisample_array_image.into();
51156         self
51157     }
51158     #[inline]
mutable_comparison_samplers(mut self, mutable_comparison_samplers: bool) -> Self51159     pub fn mutable_comparison_samplers(mut self, mutable_comparison_samplers: bool) -> Self {
51160         self.inner.mutable_comparison_samplers = mutable_comparison_samplers.into();
51161         self
51162     }
51163     #[inline]
point_polygons(mut self, point_polygons: bool) -> Self51164     pub fn point_polygons(mut self, point_polygons: bool) -> Self {
51165         self.inner.point_polygons = point_polygons.into();
51166         self
51167     }
51168     #[inline]
sampler_mip_lod_bias(mut self, sampler_mip_lod_bias: bool) -> Self51169     pub fn sampler_mip_lod_bias(mut self, sampler_mip_lod_bias: bool) -> Self {
51170         self.inner.sampler_mip_lod_bias = sampler_mip_lod_bias.into();
51171         self
51172     }
51173     #[inline]
separate_stencil_mask_ref(mut self, separate_stencil_mask_ref: bool) -> Self51174     pub fn separate_stencil_mask_ref(mut self, separate_stencil_mask_ref: bool) -> Self {
51175         self.inner.separate_stencil_mask_ref = separate_stencil_mask_ref.into();
51176         self
51177     }
51178     #[inline]
shader_sample_rate_interpolation_functions( mut self, shader_sample_rate_interpolation_functions: bool, ) -> Self51179     pub fn shader_sample_rate_interpolation_functions(
51180         mut self,
51181         shader_sample_rate_interpolation_functions: bool,
51182     ) -> Self {
51183         self.inner.shader_sample_rate_interpolation_functions =
51184             shader_sample_rate_interpolation_functions.into();
51185         self
51186     }
51187     #[inline]
tessellation_isolines(mut self, tessellation_isolines: bool) -> Self51188     pub fn tessellation_isolines(mut self, tessellation_isolines: bool) -> Self {
51189         self.inner.tessellation_isolines = tessellation_isolines.into();
51190         self
51191     }
51192     #[inline]
tessellation_point_mode(mut self, tessellation_point_mode: bool) -> Self51193     pub fn tessellation_point_mode(mut self, tessellation_point_mode: bool) -> Self {
51194         self.inner.tessellation_point_mode = tessellation_point_mode.into();
51195         self
51196     }
51197     #[inline]
triangle_fans(mut self, triangle_fans: bool) -> Self51198     pub fn triangle_fans(mut self, triangle_fans: bool) -> Self {
51199         self.inner.triangle_fans = triangle_fans.into();
51200         self
51201     }
51202     #[inline]
vertex_attribute_access_beyond_stride( mut self, vertex_attribute_access_beyond_stride: bool, ) -> Self51203     pub fn vertex_attribute_access_beyond_stride(
51204         mut self,
51205         vertex_attribute_access_beyond_stride: bool,
51206     ) -> Self {
51207         self.inner.vertex_attribute_access_beyond_stride =
51208             vertex_attribute_access_beyond_stride.into();
51209         self
51210     }
51211     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51212     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51213     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePortabilitySubsetFeaturesKHR51214     pub fn build(self) -> PhysicalDevicePortabilitySubsetFeaturesKHR {
51215         self.inner
51216     }
51217 }
51218 #[repr(C)]
51219 #[cfg_attr(feature = "debug", derive(Debug))]
51220 #[derive(Copy, Clone)]
51221 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePortabilitySubsetPropertiesKHR.html>"]
51222 pub struct PhysicalDevicePortabilitySubsetPropertiesKHR {
51223     pub s_type: StructureType,
51224     pub p_next: *mut c_void,
51225     pub min_vertex_input_binding_stride_alignment: u32,
51226 }
51227 impl ::std::default::Default for PhysicalDevicePortabilitySubsetPropertiesKHR {
51228     #[inline]
default() -> Self51229     fn default() -> Self {
51230         Self {
51231             s_type: Self::STRUCTURE_TYPE,
51232             p_next: ::std::ptr::null_mut(),
51233             min_vertex_input_binding_stride_alignment: u32::default(),
51234         }
51235     }
51236 }
51237 unsafe impl TaggedStructure for PhysicalDevicePortabilitySubsetPropertiesKHR {
51238     const STRUCTURE_TYPE: StructureType =
51239         StructureType::PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR;
51240 }
51241 impl PhysicalDevicePortabilitySubsetPropertiesKHR {
builder<'a>() -> PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a>51242     pub fn builder<'a>() -> PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> {
51243         PhysicalDevicePortabilitySubsetPropertiesKHRBuilder {
51244             inner: Self::default(),
51245             marker: ::std::marker::PhantomData,
51246         }
51247     }
51248 }
51249 #[repr(transparent)]
51250 pub struct PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> {
51251     inner: PhysicalDevicePortabilitySubsetPropertiesKHR,
51252     marker: ::std::marker::PhantomData<&'a ()>,
51253 }
51254 unsafe impl ExtendsPhysicalDeviceProperties2
51255     for PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'_>
51256 {
51257 }
51258 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePortabilitySubsetPropertiesKHR {}
51259 impl<'a> ::std::ops::Deref for PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> {
51260     type Target = PhysicalDevicePortabilitySubsetPropertiesKHR;
deref(&self) -> &Self::Target51261     fn deref(&self) -> &Self::Target {
51262         &self.inner
51263     }
51264 }
51265 impl<'a> ::std::ops::DerefMut for PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target51266     fn deref_mut(&mut self) -> &mut Self::Target {
51267         &mut self.inner
51268     }
51269 }
51270 impl<'a> PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> {
51271     #[inline]
min_vertex_input_binding_stride_alignment( mut self, min_vertex_input_binding_stride_alignment: u32, ) -> Self51272     pub fn min_vertex_input_binding_stride_alignment(
51273         mut self,
51274         min_vertex_input_binding_stride_alignment: u32,
51275     ) -> Self {
51276         self.inner.min_vertex_input_binding_stride_alignment =
51277             min_vertex_input_binding_stride_alignment;
51278         self
51279     }
51280     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51281     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51282     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePortabilitySubsetPropertiesKHR51283     pub fn build(self) -> PhysicalDevicePortabilitySubsetPropertiesKHR {
51284         self.inner
51285     }
51286 }
51287 #[repr(C)]
51288 #[cfg_attr(feature = "debug", derive(Debug))]
51289 #[derive(Copy, Clone)]
51290 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevice4444FormatsFeaturesEXT.html>"]
51291 pub struct PhysicalDevice4444FormatsFeaturesEXT {
51292     pub s_type: StructureType,
51293     pub p_next: *mut c_void,
51294     pub format_a4r4g4b4: Bool32,
51295     pub format_a4b4g4r4: Bool32,
51296 }
51297 impl ::std::default::Default for PhysicalDevice4444FormatsFeaturesEXT {
51298     #[inline]
default() -> Self51299     fn default() -> Self {
51300         Self {
51301             s_type: Self::STRUCTURE_TYPE,
51302             p_next: ::std::ptr::null_mut(),
51303             format_a4r4g4b4: Bool32::default(),
51304             format_a4b4g4r4: Bool32::default(),
51305         }
51306     }
51307 }
51308 unsafe impl TaggedStructure for PhysicalDevice4444FormatsFeaturesEXT {
51309     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
51310 }
51311 impl PhysicalDevice4444FormatsFeaturesEXT {
builder<'a>() -> PhysicalDevice4444FormatsFeaturesEXTBuilder<'a>51312     pub fn builder<'a>() -> PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
51313         PhysicalDevice4444FormatsFeaturesEXTBuilder {
51314             inner: Self::default(),
51315             marker: ::std::marker::PhantomData,
51316         }
51317     }
51318 }
51319 #[repr(transparent)]
51320 pub struct PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
51321     inner: PhysicalDevice4444FormatsFeaturesEXT,
51322     marker: ::std::marker::PhantomData<&'a ()>,
51323 }
51324 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice4444FormatsFeaturesEXTBuilder<'_> {}
51325 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice4444FormatsFeaturesEXT {}
51326 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice4444FormatsFeaturesEXTBuilder<'_> {}
51327 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice4444FormatsFeaturesEXT {}
51328 impl<'a> ::std::ops::Deref for PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
51329     type Target = PhysicalDevice4444FormatsFeaturesEXT;
deref(&self) -> &Self::Target51330     fn deref(&self) -> &Self::Target {
51331         &self.inner
51332     }
51333 }
51334 impl<'a> ::std::ops::DerefMut for PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target51335     fn deref_mut(&mut self) -> &mut Self::Target {
51336         &mut self.inner
51337     }
51338 }
51339 impl<'a> PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
51340     #[inline]
format_a4r4g4b4(mut self, format_a4r4g4b4: bool) -> Self51341     pub fn format_a4r4g4b4(mut self, format_a4r4g4b4: bool) -> Self {
51342         self.inner.format_a4r4g4b4 = format_a4r4g4b4.into();
51343         self
51344     }
51345     #[inline]
format_a4b4g4r4(mut self, format_a4b4g4r4: bool) -> Self51346     pub fn format_a4b4g4r4(mut self, format_a4b4g4r4: bool) -> Self {
51347         self.inner.format_a4b4g4r4 = format_a4b4g4r4.into();
51348         self
51349     }
51350     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51351     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51352     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevice4444FormatsFeaturesEXT51353     pub fn build(self) -> PhysicalDevice4444FormatsFeaturesEXT {
51354         self.inner
51355     }
51356 }
51357 #[repr(C)]
51358 #[cfg_attr(feature = "debug", derive(Debug))]
51359 #[derive(Copy, Clone)]
51360 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSubpassShadingFeaturesHUAWEI.html>"]
51361 pub struct PhysicalDeviceSubpassShadingFeaturesHUAWEI {
51362     pub s_type: StructureType,
51363     pub p_next: *mut c_void,
51364     pub subpass_shading: Bool32,
51365 }
51366 impl ::std::default::Default for PhysicalDeviceSubpassShadingFeaturesHUAWEI {
51367     #[inline]
default() -> Self51368     fn default() -> Self {
51369         Self {
51370             s_type: Self::STRUCTURE_TYPE,
51371             p_next: ::std::ptr::null_mut(),
51372             subpass_shading: Bool32::default(),
51373         }
51374     }
51375 }
51376 unsafe impl TaggedStructure for PhysicalDeviceSubpassShadingFeaturesHUAWEI {
51377     const STRUCTURE_TYPE: StructureType =
51378         StructureType::PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
51379 }
51380 impl PhysicalDeviceSubpassShadingFeaturesHUAWEI {
builder<'a>() -> PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a>51381     pub fn builder<'a>() -> PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> {
51382         PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder {
51383             inner: Self::default(),
51384             marker: ::std::marker::PhantomData,
51385         }
51386     }
51387 }
51388 #[repr(transparent)]
51389 pub struct PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> {
51390     inner: PhysicalDeviceSubpassShadingFeaturesHUAWEI,
51391     marker: ::std::marker::PhantomData<&'a ()>,
51392 }
51393 unsafe impl ExtendsPhysicalDeviceFeatures2
51394     for PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'_>
51395 {
51396 }
51397 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSubpassShadingFeaturesHUAWEI {}
51398 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'_> {}
51399 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubpassShadingFeaturesHUAWEI {}
51400 impl<'a> ::std::ops::Deref for PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> {
51401     type Target = PhysicalDeviceSubpassShadingFeaturesHUAWEI;
deref(&self) -> &Self::Target51402     fn deref(&self) -> &Self::Target {
51403         &self.inner
51404     }
51405 }
51406 impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target51407     fn deref_mut(&mut self) -> &mut Self::Target {
51408         &mut self.inner
51409     }
51410 }
51411 impl<'a> PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> {
51412     #[inline]
subpass_shading(mut self, subpass_shading: bool) -> Self51413     pub fn subpass_shading(mut self, subpass_shading: bool) -> Self {
51414         self.inner.subpass_shading = subpass_shading.into();
51415         self
51416     }
51417     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51418     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51419     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceSubpassShadingFeaturesHUAWEI51420     pub fn build(self) -> PhysicalDeviceSubpassShadingFeaturesHUAWEI {
51421         self.inner
51422     }
51423 }
51424 #[repr(C)]
51425 #[cfg_attr(feature = "debug", derive(Debug))]
51426 #[derive(Copy, Clone)]
51427 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI.html>"]
51428 pub struct PhysicalDeviceClusterCullingShaderFeaturesHUAWEI {
51429     pub s_type: StructureType,
51430     pub p_next: *mut c_void,
51431     pub clusterculling_shader: Bool32,
51432     pub multiview_cluster_culling_shader: Bool32,
51433 }
51434 impl ::std::default::Default for PhysicalDeviceClusterCullingShaderFeaturesHUAWEI {
51435     #[inline]
default() -> Self51436     fn default() -> Self {
51437         Self {
51438             s_type: Self::STRUCTURE_TYPE,
51439             p_next: ::std::ptr::null_mut(),
51440             clusterculling_shader: Bool32::default(),
51441             multiview_cluster_culling_shader: Bool32::default(),
51442         }
51443     }
51444 }
51445 unsafe impl TaggedStructure for PhysicalDeviceClusterCullingShaderFeaturesHUAWEI {
51446     const STRUCTURE_TYPE: StructureType =
51447         StructureType::PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI;
51448 }
51449 impl PhysicalDeviceClusterCullingShaderFeaturesHUAWEI {
builder<'a>() -> PhysicalDeviceClusterCullingShaderFeaturesHUAWEIBuilder<'a>51450     pub fn builder<'a>() -> PhysicalDeviceClusterCullingShaderFeaturesHUAWEIBuilder<'a> {
51451         PhysicalDeviceClusterCullingShaderFeaturesHUAWEIBuilder {
51452             inner: Self::default(),
51453             marker: ::std::marker::PhantomData,
51454         }
51455     }
51456 }
51457 #[repr(transparent)]
51458 pub struct PhysicalDeviceClusterCullingShaderFeaturesHUAWEIBuilder<'a> {
51459     inner: PhysicalDeviceClusterCullingShaderFeaturesHUAWEI,
51460     marker: ::std::marker::PhantomData<&'a ()>,
51461 }
51462 unsafe impl ExtendsPhysicalDeviceFeatures2
51463     for PhysicalDeviceClusterCullingShaderFeaturesHUAWEIBuilder<'_>
51464 {
51465 }
51466 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceClusterCullingShaderFeaturesHUAWEI {}
51467 unsafe impl ExtendsDeviceCreateInfo
51468     for PhysicalDeviceClusterCullingShaderFeaturesHUAWEIBuilder<'_>
51469 {
51470 }
51471 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceClusterCullingShaderFeaturesHUAWEI {}
51472 impl<'a> ::std::ops::Deref for PhysicalDeviceClusterCullingShaderFeaturesHUAWEIBuilder<'a> {
51473     type Target = PhysicalDeviceClusterCullingShaderFeaturesHUAWEI;
deref(&self) -> &Self::Target51474     fn deref(&self) -> &Self::Target {
51475         &self.inner
51476     }
51477 }
51478 impl<'a> ::std::ops::DerefMut for PhysicalDeviceClusterCullingShaderFeaturesHUAWEIBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target51479     fn deref_mut(&mut self) -> &mut Self::Target {
51480         &mut self.inner
51481     }
51482 }
51483 impl<'a> PhysicalDeviceClusterCullingShaderFeaturesHUAWEIBuilder<'a> {
51484     #[inline]
clusterculling_shader(mut self, clusterculling_shader: bool) -> Self51485     pub fn clusterculling_shader(mut self, clusterculling_shader: bool) -> Self {
51486         self.inner.clusterculling_shader = clusterculling_shader.into();
51487         self
51488     }
51489     #[inline]
multiview_cluster_culling_shader( mut self, multiview_cluster_culling_shader: bool, ) -> Self51490     pub fn multiview_cluster_culling_shader(
51491         mut self,
51492         multiview_cluster_culling_shader: bool,
51493     ) -> Self {
51494         self.inner.multiview_cluster_culling_shader = multiview_cluster_culling_shader.into();
51495         self
51496     }
51497     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51498     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51499     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceClusterCullingShaderFeaturesHUAWEI51500     pub fn build(self) -> PhysicalDeviceClusterCullingShaderFeaturesHUAWEI {
51501         self.inner
51502     }
51503 }
51504 #[repr(C)]
51505 #[cfg_attr(feature = "debug", derive(Debug))]
51506 #[derive(Copy, Clone)]
51507 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCopy2.html>"]
51508 pub struct BufferCopy2 {
51509     pub s_type: StructureType,
51510     pub p_next: *const c_void,
51511     pub src_offset: DeviceSize,
51512     pub dst_offset: DeviceSize,
51513     pub size: DeviceSize,
51514 }
51515 impl ::std::default::Default for BufferCopy2 {
51516     #[inline]
default() -> Self51517     fn default() -> Self {
51518         Self {
51519             s_type: Self::STRUCTURE_TYPE,
51520             p_next: ::std::ptr::null(),
51521             src_offset: DeviceSize::default(),
51522             dst_offset: DeviceSize::default(),
51523             size: DeviceSize::default(),
51524         }
51525     }
51526 }
51527 unsafe impl TaggedStructure for BufferCopy2 {
51528     const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_COPY_2;
51529 }
51530 impl BufferCopy2 {
builder<'a>() -> BufferCopy2Builder<'a>51531     pub fn builder<'a>() -> BufferCopy2Builder<'a> {
51532         BufferCopy2Builder {
51533             inner: Self::default(),
51534             marker: ::std::marker::PhantomData,
51535         }
51536     }
51537 }
51538 #[repr(transparent)]
51539 pub struct BufferCopy2Builder<'a> {
51540     inner: BufferCopy2,
51541     marker: ::std::marker::PhantomData<&'a ()>,
51542 }
51543 impl<'a> ::std::ops::Deref for BufferCopy2Builder<'a> {
51544     type Target = BufferCopy2;
deref(&self) -> &Self::Target51545     fn deref(&self) -> &Self::Target {
51546         &self.inner
51547     }
51548 }
51549 impl<'a> ::std::ops::DerefMut for BufferCopy2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target51550     fn deref_mut(&mut self) -> &mut Self::Target {
51551         &mut self.inner
51552     }
51553 }
51554 impl<'a> BufferCopy2Builder<'a> {
51555     #[inline]
src_offset(mut self, src_offset: DeviceSize) -> Self51556     pub fn src_offset(mut self, src_offset: DeviceSize) -> Self {
51557         self.inner.src_offset = src_offset;
51558         self
51559     }
51560     #[inline]
dst_offset(mut self, dst_offset: DeviceSize) -> Self51561     pub fn dst_offset(mut self, dst_offset: DeviceSize) -> Self {
51562         self.inner.dst_offset = dst_offset;
51563         self
51564     }
51565     #[inline]
size(mut self, size: DeviceSize) -> Self51566     pub fn size(mut self, size: DeviceSize) -> Self {
51567         self.inner.size = size;
51568         self
51569     }
51570     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51571     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51572     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferCopy251573     pub fn build(self) -> BufferCopy2 {
51574         self.inner
51575     }
51576 }
51577 #[repr(C)]
51578 #[cfg_attr(feature = "debug", derive(Debug))]
51579 #[derive(Copy, Clone)]
51580 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCopy2.html>"]
51581 pub struct ImageCopy2 {
51582     pub s_type: StructureType,
51583     pub p_next: *const c_void,
51584     pub src_subresource: ImageSubresourceLayers,
51585     pub src_offset: Offset3D,
51586     pub dst_subresource: ImageSubresourceLayers,
51587     pub dst_offset: Offset3D,
51588     pub extent: Extent3D,
51589 }
51590 impl ::std::default::Default for ImageCopy2 {
51591     #[inline]
default() -> Self51592     fn default() -> Self {
51593         Self {
51594             s_type: Self::STRUCTURE_TYPE,
51595             p_next: ::std::ptr::null(),
51596             src_subresource: ImageSubresourceLayers::default(),
51597             src_offset: Offset3D::default(),
51598             dst_subresource: ImageSubresourceLayers::default(),
51599             dst_offset: Offset3D::default(),
51600             extent: Extent3D::default(),
51601         }
51602     }
51603 }
51604 unsafe impl TaggedStructure for ImageCopy2 {
51605     const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_COPY_2;
51606 }
51607 impl ImageCopy2 {
builder<'a>() -> ImageCopy2Builder<'a>51608     pub fn builder<'a>() -> ImageCopy2Builder<'a> {
51609         ImageCopy2Builder {
51610             inner: Self::default(),
51611             marker: ::std::marker::PhantomData,
51612         }
51613     }
51614 }
51615 #[repr(transparent)]
51616 pub struct ImageCopy2Builder<'a> {
51617     inner: ImageCopy2,
51618     marker: ::std::marker::PhantomData<&'a ()>,
51619 }
51620 impl<'a> ::std::ops::Deref for ImageCopy2Builder<'a> {
51621     type Target = ImageCopy2;
deref(&self) -> &Self::Target51622     fn deref(&self) -> &Self::Target {
51623         &self.inner
51624     }
51625 }
51626 impl<'a> ::std::ops::DerefMut for ImageCopy2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target51627     fn deref_mut(&mut self) -> &mut Self::Target {
51628         &mut self.inner
51629     }
51630 }
51631 impl<'a> ImageCopy2Builder<'a> {
51632     #[inline]
src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self51633     pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self {
51634         self.inner.src_subresource = src_subresource;
51635         self
51636     }
51637     #[inline]
src_offset(mut self, src_offset: Offset3D) -> Self51638     pub fn src_offset(mut self, src_offset: Offset3D) -> Self {
51639         self.inner.src_offset = src_offset;
51640         self
51641     }
51642     #[inline]
dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self51643     pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self {
51644         self.inner.dst_subresource = dst_subresource;
51645         self
51646     }
51647     #[inline]
dst_offset(mut self, dst_offset: Offset3D) -> Self51648     pub fn dst_offset(mut self, dst_offset: Offset3D) -> Self {
51649         self.inner.dst_offset = dst_offset;
51650         self
51651     }
51652     #[inline]
extent(mut self, extent: Extent3D) -> Self51653     pub fn extent(mut self, extent: Extent3D) -> Self {
51654         self.inner.extent = extent;
51655         self
51656     }
51657     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51658     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51659     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageCopy251660     pub fn build(self) -> ImageCopy2 {
51661         self.inner
51662     }
51663 }
51664 #[repr(C)]
51665 #[cfg_attr(feature = "debug", derive(Debug))]
51666 #[derive(Copy, Clone)]
51667 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageBlit2.html>"]
51668 pub struct ImageBlit2 {
51669     pub s_type: StructureType,
51670     pub p_next: *const c_void,
51671     pub src_subresource: ImageSubresourceLayers,
51672     pub src_offsets: [Offset3D; 2],
51673     pub dst_subresource: ImageSubresourceLayers,
51674     pub dst_offsets: [Offset3D; 2],
51675 }
51676 impl ::std::default::Default for ImageBlit2 {
51677     #[inline]
default() -> Self51678     fn default() -> Self {
51679         Self {
51680             s_type: Self::STRUCTURE_TYPE,
51681             p_next: ::std::ptr::null(),
51682             src_subresource: ImageSubresourceLayers::default(),
51683             src_offsets: unsafe { ::std::mem::zeroed() },
51684             dst_subresource: ImageSubresourceLayers::default(),
51685             dst_offsets: unsafe { ::std::mem::zeroed() },
51686         }
51687     }
51688 }
51689 unsafe impl TaggedStructure for ImageBlit2 {
51690     const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_BLIT_2;
51691 }
51692 impl ImageBlit2 {
builder<'a>() -> ImageBlit2Builder<'a>51693     pub fn builder<'a>() -> ImageBlit2Builder<'a> {
51694         ImageBlit2Builder {
51695             inner: Self::default(),
51696             marker: ::std::marker::PhantomData,
51697         }
51698     }
51699 }
51700 #[repr(transparent)]
51701 pub struct ImageBlit2Builder<'a> {
51702     inner: ImageBlit2,
51703     marker: ::std::marker::PhantomData<&'a ()>,
51704 }
51705 pub unsafe trait ExtendsImageBlit2 {}
51706 impl<'a> ::std::ops::Deref for ImageBlit2Builder<'a> {
51707     type Target = ImageBlit2;
deref(&self) -> &Self::Target51708     fn deref(&self) -> &Self::Target {
51709         &self.inner
51710     }
51711 }
51712 impl<'a> ::std::ops::DerefMut for ImageBlit2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target51713     fn deref_mut(&mut self) -> &mut Self::Target {
51714         &mut self.inner
51715     }
51716 }
51717 impl<'a> ImageBlit2Builder<'a> {
51718     #[inline]
src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self51719     pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self {
51720         self.inner.src_subresource = src_subresource;
51721         self
51722     }
51723     #[inline]
src_offsets(mut self, src_offsets: [Offset3D; 2]) -> Self51724     pub fn src_offsets(mut self, src_offsets: [Offset3D; 2]) -> Self {
51725         self.inner.src_offsets = src_offsets;
51726         self
51727     }
51728     #[inline]
dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self51729     pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self {
51730         self.inner.dst_subresource = dst_subresource;
51731         self
51732     }
51733     #[inline]
dst_offsets(mut self, dst_offsets: [Offset3D; 2]) -> Self51734     pub fn dst_offsets(mut self, dst_offsets: [Offset3D; 2]) -> Self {
51735         self.inner.dst_offsets = dst_offsets;
51736         self
51737     }
51738     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
51739     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
51740     #[doc = r" valid extension structs can be pushed into the chain."]
51741     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
51742     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsImageBlit2>(mut self, next: &'a mut T) -> Self51743     pub fn push_next<T: ExtendsImageBlit2>(mut self, next: &'a mut T) -> Self {
51744         unsafe {
51745             let next_ptr = <*const T>::cast(next);
51746             let last_next = ptr_chain_iter(next).last().unwrap();
51747             (*last_next).p_next = self.inner.p_next as _;
51748             self.inner.p_next = next_ptr;
51749         }
51750         self
51751     }
51752     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51753     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51754     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageBlit251755     pub fn build(self) -> ImageBlit2 {
51756         self.inner
51757     }
51758 }
51759 #[repr(C)]
51760 #[cfg_attr(feature = "debug", derive(Debug))]
51761 #[derive(Copy, Clone)]
51762 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferImageCopy2.html>"]
51763 pub struct BufferImageCopy2 {
51764     pub s_type: StructureType,
51765     pub p_next: *const c_void,
51766     pub buffer_offset: DeviceSize,
51767     pub buffer_row_length: u32,
51768     pub buffer_image_height: u32,
51769     pub image_subresource: ImageSubresourceLayers,
51770     pub image_offset: Offset3D,
51771     pub image_extent: Extent3D,
51772 }
51773 impl ::std::default::Default for BufferImageCopy2 {
51774     #[inline]
default() -> Self51775     fn default() -> Self {
51776         Self {
51777             s_type: Self::STRUCTURE_TYPE,
51778             p_next: ::std::ptr::null(),
51779             buffer_offset: DeviceSize::default(),
51780             buffer_row_length: u32::default(),
51781             buffer_image_height: u32::default(),
51782             image_subresource: ImageSubresourceLayers::default(),
51783             image_offset: Offset3D::default(),
51784             image_extent: Extent3D::default(),
51785         }
51786     }
51787 }
51788 unsafe impl TaggedStructure for BufferImageCopy2 {
51789     const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_IMAGE_COPY_2;
51790 }
51791 impl BufferImageCopy2 {
builder<'a>() -> BufferImageCopy2Builder<'a>51792     pub fn builder<'a>() -> BufferImageCopy2Builder<'a> {
51793         BufferImageCopy2Builder {
51794             inner: Self::default(),
51795             marker: ::std::marker::PhantomData,
51796         }
51797     }
51798 }
51799 #[repr(transparent)]
51800 pub struct BufferImageCopy2Builder<'a> {
51801     inner: BufferImageCopy2,
51802     marker: ::std::marker::PhantomData<&'a ()>,
51803 }
51804 pub unsafe trait ExtendsBufferImageCopy2 {}
51805 impl<'a> ::std::ops::Deref for BufferImageCopy2Builder<'a> {
51806     type Target = BufferImageCopy2;
deref(&self) -> &Self::Target51807     fn deref(&self) -> &Self::Target {
51808         &self.inner
51809     }
51810 }
51811 impl<'a> ::std::ops::DerefMut for BufferImageCopy2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target51812     fn deref_mut(&mut self) -> &mut Self::Target {
51813         &mut self.inner
51814     }
51815 }
51816 impl<'a> BufferImageCopy2Builder<'a> {
51817     #[inline]
buffer_offset(mut self, buffer_offset: DeviceSize) -> Self51818     pub fn buffer_offset(mut self, buffer_offset: DeviceSize) -> Self {
51819         self.inner.buffer_offset = buffer_offset;
51820         self
51821     }
51822     #[inline]
buffer_row_length(mut self, buffer_row_length: u32) -> Self51823     pub fn buffer_row_length(mut self, buffer_row_length: u32) -> Self {
51824         self.inner.buffer_row_length = buffer_row_length;
51825         self
51826     }
51827     #[inline]
buffer_image_height(mut self, buffer_image_height: u32) -> Self51828     pub fn buffer_image_height(mut self, buffer_image_height: u32) -> Self {
51829         self.inner.buffer_image_height = buffer_image_height;
51830         self
51831     }
51832     #[inline]
image_subresource(mut self, image_subresource: ImageSubresourceLayers) -> Self51833     pub fn image_subresource(mut self, image_subresource: ImageSubresourceLayers) -> Self {
51834         self.inner.image_subresource = image_subresource;
51835         self
51836     }
51837     #[inline]
image_offset(mut self, image_offset: Offset3D) -> Self51838     pub fn image_offset(mut self, image_offset: Offset3D) -> Self {
51839         self.inner.image_offset = image_offset;
51840         self
51841     }
51842     #[inline]
image_extent(mut self, image_extent: Extent3D) -> Self51843     pub fn image_extent(mut self, image_extent: Extent3D) -> Self {
51844         self.inner.image_extent = image_extent;
51845         self
51846     }
51847     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
51848     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
51849     #[doc = r" valid extension structs can be pushed into the chain."]
51850     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
51851     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsBufferImageCopy2>(mut self, next: &'a mut T) -> Self51852     pub fn push_next<T: ExtendsBufferImageCopy2>(mut self, next: &'a mut T) -> Self {
51853         unsafe {
51854             let next_ptr = <*const T>::cast(next);
51855             let last_next = ptr_chain_iter(next).last().unwrap();
51856             (*last_next).p_next = self.inner.p_next as _;
51857             self.inner.p_next = next_ptr;
51858         }
51859         self
51860     }
51861     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51862     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51863     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferImageCopy251864     pub fn build(self) -> BufferImageCopy2 {
51865         self.inner
51866     }
51867 }
51868 #[repr(C)]
51869 #[cfg_attr(feature = "debug", derive(Debug))]
51870 #[derive(Copy, Clone)]
51871 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageResolve2.html>"]
51872 pub struct ImageResolve2 {
51873     pub s_type: StructureType,
51874     pub p_next: *const c_void,
51875     pub src_subresource: ImageSubresourceLayers,
51876     pub src_offset: Offset3D,
51877     pub dst_subresource: ImageSubresourceLayers,
51878     pub dst_offset: Offset3D,
51879     pub extent: Extent3D,
51880 }
51881 impl ::std::default::Default for ImageResolve2 {
51882     #[inline]
default() -> Self51883     fn default() -> Self {
51884         Self {
51885             s_type: Self::STRUCTURE_TYPE,
51886             p_next: ::std::ptr::null(),
51887             src_subresource: ImageSubresourceLayers::default(),
51888             src_offset: Offset3D::default(),
51889             dst_subresource: ImageSubresourceLayers::default(),
51890             dst_offset: Offset3D::default(),
51891             extent: Extent3D::default(),
51892         }
51893     }
51894 }
51895 unsafe impl TaggedStructure for ImageResolve2 {
51896     const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_RESOLVE_2;
51897 }
51898 impl ImageResolve2 {
builder<'a>() -> ImageResolve2Builder<'a>51899     pub fn builder<'a>() -> ImageResolve2Builder<'a> {
51900         ImageResolve2Builder {
51901             inner: Self::default(),
51902             marker: ::std::marker::PhantomData,
51903         }
51904     }
51905 }
51906 #[repr(transparent)]
51907 pub struct ImageResolve2Builder<'a> {
51908     inner: ImageResolve2,
51909     marker: ::std::marker::PhantomData<&'a ()>,
51910 }
51911 impl<'a> ::std::ops::Deref for ImageResolve2Builder<'a> {
51912     type Target = ImageResolve2;
deref(&self) -> &Self::Target51913     fn deref(&self) -> &Self::Target {
51914         &self.inner
51915     }
51916 }
51917 impl<'a> ::std::ops::DerefMut for ImageResolve2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target51918     fn deref_mut(&mut self) -> &mut Self::Target {
51919         &mut self.inner
51920     }
51921 }
51922 impl<'a> ImageResolve2Builder<'a> {
51923     #[inline]
src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self51924     pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self {
51925         self.inner.src_subresource = src_subresource;
51926         self
51927     }
51928     #[inline]
src_offset(mut self, src_offset: Offset3D) -> Self51929     pub fn src_offset(mut self, src_offset: Offset3D) -> Self {
51930         self.inner.src_offset = src_offset;
51931         self
51932     }
51933     #[inline]
dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self51934     pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self {
51935         self.inner.dst_subresource = dst_subresource;
51936         self
51937     }
51938     #[inline]
dst_offset(mut self, dst_offset: Offset3D) -> Self51939     pub fn dst_offset(mut self, dst_offset: Offset3D) -> Self {
51940         self.inner.dst_offset = dst_offset;
51941         self
51942     }
51943     #[inline]
extent(mut self, extent: Extent3D) -> Self51944     pub fn extent(mut self, extent: Extent3D) -> Self {
51945         self.inner.extent = extent;
51946         self
51947     }
51948     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51949     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51950     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageResolve251951     pub fn build(self) -> ImageResolve2 {
51952         self.inner
51953     }
51954 }
51955 #[repr(C)]
51956 #[cfg_attr(feature = "debug", derive(Debug))]
51957 #[derive(Copy, Clone)]
51958 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyBufferInfo2.html>"]
51959 pub struct CopyBufferInfo2 {
51960     pub s_type: StructureType,
51961     pub p_next: *const c_void,
51962     pub src_buffer: Buffer,
51963     pub dst_buffer: Buffer,
51964     pub region_count: u32,
51965     pub p_regions: *const BufferCopy2,
51966 }
51967 impl ::std::default::Default for CopyBufferInfo2 {
51968     #[inline]
default() -> Self51969     fn default() -> Self {
51970         Self {
51971             s_type: Self::STRUCTURE_TYPE,
51972             p_next: ::std::ptr::null(),
51973             src_buffer: Buffer::default(),
51974             dst_buffer: Buffer::default(),
51975             region_count: u32::default(),
51976             p_regions: ::std::ptr::null(),
51977         }
51978     }
51979 }
51980 unsafe impl TaggedStructure for CopyBufferInfo2 {
51981     const STRUCTURE_TYPE: StructureType = StructureType::COPY_BUFFER_INFO_2;
51982 }
51983 impl CopyBufferInfo2 {
builder<'a>() -> CopyBufferInfo2Builder<'a>51984     pub fn builder<'a>() -> CopyBufferInfo2Builder<'a> {
51985         CopyBufferInfo2Builder {
51986             inner: Self::default(),
51987             marker: ::std::marker::PhantomData,
51988         }
51989     }
51990 }
51991 #[repr(transparent)]
51992 pub struct CopyBufferInfo2Builder<'a> {
51993     inner: CopyBufferInfo2,
51994     marker: ::std::marker::PhantomData<&'a ()>,
51995 }
51996 impl<'a> ::std::ops::Deref for CopyBufferInfo2Builder<'a> {
51997     type Target = CopyBufferInfo2;
deref(&self) -> &Self::Target51998     fn deref(&self) -> &Self::Target {
51999         &self.inner
52000     }
52001 }
52002 impl<'a> ::std::ops::DerefMut for CopyBufferInfo2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target52003     fn deref_mut(&mut self) -> &mut Self::Target {
52004         &mut self.inner
52005     }
52006 }
52007 impl<'a> CopyBufferInfo2Builder<'a> {
52008     #[inline]
src_buffer(mut self, src_buffer: Buffer) -> Self52009     pub fn src_buffer(mut self, src_buffer: Buffer) -> Self {
52010         self.inner.src_buffer = src_buffer;
52011         self
52012     }
52013     #[inline]
dst_buffer(mut self, dst_buffer: Buffer) -> Self52014     pub fn dst_buffer(mut self, dst_buffer: Buffer) -> Self {
52015         self.inner.dst_buffer = dst_buffer;
52016         self
52017     }
52018     #[inline]
regions(mut self, regions: &'a [BufferCopy2]) -> Self52019     pub fn regions(mut self, regions: &'a [BufferCopy2]) -> Self {
52020         self.inner.region_count = regions.len() as _;
52021         self.inner.p_regions = regions.as_ptr();
52022         self
52023     }
52024     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52025     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52026     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CopyBufferInfo252027     pub fn build(self) -> CopyBufferInfo2 {
52028         self.inner
52029     }
52030 }
52031 #[repr(C)]
52032 #[cfg_attr(feature = "debug", derive(Debug))]
52033 #[derive(Copy, Clone)]
52034 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyImageInfo2.html>"]
52035 pub struct CopyImageInfo2 {
52036     pub s_type: StructureType,
52037     pub p_next: *const c_void,
52038     pub src_image: Image,
52039     pub src_image_layout: ImageLayout,
52040     pub dst_image: Image,
52041     pub dst_image_layout: ImageLayout,
52042     pub region_count: u32,
52043     pub p_regions: *const ImageCopy2,
52044 }
52045 impl ::std::default::Default for CopyImageInfo2 {
52046     #[inline]
default() -> Self52047     fn default() -> Self {
52048         Self {
52049             s_type: Self::STRUCTURE_TYPE,
52050             p_next: ::std::ptr::null(),
52051             src_image: Image::default(),
52052             src_image_layout: ImageLayout::default(),
52053             dst_image: Image::default(),
52054             dst_image_layout: ImageLayout::default(),
52055             region_count: u32::default(),
52056             p_regions: ::std::ptr::null(),
52057         }
52058     }
52059 }
52060 unsafe impl TaggedStructure for CopyImageInfo2 {
52061     const STRUCTURE_TYPE: StructureType = StructureType::COPY_IMAGE_INFO_2;
52062 }
52063 impl CopyImageInfo2 {
builder<'a>() -> CopyImageInfo2Builder<'a>52064     pub fn builder<'a>() -> CopyImageInfo2Builder<'a> {
52065         CopyImageInfo2Builder {
52066             inner: Self::default(),
52067             marker: ::std::marker::PhantomData,
52068         }
52069     }
52070 }
52071 #[repr(transparent)]
52072 pub struct CopyImageInfo2Builder<'a> {
52073     inner: CopyImageInfo2,
52074     marker: ::std::marker::PhantomData<&'a ()>,
52075 }
52076 impl<'a> ::std::ops::Deref for CopyImageInfo2Builder<'a> {
52077     type Target = CopyImageInfo2;
deref(&self) -> &Self::Target52078     fn deref(&self) -> &Self::Target {
52079         &self.inner
52080     }
52081 }
52082 impl<'a> ::std::ops::DerefMut for CopyImageInfo2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target52083     fn deref_mut(&mut self) -> &mut Self::Target {
52084         &mut self.inner
52085     }
52086 }
52087 impl<'a> CopyImageInfo2Builder<'a> {
52088     #[inline]
src_image(mut self, src_image: Image) -> Self52089     pub fn src_image(mut self, src_image: Image) -> Self {
52090         self.inner.src_image = src_image;
52091         self
52092     }
52093     #[inline]
src_image_layout(mut self, src_image_layout: ImageLayout) -> Self52094     pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self {
52095         self.inner.src_image_layout = src_image_layout;
52096         self
52097     }
52098     #[inline]
dst_image(mut self, dst_image: Image) -> Self52099     pub fn dst_image(mut self, dst_image: Image) -> Self {
52100         self.inner.dst_image = dst_image;
52101         self
52102     }
52103     #[inline]
dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self52104     pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self {
52105         self.inner.dst_image_layout = dst_image_layout;
52106         self
52107     }
52108     #[inline]
regions(mut self, regions: &'a [ImageCopy2]) -> Self52109     pub fn regions(mut self, regions: &'a [ImageCopy2]) -> Self {
52110         self.inner.region_count = regions.len() as _;
52111         self.inner.p_regions = regions.as_ptr();
52112         self
52113     }
52114     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52115     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52116     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CopyImageInfo252117     pub fn build(self) -> CopyImageInfo2 {
52118         self.inner
52119     }
52120 }
52121 #[repr(C)]
52122 #[cfg_attr(feature = "debug", derive(Debug))]
52123 #[derive(Copy, Clone)]
52124 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBlitImageInfo2.html>"]
52125 pub struct BlitImageInfo2 {
52126     pub s_type: StructureType,
52127     pub p_next: *const c_void,
52128     pub src_image: Image,
52129     pub src_image_layout: ImageLayout,
52130     pub dst_image: Image,
52131     pub dst_image_layout: ImageLayout,
52132     pub region_count: u32,
52133     pub p_regions: *const ImageBlit2,
52134     pub filter: Filter,
52135 }
52136 impl ::std::default::Default for BlitImageInfo2 {
52137     #[inline]
default() -> Self52138     fn default() -> Self {
52139         Self {
52140             s_type: Self::STRUCTURE_TYPE,
52141             p_next: ::std::ptr::null(),
52142             src_image: Image::default(),
52143             src_image_layout: ImageLayout::default(),
52144             dst_image: Image::default(),
52145             dst_image_layout: ImageLayout::default(),
52146             region_count: u32::default(),
52147             p_regions: ::std::ptr::null(),
52148             filter: Filter::default(),
52149         }
52150     }
52151 }
52152 unsafe impl TaggedStructure for BlitImageInfo2 {
52153     const STRUCTURE_TYPE: StructureType = StructureType::BLIT_IMAGE_INFO_2;
52154 }
52155 impl BlitImageInfo2 {
builder<'a>() -> BlitImageInfo2Builder<'a>52156     pub fn builder<'a>() -> BlitImageInfo2Builder<'a> {
52157         BlitImageInfo2Builder {
52158             inner: Self::default(),
52159             marker: ::std::marker::PhantomData,
52160         }
52161     }
52162 }
52163 #[repr(transparent)]
52164 pub struct BlitImageInfo2Builder<'a> {
52165     inner: BlitImageInfo2,
52166     marker: ::std::marker::PhantomData<&'a ()>,
52167 }
52168 impl<'a> ::std::ops::Deref for BlitImageInfo2Builder<'a> {
52169     type Target = BlitImageInfo2;
deref(&self) -> &Self::Target52170     fn deref(&self) -> &Self::Target {
52171         &self.inner
52172     }
52173 }
52174 impl<'a> ::std::ops::DerefMut for BlitImageInfo2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target52175     fn deref_mut(&mut self) -> &mut Self::Target {
52176         &mut self.inner
52177     }
52178 }
52179 impl<'a> BlitImageInfo2Builder<'a> {
52180     #[inline]
src_image(mut self, src_image: Image) -> Self52181     pub fn src_image(mut self, src_image: Image) -> Self {
52182         self.inner.src_image = src_image;
52183         self
52184     }
52185     #[inline]
src_image_layout(mut self, src_image_layout: ImageLayout) -> Self52186     pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self {
52187         self.inner.src_image_layout = src_image_layout;
52188         self
52189     }
52190     #[inline]
dst_image(mut self, dst_image: Image) -> Self52191     pub fn dst_image(mut self, dst_image: Image) -> Self {
52192         self.inner.dst_image = dst_image;
52193         self
52194     }
52195     #[inline]
dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self52196     pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self {
52197         self.inner.dst_image_layout = dst_image_layout;
52198         self
52199     }
52200     #[inline]
regions(mut self, regions: &'a [ImageBlit2]) -> Self52201     pub fn regions(mut self, regions: &'a [ImageBlit2]) -> Self {
52202         self.inner.region_count = regions.len() as _;
52203         self.inner.p_regions = regions.as_ptr();
52204         self
52205     }
52206     #[inline]
filter(mut self, filter: Filter) -> Self52207     pub fn filter(mut self, filter: Filter) -> Self {
52208         self.inner.filter = filter;
52209         self
52210     }
52211     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52212     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52213     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BlitImageInfo252214     pub fn build(self) -> BlitImageInfo2 {
52215         self.inner
52216     }
52217 }
52218 #[repr(C)]
52219 #[cfg_attr(feature = "debug", derive(Debug))]
52220 #[derive(Copy, Clone)]
52221 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyBufferToImageInfo2.html>"]
52222 pub struct CopyBufferToImageInfo2 {
52223     pub s_type: StructureType,
52224     pub p_next: *const c_void,
52225     pub src_buffer: Buffer,
52226     pub dst_image: Image,
52227     pub dst_image_layout: ImageLayout,
52228     pub region_count: u32,
52229     pub p_regions: *const BufferImageCopy2,
52230 }
52231 impl ::std::default::Default for CopyBufferToImageInfo2 {
52232     #[inline]
default() -> Self52233     fn default() -> Self {
52234         Self {
52235             s_type: Self::STRUCTURE_TYPE,
52236             p_next: ::std::ptr::null(),
52237             src_buffer: Buffer::default(),
52238             dst_image: Image::default(),
52239             dst_image_layout: ImageLayout::default(),
52240             region_count: u32::default(),
52241             p_regions: ::std::ptr::null(),
52242         }
52243     }
52244 }
52245 unsafe impl TaggedStructure for CopyBufferToImageInfo2 {
52246     const STRUCTURE_TYPE: StructureType = StructureType::COPY_BUFFER_TO_IMAGE_INFO_2;
52247 }
52248 impl CopyBufferToImageInfo2 {
builder<'a>() -> CopyBufferToImageInfo2Builder<'a>52249     pub fn builder<'a>() -> CopyBufferToImageInfo2Builder<'a> {
52250         CopyBufferToImageInfo2Builder {
52251             inner: Self::default(),
52252             marker: ::std::marker::PhantomData,
52253         }
52254     }
52255 }
52256 #[repr(transparent)]
52257 pub struct CopyBufferToImageInfo2Builder<'a> {
52258     inner: CopyBufferToImageInfo2,
52259     marker: ::std::marker::PhantomData<&'a ()>,
52260 }
52261 impl<'a> ::std::ops::Deref for CopyBufferToImageInfo2Builder<'a> {
52262     type Target = CopyBufferToImageInfo2;
deref(&self) -> &Self::Target52263     fn deref(&self) -> &Self::Target {
52264         &self.inner
52265     }
52266 }
52267 impl<'a> ::std::ops::DerefMut for CopyBufferToImageInfo2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target52268     fn deref_mut(&mut self) -> &mut Self::Target {
52269         &mut self.inner
52270     }
52271 }
52272 impl<'a> CopyBufferToImageInfo2Builder<'a> {
52273     #[inline]
src_buffer(mut self, src_buffer: Buffer) -> Self52274     pub fn src_buffer(mut self, src_buffer: Buffer) -> Self {
52275         self.inner.src_buffer = src_buffer;
52276         self
52277     }
52278     #[inline]
dst_image(mut self, dst_image: Image) -> Self52279     pub fn dst_image(mut self, dst_image: Image) -> Self {
52280         self.inner.dst_image = dst_image;
52281         self
52282     }
52283     #[inline]
dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self52284     pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self {
52285         self.inner.dst_image_layout = dst_image_layout;
52286         self
52287     }
52288     #[inline]
regions(mut self, regions: &'a [BufferImageCopy2]) -> Self52289     pub fn regions(mut self, regions: &'a [BufferImageCopy2]) -> Self {
52290         self.inner.region_count = regions.len() as _;
52291         self.inner.p_regions = regions.as_ptr();
52292         self
52293     }
52294     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52295     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52296     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CopyBufferToImageInfo252297     pub fn build(self) -> CopyBufferToImageInfo2 {
52298         self.inner
52299     }
52300 }
52301 #[repr(C)]
52302 #[cfg_attr(feature = "debug", derive(Debug))]
52303 #[derive(Copy, Clone)]
52304 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyImageToBufferInfo2.html>"]
52305 pub struct CopyImageToBufferInfo2 {
52306     pub s_type: StructureType,
52307     pub p_next: *const c_void,
52308     pub src_image: Image,
52309     pub src_image_layout: ImageLayout,
52310     pub dst_buffer: Buffer,
52311     pub region_count: u32,
52312     pub p_regions: *const BufferImageCopy2,
52313 }
52314 impl ::std::default::Default for CopyImageToBufferInfo2 {
52315     #[inline]
default() -> Self52316     fn default() -> Self {
52317         Self {
52318             s_type: Self::STRUCTURE_TYPE,
52319             p_next: ::std::ptr::null(),
52320             src_image: Image::default(),
52321             src_image_layout: ImageLayout::default(),
52322             dst_buffer: Buffer::default(),
52323             region_count: u32::default(),
52324             p_regions: ::std::ptr::null(),
52325         }
52326     }
52327 }
52328 unsafe impl TaggedStructure for CopyImageToBufferInfo2 {
52329     const STRUCTURE_TYPE: StructureType = StructureType::COPY_IMAGE_TO_BUFFER_INFO_2;
52330 }
52331 impl CopyImageToBufferInfo2 {
builder<'a>() -> CopyImageToBufferInfo2Builder<'a>52332     pub fn builder<'a>() -> CopyImageToBufferInfo2Builder<'a> {
52333         CopyImageToBufferInfo2Builder {
52334             inner: Self::default(),
52335             marker: ::std::marker::PhantomData,
52336         }
52337     }
52338 }
52339 #[repr(transparent)]
52340 pub struct CopyImageToBufferInfo2Builder<'a> {
52341     inner: CopyImageToBufferInfo2,
52342     marker: ::std::marker::PhantomData<&'a ()>,
52343 }
52344 impl<'a> ::std::ops::Deref for CopyImageToBufferInfo2Builder<'a> {
52345     type Target = CopyImageToBufferInfo2;
deref(&self) -> &Self::Target52346     fn deref(&self) -> &Self::Target {
52347         &self.inner
52348     }
52349 }
52350 impl<'a> ::std::ops::DerefMut for CopyImageToBufferInfo2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target52351     fn deref_mut(&mut self) -> &mut Self::Target {
52352         &mut self.inner
52353     }
52354 }
52355 impl<'a> CopyImageToBufferInfo2Builder<'a> {
52356     #[inline]
src_image(mut self, src_image: Image) -> Self52357     pub fn src_image(mut self, src_image: Image) -> Self {
52358         self.inner.src_image = src_image;
52359         self
52360     }
52361     #[inline]
src_image_layout(mut self, src_image_layout: ImageLayout) -> Self52362     pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self {
52363         self.inner.src_image_layout = src_image_layout;
52364         self
52365     }
52366     #[inline]
dst_buffer(mut self, dst_buffer: Buffer) -> Self52367     pub fn dst_buffer(mut self, dst_buffer: Buffer) -> Self {
52368         self.inner.dst_buffer = dst_buffer;
52369         self
52370     }
52371     #[inline]
regions(mut self, regions: &'a [BufferImageCopy2]) -> Self52372     pub fn regions(mut self, regions: &'a [BufferImageCopy2]) -> Self {
52373         self.inner.region_count = regions.len() as _;
52374         self.inner.p_regions = regions.as_ptr();
52375         self
52376     }
52377     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52378     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52379     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CopyImageToBufferInfo252380     pub fn build(self) -> CopyImageToBufferInfo2 {
52381         self.inner
52382     }
52383 }
52384 #[repr(C)]
52385 #[cfg_attr(feature = "debug", derive(Debug))]
52386 #[derive(Copy, Clone)]
52387 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkResolveImageInfo2.html>"]
52388 pub struct ResolveImageInfo2 {
52389     pub s_type: StructureType,
52390     pub p_next: *const c_void,
52391     pub src_image: Image,
52392     pub src_image_layout: ImageLayout,
52393     pub dst_image: Image,
52394     pub dst_image_layout: ImageLayout,
52395     pub region_count: u32,
52396     pub p_regions: *const ImageResolve2,
52397 }
52398 impl ::std::default::Default for ResolveImageInfo2 {
52399     #[inline]
default() -> Self52400     fn default() -> Self {
52401         Self {
52402             s_type: Self::STRUCTURE_TYPE,
52403             p_next: ::std::ptr::null(),
52404             src_image: Image::default(),
52405             src_image_layout: ImageLayout::default(),
52406             dst_image: Image::default(),
52407             dst_image_layout: ImageLayout::default(),
52408             region_count: u32::default(),
52409             p_regions: ::std::ptr::null(),
52410         }
52411     }
52412 }
52413 unsafe impl TaggedStructure for ResolveImageInfo2 {
52414     const STRUCTURE_TYPE: StructureType = StructureType::RESOLVE_IMAGE_INFO_2;
52415 }
52416 impl ResolveImageInfo2 {
builder<'a>() -> ResolveImageInfo2Builder<'a>52417     pub fn builder<'a>() -> ResolveImageInfo2Builder<'a> {
52418         ResolveImageInfo2Builder {
52419             inner: Self::default(),
52420             marker: ::std::marker::PhantomData,
52421         }
52422     }
52423 }
52424 #[repr(transparent)]
52425 pub struct ResolveImageInfo2Builder<'a> {
52426     inner: ResolveImageInfo2,
52427     marker: ::std::marker::PhantomData<&'a ()>,
52428 }
52429 impl<'a> ::std::ops::Deref for ResolveImageInfo2Builder<'a> {
52430     type Target = ResolveImageInfo2;
deref(&self) -> &Self::Target52431     fn deref(&self) -> &Self::Target {
52432         &self.inner
52433     }
52434 }
52435 impl<'a> ::std::ops::DerefMut for ResolveImageInfo2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target52436     fn deref_mut(&mut self) -> &mut Self::Target {
52437         &mut self.inner
52438     }
52439 }
52440 impl<'a> ResolveImageInfo2Builder<'a> {
52441     #[inline]
src_image(mut self, src_image: Image) -> Self52442     pub fn src_image(mut self, src_image: Image) -> Self {
52443         self.inner.src_image = src_image;
52444         self
52445     }
52446     #[inline]
src_image_layout(mut self, src_image_layout: ImageLayout) -> Self52447     pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self {
52448         self.inner.src_image_layout = src_image_layout;
52449         self
52450     }
52451     #[inline]
dst_image(mut self, dst_image: Image) -> Self52452     pub fn dst_image(mut self, dst_image: Image) -> Self {
52453         self.inner.dst_image = dst_image;
52454         self
52455     }
52456     #[inline]
dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self52457     pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self {
52458         self.inner.dst_image_layout = dst_image_layout;
52459         self
52460     }
52461     #[inline]
regions(mut self, regions: &'a [ImageResolve2]) -> Self52462     pub fn regions(mut self, regions: &'a [ImageResolve2]) -> Self {
52463         self.inner.region_count = regions.len() as _;
52464         self.inner.p_regions = regions.as_ptr();
52465         self
52466     }
52467     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52468     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52469     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ResolveImageInfo252470     pub fn build(self) -> ResolveImageInfo2 {
52471         self.inner
52472     }
52473 }
52474 #[repr(C)]
52475 #[cfg_attr(feature = "debug", derive(Debug))]
52476 #[derive(Copy, Clone)]
52477 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT.html>"]
52478 pub struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
52479     pub s_type: StructureType,
52480     pub p_next: *mut c_void,
52481     pub shader_image_int64_atomics: Bool32,
52482     pub sparse_image_int64_atomics: Bool32,
52483 }
52484 impl ::std::default::Default for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
52485     #[inline]
default() -> Self52486     fn default() -> Self {
52487         Self {
52488             s_type: Self::STRUCTURE_TYPE,
52489             p_next: ::std::ptr::null_mut(),
52490             shader_image_int64_atomics: Bool32::default(),
52491             sparse_image_int64_atomics: Bool32::default(),
52492         }
52493     }
52494 }
52495 unsafe impl TaggedStructure for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
52496     const STRUCTURE_TYPE: StructureType =
52497         StructureType::PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
52498 }
52499 impl PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
builder<'a>() -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a>52500     pub fn builder<'a>() -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
52501         PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder {
52502             inner: Self::default(),
52503             marker: ::std::marker::PhantomData,
52504         }
52505     }
52506 }
52507 #[repr(transparent)]
52508 pub struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
52509     inner: PhysicalDeviceShaderImageAtomicInt64FeaturesEXT,
52510     marker: ::std::marker::PhantomData<&'a ()>,
52511 }
52512 unsafe impl ExtendsPhysicalDeviceFeatures2
52513     for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'_>
52514 {
52515 }
52516 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {}
52517 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'_> {}
52518 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {}
52519 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
52520     type Target = PhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
deref(&self) -> &Self::Target52521     fn deref(&self) -> &Self::Target {
52522         &self.inner
52523     }
52524 }
52525 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target52526     fn deref_mut(&mut self) -> &mut Self::Target {
52527         &mut self.inner
52528     }
52529 }
52530 impl<'a> PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
52531     #[inline]
shader_image_int64_atomics(mut self, shader_image_int64_atomics: bool) -> Self52532     pub fn shader_image_int64_atomics(mut self, shader_image_int64_atomics: bool) -> Self {
52533         self.inner.shader_image_int64_atomics = shader_image_int64_atomics.into();
52534         self
52535     }
52536     #[inline]
sparse_image_int64_atomics(mut self, sparse_image_int64_atomics: bool) -> Self52537     pub fn sparse_image_int64_atomics(mut self, sparse_image_int64_atomics: bool) -> Self {
52538         self.inner.sparse_image_int64_atomics = sparse_image_int64_atomics.into();
52539         self
52540     }
52541     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52542     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52543     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXT52544     pub fn build(self) -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
52545         self.inner
52546     }
52547 }
52548 #[repr(C)]
52549 #[cfg_attr(feature = "debug", derive(Debug))]
52550 #[derive(Copy, Clone)]
52551 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFragmentShadingRateAttachmentInfoKHR.html>"]
52552 pub struct FragmentShadingRateAttachmentInfoKHR {
52553     pub s_type: StructureType,
52554     pub p_next: *const c_void,
52555     pub p_fragment_shading_rate_attachment: *const AttachmentReference2,
52556     pub shading_rate_attachment_texel_size: Extent2D,
52557 }
52558 impl ::std::default::Default for FragmentShadingRateAttachmentInfoKHR {
52559     #[inline]
default() -> Self52560     fn default() -> Self {
52561         Self {
52562             s_type: Self::STRUCTURE_TYPE,
52563             p_next: ::std::ptr::null(),
52564             p_fragment_shading_rate_attachment: ::std::ptr::null(),
52565             shading_rate_attachment_texel_size: Extent2D::default(),
52566         }
52567     }
52568 }
52569 unsafe impl TaggedStructure for FragmentShadingRateAttachmentInfoKHR {
52570     const STRUCTURE_TYPE: StructureType = StructureType::FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR;
52571 }
52572 impl FragmentShadingRateAttachmentInfoKHR {
builder<'a>() -> FragmentShadingRateAttachmentInfoKHRBuilder<'a>52573     pub fn builder<'a>() -> FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
52574         FragmentShadingRateAttachmentInfoKHRBuilder {
52575             inner: Self::default(),
52576             marker: ::std::marker::PhantomData,
52577         }
52578     }
52579 }
52580 #[repr(transparent)]
52581 pub struct FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
52582     inner: FragmentShadingRateAttachmentInfoKHR,
52583     marker: ::std::marker::PhantomData<&'a ()>,
52584 }
52585 unsafe impl ExtendsSubpassDescription2 for FragmentShadingRateAttachmentInfoKHRBuilder<'_> {}
52586 unsafe impl ExtendsSubpassDescription2 for FragmentShadingRateAttachmentInfoKHR {}
52587 impl<'a> ::std::ops::Deref for FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
52588     type Target = FragmentShadingRateAttachmentInfoKHR;
deref(&self) -> &Self::Target52589     fn deref(&self) -> &Self::Target {
52590         &self.inner
52591     }
52592 }
52593 impl<'a> ::std::ops::DerefMut for FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target52594     fn deref_mut(&mut self) -> &mut Self::Target {
52595         &mut self.inner
52596     }
52597 }
52598 impl<'a> FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
52599     #[inline]
fragment_shading_rate_attachment( mut self, fragment_shading_rate_attachment: &'a AttachmentReference2, ) -> Self52600     pub fn fragment_shading_rate_attachment(
52601         mut self,
52602         fragment_shading_rate_attachment: &'a AttachmentReference2,
52603     ) -> Self {
52604         self.inner.p_fragment_shading_rate_attachment = fragment_shading_rate_attachment;
52605         self
52606     }
52607     #[inline]
shading_rate_attachment_texel_size( mut self, shading_rate_attachment_texel_size: Extent2D, ) -> Self52608     pub fn shading_rate_attachment_texel_size(
52609         mut self,
52610         shading_rate_attachment_texel_size: Extent2D,
52611     ) -> Self {
52612         self.inner.shading_rate_attachment_texel_size = shading_rate_attachment_texel_size;
52613         self
52614     }
52615     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52616     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52617     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> FragmentShadingRateAttachmentInfoKHR52618     pub fn build(self) -> FragmentShadingRateAttachmentInfoKHR {
52619         self.inner
52620     }
52621 }
52622 #[repr(C)]
52623 #[cfg_attr(feature = "debug", derive(Debug))]
52624 #[derive(Copy, Clone)]
52625 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineFragmentShadingRateStateCreateInfoKHR.html>"]
52626 pub struct PipelineFragmentShadingRateStateCreateInfoKHR {
52627     pub s_type: StructureType,
52628     pub p_next: *const c_void,
52629     pub fragment_size: Extent2D,
52630     pub combiner_ops: [FragmentShadingRateCombinerOpKHR; 2],
52631 }
52632 impl ::std::default::Default for PipelineFragmentShadingRateStateCreateInfoKHR {
52633     #[inline]
default() -> Self52634     fn default() -> Self {
52635         Self {
52636             s_type: Self::STRUCTURE_TYPE,
52637             p_next: ::std::ptr::null(),
52638             fragment_size: Extent2D::default(),
52639             combiner_ops: unsafe { ::std::mem::zeroed() },
52640         }
52641     }
52642 }
52643 unsafe impl TaggedStructure for PipelineFragmentShadingRateStateCreateInfoKHR {
52644     const STRUCTURE_TYPE: StructureType =
52645         StructureType::PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR;
52646 }
52647 impl PipelineFragmentShadingRateStateCreateInfoKHR {
builder<'a>() -> PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a>52648     pub fn builder<'a>() -> PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
52649         PipelineFragmentShadingRateStateCreateInfoKHRBuilder {
52650             inner: Self::default(),
52651             marker: ::std::marker::PhantomData,
52652         }
52653     }
52654 }
52655 #[repr(transparent)]
52656 pub struct PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
52657     inner: PipelineFragmentShadingRateStateCreateInfoKHR,
52658     marker: ::std::marker::PhantomData<&'a ()>,
52659 }
52660 unsafe impl ExtendsGraphicsPipelineCreateInfo
52661     for PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'_>
52662 {
52663 }
52664 unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineFragmentShadingRateStateCreateInfoKHR {}
52665 impl<'a> ::std::ops::Deref for PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
52666     type Target = PipelineFragmentShadingRateStateCreateInfoKHR;
deref(&self) -> &Self::Target52667     fn deref(&self) -> &Self::Target {
52668         &self.inner
52669     }
52670 }
52671 impl<'a> ::std::ops::DerefMut for PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target52672     fn deref_mut(&mut self) -> &mut Self::Target {
52673         &mut self.inner
52674     }
52675 }
52676 impl<'a> PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
52677     #[inline]
fragment_size(mut self, fragment_size: Extent2D) -> Self52678     pub fn fragment_size(mut self, fragment_size: Extent2D) -> Self {
52679         self.inner.fragment_size = fragment_size;
52680         self
52681     }
52682     #[inline]
combiner_ops(mut self, combiner_ops: [FragmentShadingRateCombinerOpKHR; 2]) -> Self52683     pub fn combiner_ops(mut self, combiner_ops: [FragmentShadingRateCombinerOpKHR; 2]) -> Self {
52684         self.inner.combiner_ops = combiner_ops;
52685         self
52686     }
52687     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52688     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52689     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineFragmentShadingRateStateCreateInfoKHR52690     pub fn build(self) -> PipelineFragmentShadingRateStateCreateInfoKHR {
52691         self.inner
52692     }
52693 }
52694 #[repr(C)]
52695 #[cfg_attr(feature = "debug", derive(Debug))]
52696 #[derive(Copy, Clone)]
52697 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShadingRateFeaturesKHR.html>"]
52698 pub struct PhysicalDeviceFragmentShadingRateFeaturesKHR {
52699     pub s_type: StructureType,
52700     pub p_next: *mut c_void,
52701     pub pipeline_fragment_shading_rate: Bool32,
52702     pub primitive_fragment_shading_rate: Bool32,
52703     pub attachment_fragment_shading_rate: Bool32,
52704 }
52705 impl ::std::default::Default for PhysicalDeviceFragmentShadingRateFeaturesKHR {
52706     #[inline]
default() -> Self52707     fn default() -> Self {
52708         Self {
52709             s_type: Self::STRUCTURE_TYPE,
52710             p_next: ::std::ptr::null_mut(),
52711             pipeline_fragment_shading_rate: Bool32::default(),
52712             primitive_fragment_shading_rate: Bool32::default(),
52713             attachment_fragment_shading_rate: Bool32::default(),
52714         }
52715     }
52716 }
52717 unsafe impl TaggedStructure for PhysicalDeviceFragmentShadingRateFeaturesKHR {
52718     const STRUCTURE_TYPE: StructureType =
52719         StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
52720 }
52721 impl PhysicalDeviceFragmentShadingRateFeaturesKHR {
builder<'a>() -> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a>52722     pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
52723         PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder {
52724             inner: Self::default(),
52725             marker: ::std::marker::PhantomData,
52726         }
52727     }
52728 }
52729 #[repr(transparent)]
52730 pub struct PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
52731     inner: PhysicalDeviceFragmentShadingRateFeaturesKHR,
52732     marker: ::std::marker::PhantomData<&'a ()>,
52733 }
52734 unsafe impl ExtendsPhysicalDeviceFeatures2
52735     for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'_>
52736 {
52737 }
52738 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShadingRateFeaturesKHR {}
52739 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'_> {}
52740 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateFeaturesKHR {}
52741 impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
52742     type Target = PhysicalDeviceFragmentShadingRateFeaturesKHR;
deref(&self) -> &Self::Target52743     fn deref(&self) -> &Self::Target {
52744         &self.inner
52745     }
52746 }
52747 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target52748     fn deref_mut(&mut self) -> &mut Self::Target {
52749         &mut self.inner
52750     }
52751 }
52752 impl<'a> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
52753     #[inline]
pipeline_fragment_shading_rate(mut self, pipeline_fragment_shading_rate: bool) -> Self52754     pub fn pipeline_fragment_shading_rate(mut self, pipeline_fragment_shading_rate: bool) -> Self {
52755         self.inner.pipeline_fragment_shading_rate = pipeline_fragment_shading_rate.into();
52756         self
52757     }
52758     #[inline]
primitive_fragment_shading_rate( mut self, primitive_fragment_shading_rate: bool, ) -> Self52759     pub fn primitive_fragment_shading_rate(
52760         mut self,
52761         primitive_fragment_shading_rate: bool,
52762     ) -> Self {
52763         self.inner.primitive_fragment_shading_rate = primitive_fragment_shading_rate.into();
52764         self
52765     }
52766     #[inline]
attachment_fragment_shading_rate( mut self, attachment_fragment_shading_rate: bool, ) -> Self52767     pub fn attachment_fragment_shading_rate(
52768         mut self,
52769         attachment_fragment_shading_rate: bool,
52770     ) -> Self {
52771         self.inner.attachment_fragment_shading_rate = attachment_fragment_shading_rate.into();
52772         self
52773     }
52774     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52775     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52776     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFragmentShadingRateFeaturesKHR52777     pub fn build(self) -> PhysicalDeviceFragmentShadingRateFeaturesKHR {
52778         self.inner
52779     }
52780 }
52781 #[repr(C)]
52782 #[cfg_attr(feature = "debug", derive(Debug))]
52783 #[derive(Copy, Clone)]
52784 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShadingRatePropertiesKHR.html>"]
52785 pub struct PhysicalDeviceFragmentShadingRatePropertiesKHR {
52786     pub s_type: StructureType,
52787     pub p_next: *mut c_void,
52788     pub min_fragment_shading_rate_attachment_texel_size: Extent2D,
52789     pub max_fragment_shading_rate_attachment_texel_size: Extent2D,
52790     pub max_fragment_shading_rate_attachment_texel_size_aspect_ratio: u32,
52791     pub primitive_fragment_shading_rate_with_multiple_viewports: Bool32,
52792     pub layered_shading_rate_attachments: Bool32,
52793     pub fragment_shading_rate_non_trivial_combiner_ops: Bool32,
52794     pub max_fragment_size: Extent2D,
52795     pub max_fragment_size_aspect_ratio: u32,
52796     pub max_fragment_shading_rate_coverage_samples: u32,
52797     pub max_fragment_shading_rate_rasterization_samples: SampleCountFlags,
52798     pub fragment_shading_rate_with_shader_depth_stencil_writes: Bool32,
52799     pub fragment_shading_rate_with_sample_mask: Bool32,
52800     pub fragment_shading_rate_with_shader_sample_mask: Bool32,
52801     pub fragment_shading_rate_with_conservative_rasterization: Bool32,
52802     pub fragment_shading_rate_with_fragment_shader_interlock: Bool32,
52803     pub fragment_shading_rate_with_custom_sample_locations: Bool32,
52804     pub fragment_shading_rate_strict_multiply_combiner: Bool32,
52805 }
52806 impl ::std::default::Default for PhysicalDeviceFragmentShadingRatePropertiesKHR {
52807     #[inline]
default() -> Self52808     fn default() -> Self {
52809         Self {
52810             s_type: Self::STRUCTURE_TYPE,
52811             p_next: ::std::ptr::null_mut(),
52812             min_fragment_shading_rate_attachment_texel_size: Extent2D::default(),
52813             max_fragment_shading_rate_attachment_texel_size: Extent2D::default(),
52814             max_fragment_shading_rate_attachment_texel_size_aspect_ratio: u32::default(),
52815             primitive_fragment_shading_rate_with_multiple_viewports: Bool32::default(),
52816             layered_shading_rate_attachments: Bool32::default(),
52817             fragment_shading_rate_non_trivial_combiner_ops: Bool32::default(),
52818             max_fragment_size: Extent2D::default(),
52819             max_fragment_size_aspect_ratio: u32::default(),
52820             max_fragment_shading_rate_coverage_samples: u32::default(),
52821             max_fragment_shading_rate_rasterization_samples: SampleCountFlags::default(),
52822             fragment_shading_rate_with_shader_depth_stencil_writes: Bool32::default(),
52823             fragment_shading_rate_with_sample_mask: Bool32::default(),
52824             fragment_shading_rate_with_shader_sample_mask: Bool32::default(),
52825             fragment_shading_rate_with_conservative_rasterization: Bool32::default(),
52826             fragment_shading_rate_with_fragment_shader_interlock: Bool32::default(),
52827             fragment_shading_rate_with_custom_sample_locations: Bool32::default(),
52828             fragment_shading_rate_strict_multiply_combiner: Bool32::default(),
52829         }
52830     }
52831 }
52832 unsafe impl TaggedStructure for PhysicalDeviceFragmentShadingRatePropertiesKHR {
52833     const STRUCTURE_TYPE: StructureType =
52834         StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR;
52835 }
52836 impl PhysicalDeviceFragmentShadingRatePropertiesKHR {
builder<'a>() -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a>52837     pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
52838         PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder {
52839             inner: Self::default(),
52840             marker: ::std::marker::PhantomData,
52841         }
52842     }
52843 }
52844 #[repr(transparent)]
52845 pub struct PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
52846     inner: PhysicalDeviceFragmentShadingRatePropertiesKHR,
52847     marker: ::std::marker::PhantomData<&'a ()>,
52848 }
52849 unsafe impl ExtendsPhysicalDeviceProperties2
52850     for PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'_>
52851 {
52852 }
52853 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentShadingRatePropertiesKHR {}
52854 impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
52855     type Target = PhysicalDeviceFragmentShadingRatePropertiesKHR;
deref(&self) -> &Self::Target52856     fn deref(&self) -> &Self::Target {
52857         &self.inner
52858     }
52859 }
52860 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target52861     fn deref_mut(&mut self) -> &mut Self::Target {
52862         &mut self.inner
52863     }
52864 }
52865 impl<'a> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
52866     #[inline]
min_fragment_shading_rate_attachment_texel_size( mut self, min_fragment_shading_rate_attachment_texel_size: Extent2D, ) -> Self52867     pub fn min_fragment_shading_rate_attachment_texel_size(
52868         mut self,
52869         min_fragment_shading_rate_attachment_texel_size: Extent2D,
52870     ) -> Self {
52871         self.inner.min_fragment_shading_rate_attachment_texel_size =
52872             min_fragment_shading_rate_attachment_texel_size;
52873         self
52874     }
52875     #[inline]
max_fragment_shading_rate_attachment_texel_size( mut self, max_fragment_shading_rate_attachment_texel_size: Extent2D, ) -> Self52876     pub fn max_fragment_shading_rate_attachment_texel_size(
52877         mut self,
52878         max_fragment_shading_rate_attachment_texel_size: Extent2D,
52879     ) -> Self {
52880         self.inner.max_fragment_shading_rate_attachment_texel_size =
52881             max_fragment_shading_rate_attachment_texel_size;
52882         self
52883     }
52884     #[inline]
max_fragment_shading_rate_attachment_texel_size_aspect_ratio( mut self, max_fragment_shading_rate_attachment_texel_size_aspect_ratio: u32, ) -> Self52885     pub fn max_fragment_shading_rate_attachment_texel_size_aspect_ratio(
52886         mut self,
52887         max_fragment_shading_rate_attachment_texel_size_aspect_ratio: u32,
52888     ) -> Self {
52889         self.inner
52890             .max_fragment_shading_rate_attachment_texel_size_aspect_ratio =
52891             max_fragment_shading_rate_attachment_texel_size_aspect_ratio;
52892         self
52893     }
52894     #[inline]
primitive_fragment_shading_rate_with_multiple_viewports( mut self, primitive_fragment_shading_rate_with_multiple_viewports: bool, ) -> Self52895     pub fn primitive_fragment_shading_rate_with_multiple_viewports(
52896         mut self,
52897         primitive_fragment_shading_rate_with_multiple_viewports: bool,
52898     ) -> Self {
52899         self.inner
52900             .primitive_fragment_shading_rate_with_multiple_viewports =
52901             primitive_fragment_shading_rate_with_multiple_viewports.into();
52902         self
52903     }
52904     #[inline]
layered_shading_rate_attachments( mut self, layered_shading_rate_attachments: bool, ) -> Self52905     pub fn layered_shading_rate_attachments(
52906         mut self,
52907         layered_shading_rate_attachments: bool,
52908     ) -> Self {
52909         self.inner.layered_shading_rate_attachments = layered_shading_rate_attachments.into();
52910         self
52911     }
52912     #[inline]
fragment_shading_rate_non_trivial_combiner_ops( mut self, fragment_shading_rate_non_trivial_combiner_ops: bool, ) -> Self52913     pub fn fragment_shading_rate_non_trivial_combiner_ops(
52914         mut self,
52915         fragment_shading_rate_non_trivial_combiner_ops: bool,
52916     ) -> Self {
52917         self.inner.fragment_shading_rate_non_trivial_combiner_ops =
52918             fragment_shading_rate_non_trivial_combiner_ops.into();
52919         self
52920     }
52921     #[inline]
max_fragment_size(mut self, max_fragment_size: Extent2D) -> Self52922     pub fn max_fragment_size(mut self, max_fragment_size: Extent2D) -> Self {
52923         self.inner.max_fragment_size = max_fragment_size;
52924         self
52925     }
52926     #[inline]
max_fragment_size_aspect_ratio(mut self, max_fragment_size_aspect_ratio: u32) -> Self52927     pub fn max_fragment_size_aspect_ratio(mut self, max_fragment_size_aspect_ratio: u32) -> Self {
52928         self.inner.max_fragment_size_aspect_ratio = max_fragment_size_aspect_ratio;
52929         self
52930     }
52931     #[inline]
max_fragment_shading_rate_coverage_samples( mut self, max_fragment_shading_rate_coverage_samples: u32, ) -> Self52932     pub fn max_fragment_shading_rate_coverage_samples(
52933         mut self,
52934         max_fragment_shading_rate_coverage_samples: u32,
52935     ) -> Self {
52936         self.inner.max_fragment_shading_rate_coverage_samples =
52937             max_fragment_shading_rate_coverage_samples;
52938         self
52939     }
52940     #[inline]
max_fragment_shading_rate_rasterization_samples( mut self, max_fragment_shading_rate_rasterization_samples: SampleCountFlags, ) -> Self52941     pub fn max_fragment_shading_rate_rasterization_samples(
52942         mut self,
52943         max_fragment_shading_rate_rasterization_samples: SampleCountFlags,
52944     ) -> Self {
52945         self.inner.max_fragment_shading_rate_rasterization_samples =
52946             max_fragment_shading_rate_rasterization_samples;
52947         self
52948     }
52949     #[inline]
fragment_shading_rate_with_shader_depth_stencil_writes( mut self, fragment_shading_rate_with_shader_depth_stencil_writes: bool, ) -> Self52950     pub fn fragment_shading_rate_with_shader_depth_stencil_writes(
52951         mut self,
52952         fragment_shading_rate_with_shader_depth_stencil_writes: bool,
52953     ) -> Self {
52954         self.inner
52955             .fragment_shading_rate_with_shader_depth_stencil_writes =
52956             fragment_shading_rate_with_shader_depth_stencil_writes.into();
52957         self
52958     }
52959     #[inline]
fragment_shading_rate_with_sample_mask( mut self, fragment_shading_rate_with_sample_mask: bool, ) -> Self52960     pub fn fragment_shading_rate_with_sample_mask(
52961         mut self,
52962         fragment_shading_rate_with_sample_mask: bool,
52963     ) -> Self {
52964         self.inner.fragment_shading_rate_with_sample_mask =
52965             fragment_shading_rate_with_sample_mask.into();
52966         self
52967     }
52968     #[inline]
fragment_shading_rate_with_shader_sample_mask( mut self, fragment_shading_rate_with_shader_sample_mask: bool, ) -> Self52969     pub fn fragment_shading_rate_with_shader_sample_mask(
52970         mut self,
52971         fragment_shading_rate_with_shader_sample_mask: bool,
52972     ) -> Self {
52973         self.inner.fragment_shading_rate_with_shader_sample_mask =
52974             fragment_shading_rate_with_shader_sample_mask.into();
52975         self
52976     }
52977     #[inline]
fragment_shading_rate_with_conservative_rasterization( mut self, fragment_shading_rate_with_conservative_rasterization: bool, ) -> Self52978     pub fn fragment_shading_rate_with_conservative_rasterization(
52979         mut self,
52980         fragment_shading_rate_with_conservative_rasterization: bool,
52981     ) -> Self {
52982         self.inner
52983             .fragment_shading_rate_with_conservative_rasterization =
52984             fragment_shading_rate_with_conservative_rasterization.into();
52985         self
52986     }
52987     #[inline]
fragment_shading_rate_with_fragment_shader_interlock( mut self, fragment_shading_rate_with_fragment_shader_interlock: bool, ) -> Self52988     pub fn fragment_shading_rate_with_fragment_shader_interlock(
52989         mut self,
52990         fragment_shading_rate_with_fragment_shader_interlock: bool,
52991     ) -> Self {
52992         self.inner
52993             .fragment_shading_rate_with_fragment_shader_interlock =
52994             fragment_shading_rate_with_fragment_shader_interlock.into();
52995         self
52996     }
52997     #[inline]
fragment_shading_rate_with_custom_sample_locations( mut self, fragment_shading_rate_with_custom_sample_locations: bool, ) -> Self52998     pub fn fragment_shading_rate_with_custom_sample_locations(
52999         mut self,
53000         fragment_shading_rate_with_custom_sample_locations: bool,
53001     ) -> Self {
53002         self.inner
53003             .fragment_shading_rate_with_custom_sample_locations =
53004             fragment_shading_rate_with_custom_sample_locations.into();
53005         self
53006     }
53007     #[inline]
fragment_shading_rate_strict_multiply_combiner( mut self, fragment_shading_rate_strict_multiply_combiner: bool, ) -> Self53008     pub fn fragment_shading_rate_strict_multiply_combiner(
53009         mut self,
53010         fragment_shading_rate_strict_multiply_combiner: bool,
53011     ) -> Self {
53012         self.inner.fragment_shading_rate_strict_multiply_combiner =
53013             fragment_shading_rate_strict_multiply_combiner.into();
53014         self
53015     }
53016     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53017     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53018     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFragmentShadingRatePropertiesKHR53019     pub fn build(self) -> PhysicalDeviceFragmentShadingRatePropertiesKHR {
53020         self.inner
53021     }
53022 }
53023 #[repr(C)]
53024 #[cfg_attr(feature = "debug", derive(Debug))]
53025 #[derive(Copy, Clone)]
53026 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShadingRateKHR.html>"]
53027 pub struct PhysicalDeviceFragmentShadingRateKHR {
53028     pub s_type: StructureType,
53029     pub p_next: *mut c_void,
53030     pub sample_counts: SampleCountFlags,
53031     pub fragment_size: Extent2D,
53032 }
53033 impl ::std::default::Default for PhysicalDeviceFragmentShadingRateKHR {
53034     #[inline]
default() -> Self53035     fn default() -> Self {
53036         Self {
53037             s_type: Self::STRUCTURE_TYPE,
53038             p_next: ::std::ptr::null_mut(),
53039             sample_counts: SampleCountFlags::default(),
53040             fragment_size: Extent2D::default(),
53041         }
53042     }
53043 }
53044 unsafe impl TaggedStructure for PhysicalDeviceFragmentShadingRateKHR {
53045     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR;
53046 }
53047 impl PhysicalDeviceFragmentShadingRateKHR {
builder<'a>() -> PhysicalDeviceFragmentShadingRateKHRBuilder<'a>53048     pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
53049         PhysicalDeviceFragmentShadingRateKHRBuilder {
53050             inner: Self::default(),
53051             marker: ::std::marker::PhantomData,
53052         }
53053     }
53054 }
53055 #[repr(transparent)]
53056 pub struct PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
53057     inner: PhysicalDeviceFragmentShadingRateKHR,
53058     marker: ::std::marker::PhantomData<&'a ()>,
53059 }
53060 impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
53061     type Target = PhysicalDeviceFragmentShadingRateKHR;
deref(&self) -> &Self::Target53062     fn deref(&self) -> &Self::Target {
53063         &self.inner
53064     }
53065 }
53066 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target53067     fn deref_mut(&mut self) -> &mut Self::Target {
53068         &mut self.inner
53069     }
53070 }
53071 impl<'a> PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
53072     #[inline]
sample_counts(mut self, sample_counts: SampleCountFlags) -> Self53073     pub fn sample_counts(mut self, sample_counts: SampleCountFlags) -> Self {
53074         self.inner.sample_counts = sample_counts;
53075         self
53076     }
53077     #[inline]
fragment_size(mut self, fragment_size: Extent2D) -> Self53078     pub fn fragment_size(mut self, fragment_size: Extent2D) -> Self {
53079         self.inner.fragment_size = fragment_size;
53080         self
53081     }
53082     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53083     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53084     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFragmentShadingRateKHR53085     pub fn build(self) -> PhysicalDeviceFragmentShadingRateKHR {
53086         self.inner
53087     }
53088 }
53089 #[repr(C)]
53090 #[cfg_attr(feature = "debug", derive(Debug))]
53091 #[derive(Copy, Clone)]
53092 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderTerminateInvocationFeatures.html>"]
53093 pub struct PhysicalDeviceShaderTerminateInvocationFeatures {
53094     pub s_type: StructureType,
53095     pub p_next: *mut c_void,
53096     pub shader_terminate_invocation: Bool32,
53097 }
53098 impl ::std::default::Default for PhysicalDeviceShaderTerminateInvocationFeatures {
53099     #[inline]
default() -> Self53100     fn default() -> Self {
53101         Self {
53102             s_type: Self::STRUCTURE_TYPE,
53103             p_next: ::std::ptr::null_mut(),
53104             shader_terminate_invocation: Bool32::default(),
53105         }
53106     }
53107 }
53108 unsafe impl TaggedStructure for PhysicalDeviceShaderTerminateInvocationFeatures {
53109     const STRUCTURE_TYPE: StructureType =
53110         StructureType::PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
53111 }
53112 impl PhysicalDeviceShaderTerminateInvocationFeatures {
builder<'a>() -> PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a>53113     pub fn builder<'a>() -> PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> {
53114         PhysicalDeviceShaderTerminateInvocationFeaturesBuilder {
53115             inner: Self::default(),
53116             marker: ::std::marker::PhantomData,
53117         }
53118     }
53119 }
53120 #[repr(transparent)]
53121 pub struct PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> {
53122     inner: PhysicalDeviceShaderTerminateInvocationFeatures,
53123     marker: ::std::marker::PhantomData<&'a ()>,
53124 }
53125 unsafe impl ExtendsPhysicalDeviceFeatures2
53126     for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'_>
53127 {
53128 }
53129 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderTerminateInvocationFeatures {}
53130 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'_> {}
53131 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderTerminateInvocationFeatures {}
53132 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> {
53133     type Target = PhysicalDeviceShaderTerminateInvocationFeatures;
deref(&self) -> &Self::Target53134     fn deref(&self) -> &Self::Target {
53135         &self.inner
53136     }
53137 }
53138 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target53139     fn deref_mut(&mut self) -> &mut Self::Target {
53140         &mut self.inner
53141     }
53142 }
53143 impl<'a> PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> {
53144     #[inline]
shader_terminate_invocation(mut self, shader_terminate_invocation: bool) -> Self53145     pub fn shader_terminate_invocation(mut self, shader_terminate_invocation: bool) -> Self {
53146         self.inner.shader_terminate_invocation = shader_terminate_invocation.into();
53147         self
53148     }
53149     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53150     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53151     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderTerminateInvocationFeatures53152     pub fn build(self) -> PhysicalDeviceShaderTerminateInvocationFeatures {
53153         self.inner
53154     }
53155 }
53156 #[repr(C)]
53157 #[cfg_attr(feature = "debug", derive(Debug))]
53158 #[derive(Copy, Clone)]
53159 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV.html>"]
53160 pub struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
53161     pub s_type: StructureType,
53162     pub p_next: *mut c_void,
53163     pub fragment_shading_rate_enums: Bool32,
53164     pub supersample_fragment_shading_rates: Bool32,
53165     pub no_invocation_fragment_shading_rates: Bool32,
53166 }
53167 impl ::std::default::Default for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
53168     #[inline]
default() -> Self53169     fn default() -> Self {
53170         Self {
53171             s_type: Self::STRUCTURE_TYPE,
53172             p_next: ::std::ptr::null_mut(),
53173             fragment_shading_rate_enums: Bool32::default(),
53174             supersample_fragment_shading_rates: Bool32::default(),
53175             no_invocation_fragment_shading_rates: Bool32::default(),
53176         }
53177     }
53178 }
53179 unsafe impl TaggedStructure for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
53180     const STRUCTURE_TYPE: StructureType =
53181         StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
53182 }
53183 impl PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
builder<'a>() -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a>53184     pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
53185         PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder {
53186             inner: Self::default(),
53187             marker: ::std::marker::PhantomData,
53188         }
53189     }
53190 }
53191 #[repr(transparent)]
53192 pub struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
53193     inner: PhysicalDeviceFragmentShadingRateEnumsFeaturesNV,
53194     marker: ::std::marker::PhantomData<&'a ()>,
53195 }
53196 unsafe impl ExtendsPhysicalDeviceFeatures2
53197     for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'_>
53198 {
53199 }
53200 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {}
53201 unsafe impl ExtendsDeviceCreateInfo
53202     for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'_>
53203 {
53204 }
53205 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {}
53206 impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
53207     type Target = PhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
deref(&self) -> &Self::Target53208     fn deref(&self) -> &Self::Target {
53209         &self.inner
53210     }
53211 }
53212 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target53213     fn deref_mut(&mut self) -> &mut Self::Target {
53214         &mut self.inner
53215     }
53216 }
53217 impl<'a> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
53218     #[inline]
fragment_shading_rate_enums(mut self, fragment_shading_rate_enums: bool) -> Self53219     pub fn fragment_shading_rate_enums(mut self, fragment_shading_rate_enums: bool) -> Self {
53220         self.inner.fragment_shading_rate_enums = fragment_shading_rate_enums.into();
53221         self
53222     }
53223     #[inline]
supersample_fragment_shading_rates( mut self, supersample_fragment_shading_rates: bool, ) -> Self53224     pub fn supersample_fragment_shading_rates(
53225         mut self,
53226         supersample_fragment_shading_rates: bool,
53227     ) -> Self {
53228         self.inner.supersample_fragment_shading_rates = supersample_fragment_shading_rates.into();
53229         self
53230     }
53231     #[inline]
no_invocation_fragment_shading_rates( mut self, no_invocation_fragment_shading_rates: bool, ) -> Self53232     pub fn no_invocation_fragment_shading_rates(
53233         mut self,
53234         no_invocation_fragment_shading_rates: bool,
53235     ) -> Self {
53236         self.inner.no_invocation_fragment_shading_rates =
53237             no_invocation_fragment_shading_rates.into();
53238         self
53239     }
53240     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53241     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53242     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNV53243     pub fn build(self) -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
53244         self.inner
53245     }
53246 }
53247 #[repr(C)]
53248 #[cfg_attr(feature = "debug", derive(Debug))]
53249 #[derive(Copy, Clone)]
53250 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV.html>"]
53251 pub struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
53252     pub s_type: StructureType,
53253     pub p_next: *mut c_void,
53254     pub max_fragment_shading_rate_invocation_count: SampleCountFlags,
53255 }
53256 impl ::std::default::Default for PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
53257     #[inline]
default() -> Self53258     fn default() -> Self {
53259         Self {
53260             s_type: Self::STRUCTURE_TYPE,
53261             p_next: ::std::ptr::null_mut(),
53262             max_fragment_shading_rate_invocation_count: SampleCountFlags::default(),
53263         }
53264     }
53265 }
53266 unsafe impl TaggedStructure for PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
53267     const STRUCTURE_TYPE: StructureType =
53268         StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV;
53269 }
53270 impl PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
builder<'a>() -> PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a>53271     pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> {
53272         PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder {
53273             inner: Self::default(),
53274             marker: ::std::marker::PhantomData,
53275         }
53276     }
53277 }
53278 #[repr(transparent)]
53279 pub struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> {
53280     inner: PhysicalDeviceFragmentShadingRateEnumsPropertiesNV,
53281     marker: ::std::marker::PhantomData<&'a ()>,
53282 }
53283 unsafe impl ExtendsPhysicalDeviceProperties2
53284     for PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'_>
53285 {
53286 }
53287 unsafe impl ExtendsPhysicalDeviceProperties2
53288     for PhysicalDeviceFragmentShadingRateEnumsPropertiesNV
53289 {
53290 }
53291 impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> {
53292     type Target = PhysicalDeviceFragmentShadingRateEnumsPropertiesNV;
deref(&self) -> &Self::Target53293     fn deref(&self) -> &Self::Target {
53294         &self.inner
53295     }
53296 }
53297 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target53298     fn deref_mut(&mut self) -> &mut Self::Target {
53299         &mut self.inner
53300     }
53301 }
53302 impl<'a> PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> {
53303     #[inline]
max_fragment_shading_rate_invocation_count( mut self, max_fragment_shading_rate_invocation_count: SampleCountFlags, ) -> Self53304     pub fn max_fragment_shading_rate_invocation_count(
53305         mut self,
53306         max_fragment_shading_rate_invocation_count: SampleCountFlags,
53307     ) -> Self {
53308         self.inner.max_fragment_shading_rate_invocation_count =
53309             max_fragment_shading_rate_invocation_count;
53310         self
53311     }
53312     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53313     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53314     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFragmentShadingRateEnumsPropertiesNV53315     pub fn build(self) -> PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
53316         self.inner
53317     }
53318 }
53319 #[repr(C)]
53320 #[cfg_attr(feature = "debug", derive(Debug))]
53321 #[derive(Copy, Clone)]
53322 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineFragmentShadingRateEnumStateCreateInfoNV.html>"]
53323 pub struct PipelineFragmentShadingRateEnumStateCreateInfoNV {
53324     pub s_type: StructureType,
53325     pub p_next: *const c_void,
53326     pub shading_rate_type: FragmentShadingRateTypeNV,
53327     pub shading_rate: FragmentShadingRateNV,
53328     pub combiner_ops: [FragmentShadingRateCombinerOpKHR; 2],
53329 }
53330 impl ::std::default::Default for PipelineFragmentShadingRateEnumStateCreateInfoNV {
53331     #[inline]
default() -> Self53332     fn default() -> Self {
53333         Self {
53334             s_type: Self::STRUCTURE_TYPE,
53335             p_next: ::std::ptr::null(),
53336             shading_rate_type: FragmentShadingRateTypeNV::default(),
53337             shading_rate: FragmentShadingRateNV::default(),
53338             combiner_ops: unsafe { ::std::mem::zeroed() },
53339         }
53340     }
53341 }
53342 unsafe impl TaggedStructure for PipelineFragmentShadingRateEnumStateCreateInfoNV {
53343     const STRUCTURE_TYPE: StructureType =
53344         StructureType::PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV;
53345 }
53346 impl PipelineFragmentShadingRateEnumStateCreateInfoNV {
builder<'a>() -> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a>53347     pub fn builder<'a>() -> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
53348         PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder {
53349             inner: Self::default(),
53350             marker: ::std::marker::PhantomData,
53351         }
53352     }
53353 }
53354 #[repr(transparent)]
53355 pub struct PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
53356     inner: PipelineFragmentShadingRateEnumStateCreateInfoNV,
53357     marker: ::std::marker::PhantomData<&'a ()>,
53358 }
53359 unsafe impl ExtendsGraphicsPipelineCreateInfo
53360     for PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'_>
53361 {
53362 }
53363 unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineFragmentShadingRateEnumStateCreateInfoNV {}
53364 impl<'a> ::std::ops::Deref for PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
53365     type Target = PipelineFragmentShadingRateEnumStateCreateInfoNV;
deref(&self) -> &Self::Target53366     fn deref(&self) -> &Self::Target {
53367         &self.inner
53368     }
53369 }
53370 impl<'a> ::std::ops::DerefMut for PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target53371     fn deref_mut(&mut self) -> &mut Self::Target {
53372         &mut self.inner
53373     }
53374 }
53375 impl<'a> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
53376     #[inline]
shading_rate_type(mut self, shading_rate_type: FragmentShadingRateTypeNV) -> Self53377     pub fn shading_rate_type(mut self, shading_rate_type: FragmentShadingRateTypeNV) -> Self {
53378         self.inner.shading_rate_type = shading_rate_type;
53379         self
53380     }
53381     #[inline]
shading_rate(mut self, shading_rate: FragmentShadingRateNV) -> Self53382     pub fn shading_rate(mut self, shading_rate: FragmentShadingRateNV) -> Self {
53383         self.inner.shading_rate = shading_rate;
53384         self
53385     }
53386     #[inline]
combiner_ops(mut self, combiner_ops: [FragmentShadingRateCombinerOpKHR; 2]) -> Self53387     pub fn combiner_ops(mut self, combiner_ops: [FragmentShadingRateCombinerOpKHR; 2]) -> Self {
53388         self.inner.combiner_ops = combiner_ops;
53389         self
53390     }
53391     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53392     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53393     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineFragmentShadingRateEnumStateCreateInfoNV53394     pub fn build(self) -> PipelineFragmentShadingRateEnumStateCreateInfoNV {
53395         self.inner
53396     }
53397 }
53398 #[repr(C)]
53399 #[cfg_attr(feature = "debug", derive(Debug))]
53400 #[derive(Copy, Clone)]
53401 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureBuildSizesInfoKHR.html>"]
53402 pub struct AccelerationStructureBuildSizesInfoKHR {
53403     pub s_type: StructureType,
53404     pub p_next: *const c_void,
53405     pub acceleration_structure_size: DeviceSize,
53406     pub update_scratch_size: DeviceSize,
53407     pub build_scratch_size: DeviceSize,
53408 }
53409 impl ::std::default::Default for AccelerationStructureBuildSizesInfoKHR {
53410     #[inline]
default() -> Self53411     fn default() -> Self {
53412         Self {
53413             s_type: Self::STRUCTURE_TYPE,
53414             p_next: ::std::ptr::null(),
53415             acceleration_structure_size: DeviceSize::default(),
53416             update_scratch_size: DeviceSize::default(),
53417             build_scratch_size: DeviceSize::default(),
53418         }
53419     }
53420 }
53421 unsafe impl TaggedStructure for AccelerationStructureBuildSizesInfoKHR {
53422     const STRUCTURE_TYPE: StructureType =
53423         StructureType::ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR;
53424 }
53425 impl AccelerationStructureBuildSizesInfoKHR {
builder<'a>() -> AccelerationStructureBuildSizesInfoKHRBuilder<'a>53426     pub fn builder<'a>() -> AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
53427         AccelerationStructureBuildSizesInfoKHRBuilder {
53428             inner: Self::default(),
53429             marker: ::std::marker::PhantomData,
53430         }
53431     }
53432 }
53433 #[repr(transparent)]
53434 pub struct AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
53435     inner: AccelerationStructureBuildSizesInfoKHR,
53436     marker: ::std::marker::PhantomData<&'a ()>,
53437 }
53438 impl<'a> ::std::ops::Deref for AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
53439     type Target = AccelerationStructureBuildSizesInfoKHR;
deref(&self) -> &Self::Target53440     fn deref(&self) -> &Self::Target {
53441         &self.inner
53442     }
53443 }
53444 impl<'a> ::std::ops::DerefMut for AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target53445     fn deref_mut(&mut self) -> &mut Self::Target {
53446         &mut self.inner
53447     }
53448 }
53449 impl<'a> AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
53450     #[inline]
acceleration_structure_size(mut self, acceleration_structure_size: DeviceSize) -> Self53451     pub fn acceleration_structure_size(mut self, acceleration_structure_size: DeviceSize) -> Self {
53452         self.inner.acceleration_structure_size = acceleration_structure_size;
53453         self
53454     }
53455     #[inline]
update_scratch_size(mut self, update_scratch_size: DeviceSize) -> Self53456     pub fn update_scratch_size(mut self, update_scratch_size: DeviceSize) -> Self {
53457         self.inner.update_scratch_size = update_scratch_size;
53458         self
53459     }
53460     #[inline]
build_scratch_size(mut self, build_scratch_size: DeviceSize) -> Self53461     pub fn build_scratch_size(mut self, build_scratch_size: DeviceSize) -> Self {
53462         self.inner.build_scratch_size = build_scratch_size;
53463         self
53464     }
53465     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53466     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53467     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureBuildSizesInfoKHR53468     pub fn build(self) -> AccelerationStructureBuildSizesInfoKHR {
53469         self.inner
53470     }
53471 }
53472 #[repr(C)]
53473 #[cfg_attr(feature = "debug", derive(Debug))]
53474 #[derive(Copy, Clone)]
53475 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImage2DViewOf3DFeaturesEXT.html>"]
53476 pub struct PhysicalDeviceImage2DViewOf3DFeaturesEXT {
53477     pub s_type: StructureType,
53478     pub p_next: *mut c_void,
53479     pub image2_d_view_of3_d: Bool32,
53480     pub sampler2_d_view_of3_d: Bool32,
53481 }
53482 impl ::std::default::Default for PhysicalDeviceImage2DViewOf3DFeaturesEXT {
53483     #[inline]
default() -> Self53484     fn default() -> Self {
53485         Self {
53486             s_type: Self::STRUCTURE_TYPE,
53487             p_next: ::std::ptr::null_mut(),
53488             image2_d_view_of3_d: Bool32::default(),
53489             sampler2_d_view_of3_d: Bool32::default(),
53490         }
53491     }
53492 }
53493 unsafe impl TaggedStructure for PhysicalDeviceImage2DViewOf3DFeaturesEXT {
53494     const STRUCTURE_TYPE: StructureType =
53495         StructureType::PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
53496 }
53497 impl PhysicalDeviceImage2DViewOf3DFeaturesEXT {
builder<'a>() -> PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'a>53498     pub fn builder<'a>() -> PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'a> {
53499         PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder {
53500             inner: Self::default(),
53501             marker: ::std::marker::PhantomData,
53502         }
53503     }
53504 }
53505 #[repr(transparent)]
53506 pub struct PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'a> {
53507     inner: PhysicalDeviceImage2DViewOf3DFeaturesEXT,
53508     marker: ::std::marker::PhantomData<&'a ()>,
53509 }
53510 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'_> {}
53511 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImage2DViewOf3DFeaturesEXT {}
53512 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'_> {}
53513 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImage2DViewOf3DFeaturesEXT {}
53514 impl<'a> ::std::ops::Deref for PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'a> {
53515     type Target = PhysicalDeviceImage2DViewOf3DFeaturesEXT;
deref(&self) -> &Self::Target53516     fn deref(&self) -> &Self::Target {
53517         &self.inner
53518     }
53519 }
53520 impl<'a> ::std::ops::DerefMut for PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target53521     fn deref_mut(&mut self) -> &mut Self::Target {
53522         &mut self.inner
53523     }
53524 }
53525 impl<'a> PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'a> {
53526     #[inline]
image2_d_view_of3_d(mut self, image2_d_view_of3_d: bool) -> Self53527     pub fn image2_d_view_of3_d(mut self, image2_d_view_of3_d: bool) -> Self {
53528         self.inner.image2_d_view_of3_d = image2_d_view_of3_d.into();
53529         self
53530     }
53531     #[inline]
sampler2_d_view_of3_d(mut self, sampler2_d_view_of3_d: bool) -> Self53532     pub fn sampler2_d_view_of3_d(mut self, sampler2_d_view_of3_d: bool) -> Self {
53533         self.inner.sampler2_d_view_of3_d = sampler2_d_view_of3_d.into();
53534         self
53535     }
53536     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53537     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53538     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceImage2DViewOf3DFeaturesEXT53539     pub fn build(self) -> PhysicalDeviceImage2DViewOf3DFeaturesEXT {
53540         self.inner
53541     }
53542 }
53543 #[repr(C)]
53544 #[cfg_attr(feature = "debug", derive(Debug))]
53545 #[derive(Copy, Clone)]
53546 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT.html>"]
53547 pub struct PhysicalDeviceImageSlicedViewOf3DFeaturesEXT {
53548     pub s_type: StructureType,
53549     pub p_next: *mut c_void,
53550     pub image_sliced_view_of3_d: Bool32,
53551 }
53552 impl ::std::default::Default for PhysicalDeviceImageSlicedViewOf3DFeaturesEXT {
53553     #[inline]
default() -> Self53554     fn default() -> Self {
53555         Self {
53556             s_type: Self::STRUCTURE_TYPE,
53557             p_next: ::std::ptr::null_mut(),
53558             image_sliced_view_of3_d: Bool32::default(),
53559         }
53560     }
53561 }
53562 unsafe impl TaggedStructure for PhysicalDeviceImageSlicedViewOf3DFeaturesEXT {
53563     const STRUCTURE_TYPE: StructureType =
53564         StructureType::PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT;
53565 }
53566 impl PhysicalDeviceImageSlicedViewOf3DFeaturesEXT {
builder<'a>() -> PhysicalDeviceImageSlicedViewOf3DFeaturesEXTBuilder<'a>53567     pub fn builder<'a>() -> PhysicalDeviceImageSlicedViewOf3DFeaturesEXTBuilder<'a> {
53568         PhysicalDeviceImageSlicedViewOf3DFeaturesEXTBuilder {
53569             inner: Self::default(),
53570             marker: ::std::marker::PhantomData,
53571         }
53572     }
53573 }
53574 #[repr(transparent)]
53575 pub struct PhysicalDeviceImageSlicedViewOf3DFeaturesEXTBuilder<'a> {
53576     inner: PhysicalDeviceImageSlicedViewOf3DFeaturesEXT,
53577     marker: ::std::marker::PhantomData<&'a ()>,
53578 }
53579 unsafe impl ExtendsPhysicalDeviceFeatures2
53580     for PhysicalDeviceImageSlicedViewOf3DFeaturesEXTBuilder<'_>
53581 {
53582 }
53583 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageSlicedViewOf3DFeaturesEXT {}
53584 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageSlicedViewOf3DFeaturesEXTBuilder<'_> {}
53585 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageSlicedViewOf3DFeaturesEXT {}
53586 impl<'a> ::std::ops::Deref for PhysicalDeviceImageSlicedViewOf3DFeaturesEXTBuilder<'a> {
53587     type Target = PhysicalDeviceImageSlicedViewOf3DFeaturesEXT;
deref(&self) -> &Self::Target53588     fn deref(&self) -> &Self::Target {
53589         &self.inner
53590     }
53591 }
53592 impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageSlicedViewOf3DFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target53593     fn deref_mut(&mut self) -> &mut Self::Target {
53594         &mut self.inner
53595     }
53596 }
53597 impl<'a> PhysicalDeviceImageSlicedViewOf3DFeaturesEXTBuilder<'a> {
53598     #[inline]
image_sliced_view_of3_d(mut self, image_sliced_view_of3_d: bool) -> Self53599     pub fn image_sliced_view_of3_d(mut self, image_sliced_view_of3_d: bool) -> Self {
53600         self.inner.image_sliced_view_of3_d = image_sliced_view_of3_d.into();
53601         self
53602     }
53603     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53604     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53605     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceImageSlicedViewOf3DFeaturesEXT53606     pub fn build(self) -> PhysicalDeviceImageSlicedViewOf3DFeaturesEXT {
53607         self.inner
53608     }
53609 }
53610 #[repr(C)]
53611 #[cfg_attr(feature = "debug", derive(Debug))]
53612 #[derive(Copy, Clone)]
53613 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.html>"]
53614 pub struct PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT {
53615     pub s_type: StructureType,
53616     pub p_next: *mut c_void,
53617     pub attachment_feedback_loop_dynamic_state: Bool32,
53618 }
53619 impl ::std::default::Default for PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT {
53620     #[inline]
default() -> Self53621     fn default() -> Self {
53622         Self {
53623             s_type: Self::STRUCTURE_TYPE,
53624             p_next: ::std::ptr::null_mut(),
53625             attachment_feedback_loop_dynamic_state: Bool32::default(),
53626         }
53627     }
53628 }
53629 unsafe impl TaggedStructure for PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT {
53630     const STRUCTURE_TYPE: StructureType =
53631         StructureType::PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT;
53632 }
53633 impl PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT {
builder<'a>() -> PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXTBuilder<'a>53634     pub fn builder<'a>() -> PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXTBuilder<'a> {
53635         PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXTBuilder {
53636             inner: Self::default(),
53637             marker: ::std::marker::PhantomData,
53638         }
53639     }
53640 }
53641 #[repr(transparent)]
53642 pub struct PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXTBuilder<'a> {
53643     inner: PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT,
53644     marker: ::std::marker::PhantomData<&'a ()>,
53645 }
53646 unsafe impl ExtendsPhysicalDeviceFeatures2
53647     for PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXTBuilder<'_>
53648 {
53649 }
53650 unsafe impl ExtendsPhysicalDeviceFeatures2
53651     for PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT
53652 {
53653 }
53654 unsafe impl ExtendsDeviceCreateInfo
53655     for PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXTBuilder<'_>
53656 {
53657 }
53658 unsafe impl ExtendsDeviceCreateInfo
53659     for PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT
53660 {
53661 }
53662 impl<'a> ::std::ops::Deref
53663     for PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXTBuilder<'a>
53664 {
53665     type Target = PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT;
deref(&self) -> &Self::Target53666     fn deref(&self) -> &Self::Target {
53667         &self.inner
53668     }
53669 }
53670 impl<'a> ::std::ops::DerefMut
53671     for PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXTBuilder<'a>
53672 {
deref_mut(&mut self) -> &mut Self::Target53673     fn deref_mut(&mut self) -> &mut Self::Target {
53674         &mut self.inner
53675     }
53676 }
53677 impl<'a> PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXTBuilder<'a> {
53678     #[inline]
attachment_feedback_loop_dynamic_state( mut self, attachment_feedback_loop_dynamic_state: bool, ) -> Self53679     pub fn attachment_feedback_loop_dynamic_state(
53680         mut self,
53681         attachment_feedback_loop_dynamic_state: bool,
53682     ) -> Self {
53683         self.inner.attachment_feedback_loop_dynamic_state =
53684             attachment_feedback_loop_dynamic_state.into();
53685         self
53686     }
53687     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53688     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53689     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT53690     pub fn build(self) -> PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT {
53691         self.inner
53692     }
53693 }
53694 #[repr(C)]
53695 #[cfg_attr(feature = "debug", derive(Debug))]
53696 #[derive(Copy, Clone)]
53697 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT.html>"]
53698 pub struct PhysicalDeviceMutableDescriptorTypeFeaturesEXT {
53699     pub s_type: StructureType,
53700     pub p_next: *mut c_void,
53701     pub mutable_descriptor_type: Bool32,
53702 }
53703 impl ::std::default::Default for PhysicalDeviceMutableDescriptorTypeFeaturesEXT {
53704     #[inline]
default() -> Self53705     fn default() -> Self {
53706         Self {
53707             s_type: Self::STRUCTURE_TYPE,
53708             p_next: ::std::ptr::null_mut(),
53709             mutable_descriptor_type: Bool32::default(),
53710         }
53711     }
53712 }
53713 unsafe impl TaggedStructure for PhysicalDeviceMutableDescriptorTypeFeaturesEXT {
53714     const STRUCTURE_TYPE: StructureType =
53715         StructureType::PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
53716 }
53717 impl PhysicalDeviceMutableDescriptorTypeFeaturesEXT {
builder<'a>() -> PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'a>53718     pub fn builder<'a>() -> PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'a> {
53719         PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder {
53720             inner: Self::default(),
53721             marker: ::std::marker::PhantomData,
53722         }
53723     }
53724 }
53725 #[repr(transparent)]
53726 pub struct PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'a> {
53727     inner: PhysicalDeviceMutableDescriptorTypeFeaturesEXT,
53728     marker: ::std::marker::PhantomData<&'a ()>,
53729 }
53730 unsafe impl ExtendsPhysicalDeviceFeatures2
53731     for PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'_>
53732 {
53733 }
53734 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMutableDescriptorTypeFeaturesEXT {}
53735 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'_> {}
53736 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMutableDescriptorTypeFeaturesEXT {}
53737 impl<'a> ::std::ops::Deref for PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'a> {
53738     type Target = PhysicalDeviceMutableDescriptorTypeFeaturesEXT;
deref(&self) -> &Self::Target53739     fn deref(&self) -> &Self::Target {
53740         &self.inner
53741     }
53742 }
53743 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target53744     fn deref_mut(&mut self) -> &mut Self::Target {
53745         &mut self.inner
53746     }
53747 }
53748 impl<'a> PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'a> {
53749     #[inline]
mutable_descriptor_type(mut self, mutable_descriptor_type: bool) -> Self53750     pub fn mutable_descriptor_type(mut self, mutable_descriptor_type: bool) -> Self {
53751         self.inner.mutable_descriptor_type = mutable_descriptor_type.into();
53752         self
53753     }
53754     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53755     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53756     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMutableDescriptorTypeFeaturesEXT53757     pub fn build(self) -> PhysicalDeviceMutableDescriptorTypeFeaturesEXT {
53758         self.inner
53759     }
53760 }
53761 #[repr(C)]
53762 #[cfg_attr(feature = "debug", derive(Debug))]
53763 #[derive(Copy, Clone)]
53764 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMutableDescriptorTypeListEXT.html>"]
53765 pub struct MutableDescriptorTypeListEXT {
53766     pub descriptor_type_count: u32,
53767     pub p_descriptor_types: *const DescriptorType,
53768 }
53769 impl ::std::default::Default for MutableDescriptorTypeListEXT {
53770     #[inline]
default() -> Self53771     fn default() -> Self {
53772         Self {
53773             descriptor_type_count: u32::default(),
53774             p_descriptor_types: ::std::ptr::null(),
53775         }
53776     }
53777 }
53778 impl MutableDescriptorTypeListEXT {
builder<'a>() -> MutableDescriptorTypeListEXTBuilder<'a>53779     pub fn builder<'a>() -> MutableDescriptorTypeListEXTBuilder<'a> {
53780         MutableDescriptorTypeListEXTBuilder {
53781             inner: Self::default(),
53782             marker: ::std::marker::PhantomData,
53783         }
53784     }
53785 }
53786 #[repr(transparent)]
53787 pub struct MutableDescriptorTypeListEXTBuilder<'a> {
53788     inner: MutableDescriptorTypeListEXT,
53789     marker: ::std::marker::PhantomData<&'a ()>,
53790 }
53791 impl<'a> ::std::ops::Deref for MutableDescriptorTypeListEXTBuilder<'a> {
53792     type Target = MutableDescriptorTypeListEXT;
deref(&self) -> &Self::Target53793     fn deref(&self) -> &Self::Target {
53794         &self.inner
53795     }
53796 }
53797 impl<'a> ::std::ops::DerefMut for MutableDescriptorTypeListEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target53798     fn deref_mut(&mut self) -> &mut Self::Target {
53799         &mut self.inner
53800     }
53801 }
53802 impl<'a> MutableDescriptorTypeListEXTBuilder<'a> {
53803     #[inline]
descriptor_types(mut self, descriptor_types: &'a [DescriptorType]) -> Self53804     pub fn descriptor_types(mut self, descriptor_types: &'a [DescriptorType]) -> Self {
53805         self.inner.descriptor_type_count = descriptor_types.len() as _;
53806         self.inner.p_descriptor_types = descriptor_types.as_ptr();
53807         self
53808     }
53809     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53810     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53811     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MutableDescriptorTypeListEXT53812     pub fn build(self) -> MutableDescriptorTypeListEXT {
53813         self.inner
53814     }
53815 }
53816 #[repr(C)]
53817 #[cfg_attr(feature = "debug", derive(Debug))]
53818 #[derive(Copy, Clone)]
53819 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMutableDescriptorTypeCreateInfoEXT.html>"]
53820 pub struct MutableDescriptorTypeCreateInfoEXT {
53821     pub s_type: StructureType,
53822     pub p_next: *const c_void,
53823     pub mutable_descriptor_type_list_count: u32,
53824     pub p_mutable_descriptor_type_lists: *const MutableDescriptorTypeListEXT,
53825 }
53826 impl ::std::default::Default for MutableDescriptorTypeCreateInfoEXT {
53827     #[inline]
default() -> Self53828     fn default() -> Self {
53829         Self {
53830             s_type: Self::STRUCTURE_TYPE,
53831             p_next: ::std::ptr::null(),
53832             mutable_descriptor_type_list_count: u32::default(),
53833             p_mutable_descriptor_type_lists: ::std::ptr::null(),
53834         }
53835     }
53836 }
53837 unsafe impl TaggedStructure for MutableDescriptorTypeCreateInfoEXT {
53838     const STRUCTURE_TYPE: StructureType = StructureType::MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT;
53839 }
53840 impl MutableDescriptorTypeCreateInfoEXT {
builder<'a>() -> MutableDescriptorTypeCreateInfoEXTBuilder<'a>53841     pub fn builder<'a>() -> MutableDescriptorTypeCreateInfoEXTBuilder<'a> {
53842         MutableDescriptorTypeCreateInfoEXTBuilder {
53843             inner: Self::default(),
53844             marker: ::std::marker::PhantomData,
53845         }
53846     }
53847 }
53848 #[repr(transparent)]
53849 pub struct MutableDescriptorTypeCreateInfoEXTBuilder<'a> {
53850     inner: MutableDescriptorTypeCreateInfoEXT,
53851     marker: ::std::marker::PhantomData<&'a ()>,
53852 }
53853 unsafe impl ExtendsDescriptorSetLayoutCreateInfo for MutableDescriptorTypeCreateInfoEXTBuilder<'_> {}
53854 unsafe impl ExtendsDescriptorSetLayoutCreateInfo for MutableDescriptorTypeCreateInfoEXT {}
53855 unsafe impl ExtendsDescriptorPoolCreateInfo for MutableDescriptorTypeCreateInfoEXTBuilder<'_> {}
53856 unsafe impl ExtendsDescriptorPoolCreateInfo for MutableDescriptorTypeCreateInfoEXT {}
53857 impl<'a> ::std::ops::Deref for MutableDescriptorTypeCreateInfoEXTBuilder<'a> {
53858     type Target = MutableDescriptorTypeCreateInfoEXT;
deref(&self) -> &Self::Target53859     fn deref(&self) -> &Self::Target {
53860         &self.inner
53861     }
53862 }
53863 impl<'a> ::std::ops::DerefMut for MutableDescriptorTypeCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target53864     fn deref_mut(&mut self) -> &mut Self::Target {
53865         &mut self.inner
53866     }
53867 }
53868 impl<'a> MutableDescriptorTypeCreateInfoEXTBuilder<'a> {
53869     #[inline]
mutable_descriptor_type_lists( mut self, mutable_descriptor_type_lists: &'a [MutableDescriptorTypeListEXT], ) -> Self53870     pub fn mutable_descriptor_type_lists(
53871         mut self,
53872         mutable_descriptor_type_lists: &'a [MutableDescriptorTypeListEXT],
53873     ) -> Self {
53874         self.inner.mutable_descriptor_type_list_count = mutable_descriptor_type_lists.len() as _;
53875         self.inner.p_mutable_descriptor_type_lists = mutable_descriptor_type_lists.as_ptr();
53876         self
53877     }
53878     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53879     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53880     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MutableDescriptorTypeCreateInfoEXT53881     pub fn build(self) -> MutableDescriptorTypeCreateInfoEXT {
53882         self.inner
53883     }
53884 }
53885 #[repr(C)]
53886 #[cfg_attr(feature = "debug", derive(Debug))]
53887 #[derive(Copy, Clone)]
53888 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDepthClipControlFeaturesEXT.html>"]
53889 pub struct PhysicalDeviceDepthClipControlFeaturesEXT {
53890     pub s_type: StructureType,
53891     pub p_next: *mut c_void,
53892     pub depth_clip_control: Bool32,
53893 }
53894 impl ::std::default::Default for PhysicalDeviceDepthClipControlFeaturesEXT {
53895     #[inline]
default() -> Self53896     fn default() -> Self {
53897         Self {
53898             s_type: Self::STRUCTURE_TYPE,
53899             p_next: ::std::ptr::null_mut(),
53900             depth_clip_control: Bool32::default(),
53901         }
53902     }
53903 }
53904 unsafe impl TaggedStructure for PhysicalDeviceDepthClipControlFeaturesEXT {
53905     const STRUCTURE_TYPE: StructureType =
53906         StructureType::PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
53907 }
53908 impl PhysicalDeviceDepthClipControlFeaturesEXT {
builder<'a>() -> PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a>53909     pub fn builder<'a>() -> PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> {
53910         PhysicalDeviceDepthClipControlFeaturesEXTBuilder {
53911             inner: Self::default(),
53912             marker: ::std::marker::PhantomData,
53913         }
53914     }
53915 }
53916 #[repr(transparent)]
53917 pub struct PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> {
53918     inner: PhysicalDeviceDepthClipControlFeaturesEXT,
53919     marker: ::std::marker::PhantomData<&'a ()>,
53920 }
53921 unsafe impl ExtendsPhysicalDeviceFeatures2
53922     for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'_>
53923 {
53924 }
53925 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClipControlFeaturesEXT {}
53926 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'_> {}
53927 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipControlFeaturesEXT {}
53928 impl<'a> ::std::ops::Deref for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> {
53929     type Target = PhysicalDeviceDepthClipControlFeaturesEXT;
deref(&self) -> &Self::Target53930     fn deref(&self) -> &Self::Target {
53931         &self.inner
53932     }
53933 }
53934 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target53935     fn deref_mut(&mut self) -> &mut Self::Target {
53936         &mut self.inner
53937     }
53938 }
53939 impl<'a> PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> {
53940     #[inline]
depth_clip_control(mut self, depth_clip_control: bool) -> Self53941     pub fn depth_clip_control(mut self, depth_clip_control: bool) -> Self {
53942         self.inner.depth_clip_control = depth_clip_control.into();
53943         self
53944     }
53945     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53946     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53947     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDepthClipControlFeaturesEXT53948     pub fn build(self) -> PhysicalDeviceDepthClipControlFeaturesEXT {
53949         self.inner
53950     }
53951 }
53952 #[repr(C)]
53953 #[cfg_attr(feature = "debug", derive(Debug))]
53954 #[derive(Copy, Clone)]
53955 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportDepthClipControlCreateInfoEXT.html>"]
53956 pub struct PipelineViewportDepthClipControlCreateInfoEXT {
53957     pub s_type: StructureType,
53958     pub p_next: *const c_void,
53959     pub negative_one_to_one: Bool32,
53960 }
53961 impl ::std::default::Default for PipelineViewportDepthClipControlCreateInfoEXT {
53962     #[inline]
default() -> Self53963     fn default() -> Self {
53964         Self {
53965             s_type: Self::STRUCTURE_TYPE,
53966             p_next: ::std::ptr::null(),
53967             negative_one_to_one: Bool32::default(),
53968         }
53969     }
53970 }
53971 unsafe impl TaggedStructure for PipelineViewportDepthClipControlCreateInfoEXT {
53972     const STRUCTURE_TYPE: StructureType =
53973         StructureType::PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT;
53974 }
53975 impl PipelineViewportDepthClipControlCreateInfoEXT {
builder<'a>() -> PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a>53976     pub fn builder<'a>() -> PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> {
53977         PipelineViewportDepthClipControlCreateInfoEXTBuilder {
53978             inner: Self::default(),
53979             marker: ::std::marker::PhantomData,
53980         }
53981     }
53982 }
53983 #[repr(transparent)]
53984 pub struct PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> {
53985     inner: PipelineViewportDepthClipControlCreateInfoEXT,
53986     marker: ::std::marker::PhantomData<&'a ()>,
53987 }
53988 unsafe impl ExtendsPipelineViewportStateCreateInfo
53989     for PipelineViewportDepthClipControlCreateInfoEXTBuilder<'_>
53990 {
53991 }
53992 unsafe impl ExtendsPipelineViewportStateCreateInfo
53993     for PipelineViewportDepthClipControlCreateInfoEXT
53994 {
53995 }
53996 impl<'a> ::std::ops::Deref for PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> {
53997     type Target = PipelineViewportDepthClipControlCreateInfoEXT;
deref(&self) -> &Self::Target53998     fn deref(&self) -> &Self::Target {
53999         &self.inner
54000     }
54001 }
54002 impl<'a> ::std::ops::DerefMut for PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target54003     fn deref_mut(&mut self) -> &mut Self::Target {
54004         &mut self.inner
54005     }
54006 }
54007 impl<'a> PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> {
54008     #[inline]
negative_one_to_one(mut self, negative_one_to_one: bool) -> Self54009     pub fn negative_one_to_one(mut self, negative_one_to_one: bool) -> Self {
54010         self.inner.negative_one_to_one = negative_one_to_one.into();
54011         self
54012     }
54013     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54014     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54015     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineViewportDepthClipControlCreateInfoEXT54016     pub fn build(self) -> PipelineViewportDepthClipControlCreateInfoEXT {
54017         self.inner
54018     }
54019 }
54020 #[repr(C)]
54021 #[cfg_attr(feature = "debug", derive(Debug))]
54022 #[derive(Copy, Clone)]
54023 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT.html>"]
54024 pub struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT {
54025     pub s_type: StructureType,
54026     pub p_next: *mut c_void,
54027     pub vertex_input_dynamic_state: Bool32,
54028 }
54029 impl ::std::default::Default for PhysicalDeviceVertexInputDynamicStateFeaturesEXT {
54030     #[inline]
default() -> Self54031     fn default() -> Self {
54032         Self {
54033             s_type: Self::STRUCTURE_TYPE,
54034             p_next: ::std::ptr::null_mut(),
54035             vertex_input_dynamic_state: Bool32::default(),
54036         }
54037     }
54038 }
54039 unsafe impl TaggedStructure for PhysicalDeviceVertexInputDynamicStateFeaturesEXT {
54040     const STRUCTURE_TYPE: StructureType =
54041         StructureType::PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
54042 }
54043 impl PhysicalDeviceVertexInputDynamicStateFeaturesEXT {
builder<'a>() -> PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a>54044     pub fn builder<'a>() -> PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> {
54045         PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder {
54046             inner: Self::default(),
54047             marker: ::std::marker::PhantomData,
54048         }
54049     }
54050 }
54051 #[repr(transparent)]
54052 pub struct PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> {
54053     inner: PhysicalDeviceVertexInputDynamicStateFeaturesEXT,
54054     marker: ::std::marker::PhantomData<&'a ()>,
54055 }
54056 unsafe impl ExtendsPhysicalDeviceFeatures2
54057     for PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'_>
54058 {
54059 }
54060 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVertexInputDynamicStateFeaturesEXT {}
54061 unsafe impl ExtendsDeviceCreateInfo
54062     for PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'_>
54063 {
54064 }
54065 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexInputDynamicStateFeaturesEXT {}
54066 impl<'a> ::std::ops::Deref for PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> {
54067     type Target = PhysicalDeviceVertexInputDynamicStateFeaturesEXT;
deref(&self) -> &Self::Target54068     fn deref(&self) -> &Self::Target {
54069         &self.inner
54070     }
54071 }
54072 impl<'a> ::std::ops::DerefMut for PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target54073     fn deref_mut(&mut self) -> &mut Self::Target {
54074         &mut self.inner
54075     }
54076 }
54077 impl<'a> PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> {
54078     #[inline]
vertex_input_dynamic_state(mut self, vertex_input_dynamic_state: bool) -> Self54079     pub fn vertex_input_dynamic_state(mut self, vertex_input_dynamic_state: bool) -> Self {
54080         self.inner.vertex_input_dynamic_state = vertex_input_dynamic_state.into();
54081         self
54082     }
54083     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54084     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54085     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceVertexInputDynamicStateFeaturesEXT54086     pub fn build(self) -> PhysicalDeviceVertexInputDynamicStateFeaturesEXT {
54087         self.inner
54088     }
54089 }
54090 #[repr(C)]
54091 #[cfg_attr(feature = "debug", derive(Debug))]
54092 #[derive(Copy, Clone)]
54093 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalMemoryRDMAFeaturesNV.html>"]
54094 pub struct PhysicalDeviceExternalMemoryRDMAFeaturesNV {
54095     pub s_type: StructureType,
54096     pub p_next: *mut c_void,
54097     pub external_memory_rdma: Bool32,
54098 }
54099 impl ::std::default::Default for PhysicalDeviceExternalMemoryRDMAFeaturesNV {
54100     #[inline]
default() -> Self54101     fn default() -> Self {
54102         Self {
54103             s_type: Self::STRUCTURE_TYPE,
54104             p_next: ::std::ptr::null_mut(),
54105             external_memory_rdma: Bool32::default(),
54106         }
54107     }
54108 }
54109 unsafe impl TaggedStructure for PhysicalDeviceExternalMemoryRDMAFeaturesNV {
54110     const STRUCTURE_TYPE: StructureType =
54111         StructureType::PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV;
54112 }
54113 impl PhysicalDeviceExternalMemoryRDMAFeaturesNV {
builder<'a>() -> PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a>54114     pub fn builder<'a>() -> PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> {
54115         PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder {
54116             inner: Self::default(),
54117             marker: ::std::marker::PhantomData,
54118         }
54119     }
54120 }
54121 #[repr(transparent)]
54122 pub struct PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> {
54123     inner: PhysicalDeviceExternalMemoryRDMAFeaturesNV,
54124     marker: ::std::marker::PhantomData<&'a ()>,
54125 }
54126 unsafe impl ExtendsPhysicalDeviceFeatures2
54127     for PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'_>
54128 {
54129 }
54130 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExternalMemoryRDMAFeaturesNV {}
54131 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'_> {}
54132 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExternalMemoryRDMAFeaturesNV {}
54133 impl<'a> ::std::ops::Deref for PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> {
54134     type Target = PhysicalDeviceExternalMemoryRDMAFeaturesNV;
deref(&self) -> &Self::Target54135     fn deref(&self) -> &Self::Target {
54136         &self.inner
54137     }
54138 }
54139 impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target54140     fn deref_mut(&mut self) -> &mut Self::Target {
54141         &mut self.inner
54142     }
54143 }
54144 impl<'a> PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> {
54145     #[inline]
external_memory_rdma(mut self, external_memory_rdma: bool) -> Self54146     pub fn external_memory_rdma(mut self, external_memory_rdma: bool) -> Self {
54147         self.inner.external_memory_rdma = external_memory_rdma.into();
54148         self
54149     }
54150     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54151     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54152     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceExternalMemoryRDMAFeaturesNV54153     pub fn build(self) -> PhysicalDeviceExternalMemoryRDMAFeaturesNV {
54154         self.inner
54155     }
54156 }
54157 #[repr(C)]
54158 #[cfg_attr(feature = "debug", derive(Debug))]
54159 #[derive(Copy, Clone)]
54160 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVertexInputBindingDescription2EXT.html>"]
54161 pub struct VertexInputBindingDescription2EXT {
54162     pub s_type: StructureType,
54163     pub p_next: *mut c_void,
54164     pub binding: u32,
54165     pub stride: u32,
54166     pub input_rate: VertexInputRate,
54167     pub divisor: u32,
54168 }
54169 impl ::std::default::Default for VertexInputBindingDescription2EXT {
54170     #[inline]
default() -> Self54171     fn default() -> Self {
54172         Self {
54173             s_type: Self::STRUCTURE_TYPE,
54174             p_next: ::std::ptr::null_mut(),
54175             binding: u32::default(),
54176             stride: u32::default(),
54177             input_rate: VertexInputRate::default(),
54178             divisor: u32::default(),
54179         }
54180     }
54181 }
54182 unsafe impl TaggedStructure for VertexInputBindingDescription2EXT {
54183     const STRUCTURE_TYPE: StructureType = StructureType::VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT;
54184 }
54185 impl VertexInputBindingDescription2EXT {
builder<'a>() -> VertexInputBindingDescription2EXTBuilder<'a>54186     pub fn builder<'a>() -> VertexInputBindingDescription2EXTBuilder<'a> {
54187         VertexInputBindingDescription2EXTBuilder {
54188             inner: Self::default(),
54189             marker: ::std::marker::PhantomData,
54190         }
54191     }
54192 }
54193 #[repr(transparent)]
54194 pub struct VertexInputBindingDescription2EXTBuilder<'a> {
54195     inner: VertexInputBindingDescription2EXT,
54196     marker: ::std::marker::PhantomData<&'a ()>,
54197 }
54198 impl<'a> ::std::ops::Deref for VertexInputBindingDescription2EXTBuilder<'a> {
54199     type Target = VertexInputBindingDescription2EXT;
deref(&self) -> &Self::Target54200     fn deref(&self) -> &Self::Target {
54201         &self.inner
54202     }
54203 }
54204 impl<'a> ::std::ops::DerefMut for VertexInputBindingDescription2EXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target54205     fn deref_mut(&mut self) -> &mut Self::Target {
54206         &mut self.inner
54207     }
54208 }
54209 impl<'a> VertexInputBindingDescription2EXTBuilder<'a> {
54210     #[inline]
binding(mut self, binding: u32) -> Self54211     pub fn binding(mut self, binding: u32) -> Self {
54212         self.inner.binding = binding;
54213         self
54214     }
54215     #[inline]
stride(mut self, stride: u32) -> Self54216     pub fn stride(mut self, stride: u32) -> Self {
54217         self.inner.stride = stride;
54218         self
54219     }
54220     #[inline]
input_rate(mut self, input_rate: VertexInputRate) -> Self54221     pub fn input_rate(mut self, input_rate: VertexInputRate) -> Self {
54222         self.inner.input_rate = input_rate;
54223         self
54224     }
54225     #[inline]
divisor(mut self, divisor: u32) -> Self54226     pub fn divisor(mut self, divisor: u32) -> Self {
54227         self.inner.divisor = divisor;
54228         self
54229     }
54230     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54231     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54232     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VertexInputBindingDescription2EXT54233     pub fn build(self) -> VertexInputBindingDescription2EXT {
54234         self.inner
54235     }
54236 }
54237 #[repr(C)]
54238 #[cfg_attr(feature = "debug", derive(Debug))]
54239 #[derive(Copy, Clone)]
54240 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVertexInputAttributeDescription2EXT.html>"]
54241 pub struct VertexInputAttributeDescription2EXT {
54242     pub s_type: StructureType,
54243     pub p_next: *mut c_void,
54244     pub location: u32,
54245     pub binding: u32,
54246     pub format: Format,
54247     pub offset: u32,
54248 }
54249 impl ::std::default::Default for VertexInputAttributeDescription2EXT {
54250     #[inline]
default() -> Self54251     fn default() -> Self {
54252         Self {
54253             s_type: Self::STRUCTURE_TYPE,
54254             p_next: ::std::ptr::null_mut(),
54255             location: u32::default(),
54256             binding: u32::default(),
54257             format: Format::default(),
54258             offset: u32::default(),
54259         }
54260     }
54261 }
54262 unsafe impl TaggedStructure for VertexInputAttributeDescription2EXT {
54263     const STRUCTURE_TYPE: StructureType = StructureType::VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT;
54264 }
54265 impl VertexInputAttributeDescription2EXT {
builder<'a>() -> VertexInputAttributeDescription2EXTBuilder<'a>54266     pub fn builder<'a>() -> VertexInputAttributeDescription2EXTBuilder<'a> {
54267         VertexInputAttributeDescription2EXTBuilder {
54268             inner: Self::default(),
54269             marker: ::std::marker::PhantomData,
54270         }
54271     }
54272 }
54273 #[repr(transparent)]
54274 pub struct VertexInputAttributeDescription2EXTBuilder<'a> {
54275     inner: VertexInputAttributeDescription2EXT,
54276     marker: ::std::marker::PhantomData<&'a ()>,
54277 }
54278 impl<'a> ::std::ops::Deref for VertexInputAttributeDescription2EXTBuilder<'a> {
54279     type Target = VertexInputAttributeDescription2EXT;
deref(&self) -> &Self::Target54280     fn deref(&self) -> &Self::Target {
54281         &self.inner
54282     }
54283 }
54284 impl<'a> ::std::ops::DerefMut for VertexInputAttributeDescription2EXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target54285     fn deref_mut(&mut self) -> &mut Self::Target {
54286         &mut self.inner
54287     }
54288 }
54289 impl<'a> VertexInputAttributeDescription2EXTBuilder<'a> {
54290     #[inline]
location(mut self, location: u32) -> Self54291     pub fn location(mut self, location: u32) -> Self {
54292         self.inner.location = location;
54293         self
54294     }
54295     #[inline]
binding(mut self, binding: u32) -> Self54296     pub fn binding(mut self, binding: u32) -> Self {
54297         self.inner.binding = binding;
54298         self
54299     }
54300     #[inline]
format(mut self, format: Format) -> Self54301     pub fn format(mut self, format: Format) -> Self {
54302         self.inner.format = format;
54303         self
54304     }
54305     #[inline]
offset(mut self, offset: u32) -> Self54306     pub fn offset(mut self, offset: u32) -> Self {
54307         self.inner.offset = offset;
54308         self
54309     }
54310     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54311     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54312     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VertexInputAttributeDescription2EXT54313     pub fn build(self) -> VertexInputAttributeDescription2EXT {
54314         self.inner
54315     }
54316 }
54317 #[repr(C)]
54318 #[cfg_attr(feature = "debug", derive(Debug))]
54319 #[derive(Copy, Clone)]
54320 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceColorWriteEnableFeaturesEXT.html>"]
54321 pub struct PhysicalDeviceColorWriteEnableFeaturesEXT {
54322     pub s_type: StructureType,
54323     pub p_next: *mut c_void,
54324     pub color_write_enable: Bool32,
54325 }
54326 impl ::std::default::Default for PhysicalDeviceColorWriteEnableFeaturesEXT {
54327     #[inline]
default() -> Self54328     fn default() -> Self {
54329         Self {
54330             s_type: Self::STRUCTURE_TYPE,
54331             p_next: ::std::ptr::null_mut(),
54332             color_write_enable: Bool32::default(),
54333         }
54334     }
54335 }
54336 unsafe impl TaggedStructure for PhysicalDeviceColorWriteEnableFeaturesEXT {
54337     const STRUCTURE_TYPE: StructureType =
54338         StructureType::PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
54339 }
54340 impl PhysicalDeviceColorWriteEnableFeaturesEXT {
builder<'a>() -> PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a>54341     pub fn builder<'a>() -> PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> {
54342         PhysicalDeviceColorWriteEnableFeaturesEXTBuilder {
54343             inner: Self::default(),
54344             marker: ::std::marker::PhantomData,
54345         }
54346     }
54347 }
54348 #[repr(transparent)]
54349 pub struct PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> {
54350     inner: PhysicalDeviceColorWriteEnableFeaturesEXT,
54351     marker: ::std::marker::PhantomData<&'a ()>,
54352 }
54353 unsafe impl ExtendsPhysicalDeviceFeatures2
54354     for PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'_>
54355 {
54356 }
54357 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceColorWriteEnableFeaturesEXT {}
54358 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'_> {}
54359 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceColorWriteEnableFeaturesEXT {}
54360 impl<'a> ::std::ops::Deref for PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> {
54361     type Target = PhysicalDeviceColorWriteEnableFeaturesEXT;
deref(&self) -> &Self::Target54362     fn deref(&self) -> &Self::Target {
54363         &self.inner
54364     }
54365 }
54366 impl<'a> ::std::ops::DerefMut for PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target54367     fn deref_mut(&mut self) -> &mut Self::Target {
54368         &mut self.inner
54369     }
54370 }
54371 impl<'a> PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> {
54372     #[inline]
color_write_enable(mut self, color_write_enable: bool) -> Self54373     pub fn color_write_enable(mut self, color_write_enable: bool) -> Self {
54374         self.inner.color_write_enable = color_write_enable.into();
54375         self
54376     }
54377     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54378     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54379     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceColorWriteEnableFeaturesEXT54380     pub fn build(self) -> PhysicalDeviceColorWriteEnableFeaturesEXT {
54381         self.inner
54382     }
54383 }
54384 #[repr(C)]
54385 #[cfg_attr(feature = "debug", derive(Debug))]
54386 #[derive(Copy, Clone)]
54387 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineColorWriteCreateInfoEXT.html>"]
54388 pub struct PipelineColorWriteCreateInfoEXT {
54389     pub s_type: StructureType,
54390     pub p_next: *const c_void,
54391     pub attachment_count: u32,
54392     pub p_color_write_enables: *const Bool32,
54393 }
54394 impl ::std::default::Default for PipelineColorWriteCreateInfoEXT {
54395     #[inline]
default() -> Self54396     fn default() -> Self {
54397         Self {
54398             s_type: Self::STRUCTURE_TYPE,
54399             p_next: ::std::ptr::null(),
54400             attachment_count: u32::default(),
54401             p_color_write_enables: ::std::ptr::null(),
54402         }
54403     }
54404 }
54405 unsafe impl TaggedStructure for PipelineColorWriteCreateInfoEXT {
54406     const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_COLOR_WRITE_CREATE_INFO_EXT;
54407 }
54408 impl PipelineColorWriteCreateInfoEXT {
builder<'a>() -> PipelineColorWriteCreateInfoEXTBuilder<'a>54409     pub fn builder<'a>() -> PipelineColorWriteCreateInfoEXTBuilder<'a> {
54410         PipelineColorWriteCreateInfoEXTBuilder {
54411             inner: Self::default(),
54412             marker: ::std::marker::PhantomData,
54413         }
54414     }
54415 }
54416 #[repr(transparent)]
54417 pub struct PipelineColorWriteCreateInfoEXTBuilder<'a> {
54418     inner: PipelineColorWriteCreateInfoEXT,
54419     marker: ::std::marker::PhantomData<&'a ()>,
54420 }
54421 unsafe impl ExtendsPipelineColorBlendStateCreateInfo
54422     for PipelineColorWriteCreateInfoEXTBuilder<'_>
54423 {
54424 }
54425 unsafe impl ExtendsPipelineColorBlendStateCreateInfo for PipelineColorWriteCreateInfoEXT {}
54426 impl<'a> ::std::ops::Deref for PipelineColorWriteCreateInfoEXTBuilder<'a> {
54427     type Target = PipelineColorWriteCreateInfoEXT;
deref(&self) -> &Self::Target54428     fn deref(&self) -> &Self::Target {
54429         &self.inner
54430     }
54431 }
54432 impl<'a> ::std::ops::DerefMut for PipelineColorWriteCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target54433     fn deref_mut(&mut self) -> &mut Self::Target {
54434         &mut self.inner
54435     }
54436 }
54437 impl<'a> PipelineColorWriteCreateInfoEXTBuilder<'a> {
54438     #[inline]
color_write_enables(mut self, color_write_enables: &'a [Bool32]) -> Self54439     pub fn color_write_enables(mut self, color_write_enables: &'a [Bool32]) -> Self {
54440         self.inner.attachment_count = color_write_enables.len() as _;
54441         self.inner.p_color_write_enables = color_write_enables.as_ptr();
54442         self
54443     }
54444     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54445     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54446     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineColorWriteCreateInfoEXT54447     pub fn build(self) -> PipelineColorWriteCreateInfoEXT {
54448         self.inner
54449     }
54450 }
54451 #[repr(C)]
54452 #[cfg_attr(feature = "debug", derive(Debug))]
54453 #[derive(Copy, Clone)]
54454 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryBarrier2.html>"]
54455 pub struct MemoryBarrier2 {
54456     pub s_type: StructureType,
54457     pub p_next: *const c_void,
54458     pub src_stage_mask: PipelineStageFlags2,
54459     pub src_access_mask: AccessFlags2,
54460     pub dst_stage_mask: PipelineStageFlags2,
54461     pub dst_access_mask: AccessFlags2,
54462 }
54463 impl ::std::default::Default for MemoryBarrier2 {
54464     #[inline]
default() -> Self54465     fn default() -> Self {
54466         Self {
54467             s_type: Self::STRUCTURE_TYPE,
54468             p_next: ::std::ptr::null(),
54469             src_stage_mask: PipelineStageFlags2::default(),
54470             src_access_mask: AccessFlags2::default(),
54471             dst_stage_mask: PipelineStageFlags2::default(),
54472             dst_access_mask: AccessFlags2::default(),
54473         }
54474     }
54475 }
54476 unsafe impl TaggedStructure for MemoryBarrier2 {
54477     const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_BARRIER_2;
54478 }
54479 impl MemoryBarrier2 {
builder<'a>() -> MemoryBarrier2Builder<'a>54480     pub fn builder<'a>() -> MemoryBarrier2Builder<'a> {
54481         MemoryBarrier2Builder {
54482             inner: Self::default(),
54483             marker: ::std::marker::PhantomData,
54484         }
54485     }
54486 }
54487 #[repr(transparent)]
54488 pub struct MemoryBarrier2Builder<'a> {
54489     inner: MemoryBarrier2,
54490     marker: ::std::marker::PhantomData<&'a ()>,
54491 }
54492 unsafe impl ExtendsSubpassDependency2 for MemoryBarrier2Builder<'_> {}
54493 unsafe impl ExtendsSubpassDependency2 for MemoryBarrier2 {}
54494 impl<'a> ::std::ops::Deref for MemoryBarrier2Builder<'a> {
54495     type Target = MemoryBarrier2;
deref(&self) -> &Self::Target54496     fn deref(&self) -> &Self::Target {
54497         &self.inner
54498     }
54499 }
54500 impl<'a> ::std::ops::DerefMut for MemoryBarrier2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target54501     fn deref_mut(&mut self) -> &mut Self::Target {
54502         &mut self.inner
54503     }
54504 }
54505 impl<'a> MemoryBarrier2Builder<'a> {
54506     #[inline]
src_stage_mask(mut self, src_stage_mask: PipelineStageFlags2) -> Self54507     pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags2) -> Self {
54508         self.inner.src_stage_mask = src_stage_mask;
54509         self
54510     }
54511     #[inline]
src_access_mask(mut self, src_access_mask: AccessFlags2) -> Self54512     pub fn src_access_mask(mut self, src_access_mask: AccessFlags2) -> Self {
54513         self.inner.src_access_mask = src_access_mask;
54514         self
54515     }
54516     #[inline]
dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags2) -> Self54517     pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags2) -> Self {
54518         self.inner.dst_stage_mask = dst_stage_mask;
54519         self
54520     }
54521     #[inline]
dst_access_mask(mut self, dst_access_mask: AccessFlags2) -> Self54522     pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags2) -> Self {
54523         self.inner.dst_access_mask = dst_access_mask;
54524         self
54525     }
54526     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54527     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54528     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryBarrier254529     pub fn build(self) -> MemoryBarrier2 {
54530         self.inner
54531     }
54532 }
54533 #[repr(C)]
54534 #[cfg_attr(feature = "debug", derive(Debug))]
54535 #[derive(Copy, Clone)]
54536 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageMemoryBarrier2.html>"]
54537 pub struct ImageMemoryBarrier2 {
54538     pub s_type: StructureType,
54539     pub p_next: *const c_void,
54540     pub src_stage_mask: PipelineStageFlags2,
54541     pub src_access_mask: AccessFlags2,
54542     pub dst_stage_mask: PipelineStageFlags2,
54543     pub dst_access_mask: AccessFlags2,
54544     pub old_layout: ImageLayout,
54545     pub new_layout: ImageLayout,
54546     pub src_queue_family_index: u32,
54547     pub dst_queue_family_index: u32,
54548     pub image: Image,
54549     pub subresource_range: ImageSubresourceRange,
54550 }
54551 impl ::std::default::Default for ImageMemoryBarrier2 {
54552     #[inline]
default() -> Self54553     fn default() -> Self {
54554         Self {
54555             s_type: Self::STRUCTURE_TYPE,
54556             p_next: ::std::ptr::null(),
54557             src_stage_mask: PipelineStageFlags2::default(),
54558             src_access_mask: AccessFlags2::default(),
54559             dst_stage_mask: PipelineStageFlags2::default(),
54560             dst_access_mask: AccessFlags2::default(),
54561             old_layout: ImageLayout::default(),
54562             new_layout: ImageLayout::default(),
54563             src_queue_family_index: u32::default(),
54564             dst_queue_family_index: u32::default(),
54565             image: Image::default(),
54566             subresource_range: ImageSubresourceRange::default(),
54567         }
54568     }
54569 }
54570 unsafe impl TaggedStructure for ImageMemoryBarrier2 {
54571     const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_MEMORY_BARRIER_2;
54572 }
54573 impl ImageMemoryBarrier2 {
builder<'a>() -> ImageMemoryBarrier2Builder<'a>54574     pub fn builder<'a>() -> ImageMemoryBarrier2Builder<'a> {
54575         ImageMemoryBarrier2Builder {
54576             inner: Self::default(),
54577             marker: ::std::marker::PhantomData,
54578         }
54579     }
54580 }
54581 #[repr(transparent)]
54582 pub struct ImageMemoryBarrier2Builder<'a> {
54583     inner: ImageMemoryBarrier2,
54584     marker: ::std::marker::PhantomData<&'a ()>,
54585 }
54586 pub unsafe trait ExtendsImageMemoryBarrier2 {}
54587 impl<'a> ::std::ops::Deref for ImageMemoryBarrier2Builder<'a> {
54588     type Target = ImageMemoryBarrier2;
deref(&self) -> &Self::Target54589     fn deref(&self) -> &Self::Target {
54590         &self.inner
54591     }
54592 }
54593 impl<'a> ::std::ops::DerefMut for ImageMemoryBarrier2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target54594     fn deref_mut(&mut self) -> &mut Self::Target {
54595         &mut self.inner
54596     }
54597 }
54598 impl<'a> ImageMemoryBarrier2Builder<'a> {
54599     #[inline]
src_stage_mask(mut self, src_stage_mask: PipelineStageFlags2) -> Self54600     pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags2) -> Self {
54601         self.inner.src_stage_mask = src_stage_mask;
54602         self
54603     }
54604     #[inline]
src_access_mask(mut self, src_access_mask: AccessFlags2) -> Self54605     pub fn src_access_mask(mut self, src_access_mask: AccessFlags2) -> Self {
54606         self.inner.src_access_mask = src_access_mask;
54607         self
54608     }
54609     #[inline]
dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags2) -> Self54610     pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags2) -> Self {
54611         self.inner.dst_stage_mask = dst_stage_mask;
54612         self
54613     }
54614     #[inline]
dst_access_mask(mut self, dst_access_mask: AccessFlags2) -> Self54615     pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags2) -> Self {
54616         self.inner.dst_access_mask = dst_access_mask;
54617         self
54618     }
54619     #[inline]
old_layout(mut self, old_layout: ImageLayout) -> Self54620     pub fn old_layout(mut self, old_layout: ImageLayout) -> Self {
54621         self.inner.old_layout = old_layout;
54622         self
54623     }
54624     #[inline]
new_layout(mut self, new_layout: ImageLayout) -> Self54625     pub fn new_layout(mut self, new_layout: ImageLayout) -> Self {
54626         self.inner.new_layout = new_layout;
54627         self
54628     }
54629     #[inline]
src_queue_family_index(mut self, src_queue_family_index: u32) -> Self54630     pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self {
54631         self.inner.src_queue_family_index = src_queue_family_index;
54632         self
54633     }
54634     #[inline]
dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self54635     pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self {
54636         self.inner.dst_queue_family_index = dst_queue_family_index;
54637         self
54638     }
54639     #[inline]
image(mut self, image: Image) -> Self54640     pub fn image(mut self, image: Image) -> Self {
54641         self.inner.image = image;
54642         self
54643     }
54644     #[inline]
subresource_range(mut self, subresource_range: ImageSubresourceRange) -> Self54645     pub fn subresource_range(mut self, subresource_range: ImageSubresourceRange) -> Self {
54646         self.inner.subresource_range = subresource_range;
54647         self
54648     }
54649     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
54650     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
54651     #[doc = r" valid extension structs can be pushed into the chain."]
54652     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
54653     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsImageMemoryBarrier2>(mut self, next: &'a mut T) -> Self54654     pub fn push_next<T: ExtendsImageMemoryBarrier2>(mut self, next: &'a mut T) -> Self {
54655         unsafe {
54656             let next_ptr = <*const T>::cast(next);
54657             let last_next = ptr_chain_iter(next).last().unwrap();
54658             (*last_next).p_next = self.inner.p_next as _;
54659             self.inner.p_next = next_ptr;
54660         }
54661         self
54662     }
54663     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54664     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54665     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageMemoryBarrier254666     pub fn build(self) -> ImageMemoryBarrier2 {
54667         self.inner
54668     }
54669 }
54670 #[repr(C)]
54671 #[cfg_attr(feature = "debug", derive(Debug))]
54672 #[derive(Copy, Clone)]
54673 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferMemoryBarrier2.html>"]
54674 pub struct BufferMemoryBarrier2 {
54675     pub s_type: StructureType,
54676     pub p_next: *const c_void,
54677     pub src_stage_mask: PipelineStageFlags2,
54678     pub src_access_mask: AccessFlags2,
54679     pub dst_stage_mask: PipelineStageFlags2,
54680     pub dst_access_mask: AccessFlags2,
54681     pub src_queue_family_index: u32,
54682     pub dst_queue_family_index: u32,
54683     pub buffer: Buffer,
54684     pub offset: DeviceSize,
54685     pub size: DeviceSize,
54686 }
54687 impl ::std::default::Default for BufferMemoryBarrier2 {
54688     #[inline]
default() -> Self54689     fn default() -> Self {
54690         Self {
54691             s_type: Self::STRUCTURE_TYPE,
54692             p_next: ::std::ptr::null(),
54693             src_stage_mask: PipelineStageFlags2::default(),
54694             src_access_mask: AccessFlags2::default(),
54695             dst_stage_mask: PipelineStageFlags2::default(),
54696             dst_access_mask: AccessFlags2::default(),
54697             src_queue_family_index: u32::default(),
54698             dst_queue_family_index: u32::default(),
54699             buffer: Buffer::default(),
54700             offset: DeviceSize::default(),
54701             size: DeviceSize::default(),
54702         }
54703     }
54704 }
54705 unsafe impl TaggedStructure for BufferMemoryBarrier2 {
54706     const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_MEMORY_BARRIER_2;
54707 }
54708 impl BufferMemoryBarrier2 {
builder<'a>() -> BufferMemoryBarrier2Builder<'a>54709     pub fn builder<'a>() -> BufferMemoryBarrier2Builder<'a> {
54710         BufferMemoryBarrier2Builder {
54711             inner: Self::default(),
54712             marker: ::std::marker::PhantomData,
54713         }
54714     }
54715 }
54716 #[repr(transparent)]
54717 pub struct BufferMemoryBarrier2Builder<'a> {
54718     inner: BufferMemoryBarrier2,
54719     marker: ::std::marker::PhantomData<&'a ()>,
54720 }
54721 impl<'a> ::std::ops::Deref for BufferMemoryBarrier2Builder<'a> {
54722     type Target = BufferMemoryBarrier2;
deref(&self) -> &Self::Target54723     fn deref(&self) -> &Self::Target {
54724         &self.inner
54725     }
54726 }
54727 impl<'a> ::std::ops::DerefMut for BufferMemoryBarrier2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target54728     fn deref_mut(&mut self) -> &mut Self::Target {
54729         &mut self.inner
54730     }
54731 }
54732 impl<'a> BufferMemoryBarrier2Builder<'a> {
54733     #[inline]
src_stage_mask(mut self, src_stage_mask: PipelineStageFlags2) -> Self54734     pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags2) -> Self {
54735         self.inner.src_stage_mask = src_stage_mask;
54736         self
54737     }
54738     #[inline]
src_access_mask(mut self, src_access_mask: AccessFlags2) -> Self54739     pub fn src_access_mask(mut self, src_access_mask: AccessFlags2) -> Self {
54740         self.inner.src_access_mask = src_access_mask;
54741         self
54742     }
54743     #[inline]
dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags2) -> Self54744     pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags2) -> Self {
54745         self.inner.dst_stage_mask = dst_stage_mask;
54746         self
54747     }
54748     #[inline]
dst_access_mask(mut self, dst_access_mask: AccessFlags2) -> Self54749     pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags2) -> Self {
54750         self.inner.dst_access_mask = dst_access_mask;
54751         self
54752     }
54753     #[inline]
src_queue_family_index(mut self, src_queue_family_index: u32) -> Self54754     pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self {
54755         self.inner.src_queue_family_index = src_queue_family_index;
54756         self
54757     }
54758     #[inline]
dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self54759     pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self {
54760         self.inner.dst_queue_family_index = dst_queue_family_index;
54761         self
54762     }
54763     #[inline]
buffer(mut self, buffer: Buffer) -> Self54764     pub fn buffer(mut self, buffer: Buffer) -> Self {
54765         self.inner.buffer = buffer;
54766         self
54767     }
54768     #[inline]
offset(mut self, offset: DeviceSize) -> Self54769     pub fn offset(mut self, offset: DeviceSize) -> Self {
54770         self.inner.offset = offset;
54771         self
54772     }
54773     #[inline]
size(mut self, size: DeviceSize) -> Self54774     pub fn size(mut self, size: DeviceSize) -> Self {
54775         self.inner.size = size;
54776         self
54777     }
54778     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54779     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54780     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferMemoryBarrier254781     pub fn build(self) -> BufferMemoryBarrier2 {
54782         self.inner
54783     }
54784 }
54785 #[repr(C)]
54786 #[cfg_attr(feature = "debug", derive(Debug))]
54787 #[derive(Copy, Clone)]
54788 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDependencyInfo.html>"]
54789 pub struct DependencyInfo {
54790     pub s_type: StructureType,
54791     pub p_next: *const c_void,
54792     pub dependency_flags: DependencyFlags,
54793     pub memory_barrier_count: u32,
54794     pub p_memory_barriers: *const MemoryBarrier2,
54795     pub buffer_memory_barrier_count: u32,
54796     pub p_buffer_memory_barriers: *const BufferMemoryBarrier2,
54797     pub image_memory_barrier_count: u32,
54798     pub p_image_memory_barriers: *const ImageMemoryBarrier2,
54799 }
54800 impl ::std::default::Default for DependencyInfo {
54801     #[inline]
default() -> Self54802     fn default() -> Self {
54803         Self {
54804             s_type: Self::STRUCTURE_TYPE,
54805             p_next: ::std::ptr::null(),
54806             dependency_flags: DependencyFlags::default(),
54807             memory_barrier_count: u32::default(),
54808             p_memory_barriers: ::std::ptr::null(),
54809             buffer_memory_barrier_count: u32::default(),
54810             p_buffer_memory_barriers: ::std::ptr::null(),
54811             image_memory_barrier_count: u32::default(),
54812             p_image_memory_barriers: ::std::ptr::null(),
54813         }
54814     }
54815 }
54816 unsafe impl TaggedStructure for DependencyInfo {
54817     const STRUCTURE_TYPE: StructureType = StructureType::DEPENDENCY_INFO;
54818 }
54819 impl DependencyInfo {
builder<'a>() -> DependencyInfoBuilder<'a>54820     pub fn builder<'a>() -> DependencyInfoBuilder<'a> {
54821         DependencyInfoBuilder {
54822             inner: Self::default(),
54823             marker: ::std::marker::PhantomData,
54824         }
54825     }
54826 }
54827 #[repr(transparent)]
54828 pub struct DependencyInfoBuilder<'a> {
54829     inner: DependencyInfo,
54830     marker: ::std::marker::PhantomData<&'a ()>,
54831 }
54832 impl<'a> ::std::ops::Deref for DependencyInfoBuilder<'a> {
54833     type Target = DependencyInfo;
deref(&self) -> &Self::Target54834     fn deref(&self) -> &Self::Target {
54835         &self.inner
54836     }
54837 }
54838 impl<'a> ::std::ops::DerefMut for DependencyInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target54839     fn deref_mut(&mut self) -> &mut Self::Target {
54840         &mut self.inner
54841     }
54842 }
54843 impl<'a> DependencyInfoBuilder<'a> {
54844     #[inline]
dependency_flags(mut self, dependency_flags: DependencyFlags) -> Self54845     pub fn dependency_flags(mut self, dependency_flags: DependencyFlags) -> Self {
54846         self.inner.dependency_flags = dependency_flags;
54847         self
54848     }
54849     #[inline]
memory_barriers(mut self, memory_barriers: &'a [MemoryBarrier2]) -> Self54850     pub fn memory_barriers(mut self, memory_barriers: &'a [MemoryBarrier2]) -> Self {
54851         self.inner.memory_barrier_count = memory_barriers.len() as _;
54852         self.inner.p_memory_barriers = memory_barriers.as_ptr();
54853         self
54854     }
54855     #[inline]
buffer_memory_barriers( mut self, buffer_memory_barriers: &'a [BufferMemoryBarrier2], ) -> Self54856     pub fn buffer_memory_barriers(
54857         mut self,
54858         buffer_memory_barriers: &'a [BufferMemoryBarrier2],
54859     ) -> Self {
54860         self.inner.buffer_memory_barrier_count = buffer_memory_barriers.len() as _;
54861         self.inner.p_buffer_memory_barriers = buffer_memory_barriers.as_ptr();
54862         self
54863     }
54864     #[inline]
image_memory_barriers( mut self, image_memory_barriers: &'a [ImageMemoryBarrier2], ) -> Self54865     pub fn image_memory_barriers(
54866         mut self,
54867         image_memory_barriers: &'a [ImageMemoryBarrier2],
54868     ) -> Self {
54869         self.inner.image_memory_barrier_count = image_memory_barriers.len() as _;
54870         self.inner.p_image_memory_barriers = image_memory_barriers.as_ptr();
54871         self
54872     }
54873     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54874     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54875     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DependencyInfo54876     pub fn build(self) -> DependencyInfo {
54877         self.inner
54878     }
54879 }
54880 #[repr(C)]
54881 #[cfg_attr(feature = "debug", derive(Debug))]
54882 #[derive(Copy, Clone)]
54883 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreSubmitInfo.html>"]
54884 pub struct SemaphoreSubmitInfo {
54885     pub s_type: StructureType,
54886     pub p_next: *const c_void,
54887     pub semaphore: Semaphore,
54888     pub value: u64,
54889     pub stage_mask: PipelineStageFlags2,
54890     pub device_index: u32,
54891 }
54892 impl ::std::default::Default for SemaphoreSubmitInfo {
54893     #[inline]
default() -> Self54894     fn default() -> Self {
54895         Self {
54896             s_type: Self::STRUCTURE_TYPE,
54897             p_next: ::std::ptr::null(),
54898             semaphore: Semaphore::default(),
54899             value: u64::default(),
54900             stage_mask: PipelineStageFlags2::default(),
54901             device_index: u32::default(),
54902         }
54903     }
54904 }
54905 unsafe impl TaggedStructure for SemaphoreSubmitInfo {
54906     const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_SUBMIT_INFO;
54907 }
54908 impl SemaphoreSubmitInfo {
builder<'a>() -> SemaphoreSubmitInfoBuilder<'a>54909     pub fn builder<'a>() -> SemaphoreSubmitInfoBuilder<'a> {
54910         SemaphoreSubmitInfoBuilder {
54911             inner: Self::default(),
54912             marker: ::std::marker::PhantomData,
54913         }
54914     }
54915 }
54916 #[repr(transparent)]
54917 pub struct SemaphoreSubmitInfoBuilder<'a> {
54918     inner: SemaphoreSubmitInfo,
54919     marker: ::std::marker::PhantomData<&'a ()>,
54920 }
54921 impl<'a> ::std::ops::Deref for SemaphoreSubmitInfoBuilder<'a> {
54922     type Target = SemaphoreSubmitInfo;
deref(&self) -> &Self::Target54923     fn deref(&self) -> &Self::Target {
54924         &self.inner
54925     }
54926 }
54927 impl<'a> ::std::ops::DerefMut for SemaphoreSubmitInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target54928     fn deref_mut(&mut self) -> &mut Self::Target {
54929         &mut self.inner
54930     }
54931 }
54932 impl<'a> SemaphoreSubmitInfoBuilder<'a> {
54933     #[inline]
semaphore(mut self, semaphore: Semaphore) -> Self54934     pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
54935         self.inner.semaphore = semaphore;
54936         self
54937     }
54938     #[inline]
value(mut self, value: u64) -> Self54939     pub fn value(mut self, value: u64) -> Self {
54940         self.inner.value = value;
54941         self
54942     }
54943     #[inline]
stage_mask(mut self, stage_mask: PipelineStageFlags2) -> Self54944     pub fn stage_mask(mut self, stage_mask: PipelineStageFlags2) -> Self {
54945         self.inner.stage_mask = stage_mask;
54946         self
54947     }
54948     #[inline]
device_index(mut self, device_index: u32) -> Self54949     pub fn device_index(mut self, device_index: u32) -> Self {
54950         self.inner.device_index = device_index;
54951         self
54952     }
54953     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54954     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54955     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SemaphoreSubmitInfo54956     pub fn build(self) -> SemaphoreSubmitInfo {
54957         self.inner
54958     }
54959 }
54960 #[repr(C)]
54961 #[cfg_attr(feature = "debug", derive(Debug))]
54962 #[derive(Copy, Clone)]
54963 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferSubmitInfo.html>"]
54964 pub struct CommandBufferSubmitInfo {
54965     pub s_type: StructureType,
54966     pub p_next: *const c_void,
54967     pub command_buffer: CommandBuffer,
54968     pub device_mask: u32,
54969 }
54970 impl ::std::default::Default for CommandBufferSubmitInfo {
54971     #[inline]
default() -> Self54972     fn default() -> Self {
54973         Self {
54974             s_type: Self::STRUCTURE_TYPE,
54975             p_next: ::std::ptr::null(),
54976             command_buffer: CommandBuffer::default(),
54977             device_mask: u32::default(),
54978         }
54979     }
54980 }
54981 unsafe impl TaggedStructure for CommandBufferSubmitInfo {
54982     const STRUCTURE_TYPE: StructureType = StructureType::COMMAND_BUFFER_SUBMIT_INFO;
54983 }
54984 impl CommandBufferSubmitInfo {
builder<'a>() -> CommandBufferSubmitInfoBuilder<'a>54985     pub fn builder<'a>() -> CommandBufferSubmitInfoBuilder<'a> {
54986         CommandBufferSubmitInfoBuilder {
54987             inner: Self::default(),
54988             marker: ::std::marker::PhantomData,
54989         }
54990     }
54991 }
54992 #[repr(transparent)]
54993 pub struct CommandBufferSubmitInfoBuilder<'a> {
54994     inner: CommandBufferSubmitInfo,
54995     marker: ::std::marker::PhantomData<&'a ()>,
54996 }
54997 impl<'a> ::std::ops::Deref for CommandBufferSubmitInfoBuilder<'a> {
54998     type Target = CommandBufferSubmitInfo;
deref(&self) -> &Self::Target54999     fn deref(&self) -> &Self::Target {
55000         &self.inner
55001     }
55002 }
55003 impl<'a> ::std::ops::DerefMut for CommandBufferSubmitInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target55004     fn deref_mut(&mut self) -> &mut Self::Target {
55005         &mut self.inner
55006     }
55007 }
55008 impl<'a> CommandBufferSubmitInfoBuilder<'a> {
55009     #[inline]
command_buffer(mut self, command_buffer: CommandBuffer) -> Self55010     pub fn command_buffer(mut self, command_buffer: CommandBuffer) -> Self {
55011         self.inner.command_buffer = command_buffer;
55012         self
55013     }
55014     #[inline]
device_mask(mut self, device_mask: u32) -> Self55015     pub fn device_mask(mut self, device_mask: u32) -> Self {
55016         self.inner.device_mask = device_mask;
55017         self
55018     }
55019     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55020     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55021     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CommandBufferSubmitInfo55022     pub fn build(self) -> CommandBufferSubmitInfo {
55023         self.inner
55024     }
55025 }
55026 #[repr(C)]
55027 #[cfg_attr(feature = "debug", derive(Debug))]
55028 #[derive(Copy, Clone)]
55029 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubmitInfo2.html>"]
55030 pub struct SubmitInfo2 {
55031     pub s_type: StructureType,
55032     pub p_next: *const c_void,
55033     pub flags: SubmitFlags,
55034     pub wait_semaphore_info_count: u32,
55035     pub p_wait_semaphore_infos: *const SemaphoreSubmitInfo,
55036     pub command_buffer_info_count: u32,
55037     pub p_command_buffer_infos: *const CommandBufferSubmitInfo,
55038     pub signal_semaphore_info_count: u32,
55039     pub p_signal_semaphore_infos: *const SemaphoreSubmitInfo,
55040 }
55041 impl ::std::default::Default for SubmitInfo2 {
55042     #[inline]
default() -> Self55043     fn default() -> Self {
55044         Self {
55045             s_type: Self::STRUCTURE_TYPE,
55046             p_next: ::std::ptr::null(),
55047             flags: SubmitFlags::default(),
55048             wait_semaphore_info_count: u32::default(),
55049             p_wait_semaphore_infos: ::std::ptr::null(),
55050             command_buffer_info_count: u32::default(),
55051             p_command_buffer_infos: ::std::ptr::null(),
55052             signal_semaphore_info_count: u32::default(),
55053             p_signal_semaphore_infos: ::std::ptr::null(),
55054         }
55055     }
55056 }
55057 unsafe impl TaggedStructure for SubmitInfo2 {
55058     const STRUCTURE_TYPE: StructureType = StructureType::SUBMIT_INFO_2;
55059 }
55060 impl SubmitInfo2 {
builder<'a>() -> SubmitInfo2Builder<'a>55061     pub fn builder<'a>() -> SubmitInfo2Builder<'a> {
55062         SubmitInfo2Builder {
55063             inner: Self::default(),
55064             marker: ::std::marker::PhantomData,
55065         }
55066     }
55067 }
55068 #[repr(transparent)]
55069 pub struct SubmitInfo2Builder<'a> {
55070     inner: SubmitInfo2,
55071     marker: ::std::marker::PhantomData<&'a ()>,
55072 }
55073 pub unsafe trait ExtendsSubmitInfo2 {}
55074 impl<'a> ::std::ops::Deref for SubmitInfo2Builder<'a> {
55075     type Target = SubmitInfo2;
deref(&self) -> &Self::Target55076     fn deref(&self) -> &Self::Target {
55077         &self.inner
55078     }
55079 }
55080 impl<'a> ::std::ops::DerefMut for SubmitInfo2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target55081     fn deref_mut(&mut self) -> &mut Self::Target {
55082         &mut self.inner
55083     }
55084 }
55085 impl<'a> SubmitInfo2Builder<'a> {
55086     #[inline]
flags(mut self, flags: SubmitFlags) -> Self55087     pub fn flags(mut self, flags: SubmitFlags) -> Self {
55088         self.inner.flags = flags;
55089         self
55090     }
55091     #[inline]
wait_semaphore_infos(mut self, wait_semaphore_infos: &'a [SemaphoreSubmitInfo]) -> Self55092     pub fn wait_semaphore_infos(mut self, wait_semaphore_infos: &'a [SemaphoreSubmitInfo]) -> Self {
55093         self.inner.wait_semaphore_info_count = wait_semaphore_infos.len() as _;
55094         self.inner.p_wait_semaphore_infos = wait_semaphore_infos.as_ptr();
55095         self
55096     }
55097     #[inline]
command_buffer_infos( mut self, command_buffer_infos: &'a [CommandBufferSubmitInfo], ) -> Self55098     pub fn command_buffer_infos(
55099         mut self,
55100         command_buffer_infos: &'a [CommandBufferSubmitInfo],
55101     ) -> Self {
55102         self.inner.command_buffer_info_count = command_buffer_infos.len() as _;
55103         self.inner.p_command_buffer_infos = command_buffer_infos.as_ptr();
55104         self
55105     }
55106     #[inline]
signal_semaphore_infos( mut self, signal_semaphore_infos: &'a [SemaphoreSubmitInfo], ) -> Self55107     pub fn signal_semaphore_infos(
55108         mut self,
55109         signal_semaphore_infos: &'a [SemaphoreSubmitInfo],
55110     ) -> Self {
55111         self.inner.signal_semaphore_info_count = signal_semaphore_infos.len() as _;
55112         self.inner.p_signal_semaphore_infos = signal_semaphore_infos.as_ptr();
55113         self
55114     }
55115     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
55116     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
55117     #[doc = r" valid extension structs can be pushed into the chain."]
55118     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
55119     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSubmitInfo2>(mut self, next: &'a mut T) -> Self55120     pub fn push_next<T: ExtendsSubmitInfo2>(mut self, next: &'a mut T) -> Self {
55121         unsafe {
55122             let next_ptr = <*const T>::cast(next);
55123             let last_next = ptr_chain_iter(next).last().unwrap();
55124             (*last_next).p_next = self.inner.p_next as _;
55125             self.inner.p_next = next_ptr;
55126         }
55127         self
55128     }
55129     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55130     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55131     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SubmitInfo255132     pub fn build(self) -> SubmitInfo2 {
55133         self.inner
55134     }
55135 }
55136 #[repr(C)]
55137 #[cfg_attr(feature = "debug", derive(Debug))]
55138 #[derive(Copy, Clone)]
55139 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyCheckpointProperties2NV.html>"]
55140 pub struct QueueFamilyCheckpointProperties2NV {
55141     pub s_type: StructureType,
55142     pub p_next: *mut c_void,
55143     pub checkpoint_execution_stage_mask: PipelineStageFlags2,
55144 }
55145 impl ::std::default::Default for QueueFamilyCheckpointProperties2NV {
55146     #[inline]
default() -> Self55147     fn default() -> Self {
55148         Self {
55149             s_type: Self::STRUCTURE_TYPE,
55150             p_next: ::std::ptr::null_mut(),
55151             checkpoint_execution_stage_mask: PipelineStageFlags2::default(),
55152         }
55153     }
55154 }
55155 unsafe impl TaggedStructure for QueueFamilyCheckpointProperties2NV {
55156     const STRUCTURE_TYPE: StructureType = StructureType::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV;
55157 }
55158 impl QueueFamilyCheckpointProperties2NV {
builder<'a>() -> QueueFamilyCheckpointProperties2NVBuilder<'a>55159     pub fn builder<'a>() -> QueueFamilyCheckpointProperties2NVBuilder<'a> {
55160         QueueFamilyCheckpointProperties2NVBuilder {
55161             inner: Self::default(),
55162             marker: ::std::marker::PhantomData,
55163         }
55164     }
55165 }
55166 #[repr(transparent)]
55167 pub struct QueueFamilyCheckpointProperties2NVBuilder<'a> {
55168     inner: QueueFamilyCheckpointProperties2NV,
55169     marker: ::std::marker::PhantomData<&'a ()>,
55170 }
55171 unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointProperties2NVBuilder<'_> {}
55172 unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointProperties2NV {}
55173 impl<'a> ::std::ops::Deref for QueueFamilyCheckpointProperties2NVBuilder<'a> {
55174     type Target = QueueFamilyCheckpointProperties2NV;
deref(&self) -> &Self::Target55175     fn deref(&self) -> &Self::Target {
55176         &self.inner
55177     }
55178 }
55179 impl<'a> ::std::ops::DerefMut for QueueFamilyCheckpointProperties2NVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target55180     fn deref_mut(&mut self) -> &mut Self::Target {
55181         &mut self.inner
55182     }
55183 }
55184 impl<'a> QueueFamilyCheckpointProperties2NVBuilder<'a> {
55185     #[inline]
checkpoint_execution_stage_mask( mut self, checkpoint_execution_stage_mask: PipelineStageFlags2, ) -> Self55186     pub fn checkpoint_execution_stage_mask(
55187         mut self,
55188         checkpoint_execution_stage_mask: PipelineStageFlags2,
55189     ) -> Self {
55190         self.inner.checkpoint_execution_stage_mask = checkpoint_execution_stage_mask;
55191         self
55192     }
55193     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55194     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55195     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> QueueFamilyCheckpointProperties2NV55196     pub fn build(self) -> QueueFamilyCheckpointProperties2NV {
55197         self.inner
55198     }
55199 }
55200 #[repr(C)]
55201 #[cfg_attr(feature = "debug", derive(Debug))]
55202 #[derive(Copy, Clone)]
55203 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCheckpointData2NV.html>"]
55204 pub struct CheckpointData2NV {
55205     pub s_type: StructureType,
55206     pub p_next: *mut c_void,
55207     pub stage: PipelineStageFlags2,
55208     pub p_checkpoint_marker: *mut c_void,
55209 }
55210 impl ::std::default::Default for CheckpointData2NV {
55211     #[inline]
default() -> Self55212     fn default() -> Self {
55213         Self {
55214             s_type: Self::STRUCTURE_TYPE,
55215             p_next: ::std::ptr::null_mut(),
55216             stage: PipelineStageFlags2::default(),
55217             p_checkpoint_marker: ::std::ptr::null_mut(),
55218         }
55219     }
55220 }
55221 unsafe impl TaggedStructure for CheckpointData2NV {
55222     const STRUCTURE_TYPE: StructureType = StructureType::CHECKPOINT_DATA_2_NV;
55223 }
55224 impl CheckpointData2NV {
builder<'a>() -> CheckpointData2NVBuilder<'a>55225     pub fn builder<'a>() -> CheckpointData2NVBuilder<'a> {
55226         CheckpointData2NVBuilder {
55227             inner: Self::default(),
55228             marker: ::std::marker::PhantomData,
55229         }
55230     }
55231 }
55232 #[repr(transparent)]
55233 pub struct CheckpointData2NVBuilder<'a> {
55234     inner: CheckpointData2NV,
55235     marker: ::std::marker::PhantomData<&'a ()>,
55236 }
55237 impl<'a> ::std::ops::Deref for CheckpointData2NVBuilder<'a> {
55238     type Target = CheckpointData2NV;
deref(&self) -> &Self::Target55239     fn deref(&self) -> &Self::Target {
55240         &self.inner
55241     }
55242 }
55243 impl<'a> ::std::ops::DerefMut for CheckpointData2NVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target55244     fn deref_mut(&mut self) -> &mut Self::Target {
55245         &mut self.inner
55246     }
55247 }
55248 impl<'a> CheckpointData2NVBuilder<'a> {
55249     #[inline]
stage(mut self, stage: PipelineStageFlags2) -> Self55250     pub fn stage(mut self, stage: PipelineStageFlags2) -> Self {
55251         self.inner.stage = stage;
55252         self
55253     }
55254     #[inline]
checkpoint_marker(mut self, checkpoint_marker: *mut c_void) -> Self55255     pub fn checkpoint_marker(mut self, checkpoint_marker: *mut c_void) -> Self {
55256         self.inner.p_checkpoint_marker = checkpoint_marker;
55257         self
55258     }
55259     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55260     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55261     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CheckpointData2NV55262     pub fn build(self) -> CheckpointData2NV {
55263         self.inner
55264     }
55265 }
55266 #[repr(C)]
55267 #[cfg_attr(feature = "debug", derive(Debug))]
55268 #[derive(Copy, Clone)]
55269 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSynchronization2Features.html>"]
55270 pub struct PhysicalDeviceSynchronization2Features {
55271     pub s_type: StructureType,
55272     pub p_next: *mut c_void,
55273     pub synchronization2: Bool32,
55274 }
55275 impl ::std::default::Default for PhysicalDeviceSynchronization2Features {
55276     #[inline]
default() -> Self55277     fn default() -> Self {
55278         Self {
55279             s_type: Self::STRUCTURE_TYPE,
55280             p_next: ::std::ptr::null_mut(),
55281             synchronization2: Bool32::default(),
55282         }
55283     }
55284 }
55285 unsafe impl TaggedStructure for PhysicalDeviceSynchronization2Features {
55286     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
55287 }
55288 impl PhysicalDeviceSynchronization2Features {
builder<'a>() -> PhysicalDeviceSynchronization2FeaturesBuilder<'a>55289     pub fn builder<'a>() -> PhysicalDeviceSynchronization2FeaturesBuilder<'a> {
55290         PhysicalDeviceSynchronization2FeaturesBuilder {
55291             inner: Self::default(),
55292             marker: ::std::marker::PhantomData,
55293         }
55294     }
55295 }
55296 #[repr(transparent)]
55297 pub struct PhysicalDeviceSynchronization2FeaturesBuilder<'a> {
55298     inner: PhysicalDeviceSynchronization2Features,
55299     marker: ::std::marker::PhantomData<&'a ()>,
55300 }
55301 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSynchronization2FeaturesBuilder<'_> {}
55302 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSynchronization2Features {}
55303 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSynchronization2FeaturesBuilder<'_> {}
55304 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSynchronization2Features {}
55305 impl<'a> ::std::ops::Deref for PhysicalDeviceSynchronization2FeaturesBuilder<'a> {
55306     type Target = PhysicalDeviceSynchronization2Features;
deref(&self) -> &Self::Target55307     fn deref(&self) -> &Self::Target {
55308         &self.inner
55309     }
55310 }
55311 impl<'a> ::std::ops::DerefMut for PhysicalDeviceSynchronization2FeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target55312     fn deref_mut(&mut self) -> &mut Self::Target {
55313         &mut self.inner
55314     }
55315 }
55316 impl<'a> PhysicalDeviceSynchronization2FeaturesBuilder<'a> {
55317     #[inline]
synchronization2(mut self, synchronization2: bool) -> Self55318     pub fn synchronization2(mut self, synchronization2: bool) -> Self {
55319         self.inner.synchronization2 = synchronization2.into();
55320         self
55321     }
55322     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55323     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55324     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceSynchronization2Features55325     pub fn build(self) -> PhysicalDeviceSynchronization2Features {
55326         self.inner
55327     }
55328 }
55329 #[repr(C)]
55330 #[cfg_attr(feature = "debug", derive(Debug))]
55331 #[derive(Copy, Clone)]
55332 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT.html>"]
55333 pub struct PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {
55334     pub s_type: StructureType,
55335     pub p_next: *mut c_void,
55336     pub primitives_generated_query: Bool32,
55337     pub primitives_generated_query_with_rasterizer_discard: Bool32,
55338     pub primitives_generated_query_with_non_zero_streams: Bool32,
55339 }
55340 impl ::std::default::Default for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {
55341     #[inline]
default() -> Self55342     fn default() -> Self {
55343         Self {
55344             s_type: Self::STRUCTURE_TYPE,
55345             p_next: ::std::ptr::null_mut(),
55346             primitives_generated_query: Bool32::default(),
55347             primitives_generated_query_with_rasterizer_discard: Bool32::default(),
55348             primitives_generated_query_with_non_zero_streams: Bool32::default(),
55349         }
55350     }
55351 }
55352 unsafe impl TaggedStructure for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {
55353     const STRUCTURE_TYPE: StructureType =
55354         StructureType::PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
55355 }
55356 impl PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {
builder<'a>() -> PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'a>55357     pub fn builder<'a>() -> PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'a> {
55358         PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder {
55359             inner: Self::default(),
55360             marker: ::std::marker::PhantomData,
55361         }
55362     }
55363 }
55364 #[repr(transparent)]
55365 pub struct PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'a> {
55366     inner: PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT,
55367     marker: ::std::marker::PhantomData<&'a ()>,
55368 }
55369 unsafe impl ExtendsPhysicalDeviceFeatures2
55370     for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'_>
55371 {
55372 }
55373 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {}
55374 unsafe impl ExtendsDeviceCreateInfo
55375     for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'_>
55376 {
55377 }
55378 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {}
55379 impl<'a> ::std::ops::Deref for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'a> {
55380     type Target = PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT;
deref(&self) -> &Self::Target55381     fn deref(&self) -> &Self::Target {
55382         &self.inner
55383     }
55384 }
55385 impl<'a> ::std::ops::DerefMut for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target55386     fn deref_mut(&mut self) -> &mut Self::Target {
55387         &mut self.inner
55388     }
55389 }
55390 impl<'a> PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'a> {
55391     #[inline]
primitives_generated_query(mut self, primitives_generated_query: bool) -> Self55392     pub fn primitives_generated_query(mut self, primitives_generated_query: bool) -> Self {
55393         self.inner.primitives_generated_query = primitives_generated_query.into();
55394         self
55395     }
55396     #[inline]
primitives_generated_query_with_rasterizer_discard( mut self, primitives_generated_query_with_rasterizer_discard: bool, ) -> Self55397     pub fn primitives_generated_query_with_rasterizer_discard(
55398         mut self,
55399         primitives_generated_query_with_rasterizer_discard: bool,
55400     ) -> Self {
55401         self.inner
55402             .primitives_generated_query_with_rasterizer_discard =
55403             primitives_generated_query_with_rasterizer_discard.into();
55404         self
55405     }
55406     #[inline]
primitives_generated_query_with_non_zero_streams( mut self, primitives_generated_query_with_non_zero_streams: bool, ) -> Self55407     pub fn primitives_generated_query_with_non_zero_streams(
55408         mut self,
55409         primitives_generated_query_with_non_zero_streams: bool,
55410     ) -> Self {
55411         self.inner.primitives_generated_query_with_non_zero_streams =
55412             primitives_generated_query_with_non_zero_streams.into();
55413         self
55414     }
55415     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55416     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55417     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT55418     pub fn build(self) -> PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {
55419         self.inner
55420     }
55421 }
55422 #[repr(C)]
55423 #[cfg_attr(feature = "debug", derive(Debug))]
55424 #[derive(Copy, Clone)]
55425 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceLegacyDitheringFeaturesEXT.html>"]
55426 pub struct PhysicalDeviceLegacyDitheringFeaturesEXT {
55427     pub s_type: StructureType,
55428     pub p_next: *mut c_void,
55429     pub legacy_dithering: Bool32,
55430 }
55431 impl ::std::default::Default for PhysicalDeviceLegacyDitheringFeaturesEXT {
55432     #[inline]
default() -> Self55433     fn default() -> Self {
55434         Self {
55435             s_type: Self::STRUCTURE_TYPE,
55436             p_next: ::std::ptr::null_mut(),
55437             legacy_dithering: Bool32::default(),
55438         }
55439     }
55440 }
55441 unsafe impl TaggedStructure for PhysicalDeviceLegacyDitheringFeaturesEXT {
55442     const STRUCTURE_TYPE: StructureType =
55443         StructureType::PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
55444 }
55445 impl PhysicalDeviceLegacyDitheringFeaturesEXT {
builder<'a>() -> PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'a>55446     pub fn builder<'a>() -> PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'a> {
55447         PhysicalDeviceLegacyDitheringFeaturesEXTBuilder {
55448             inner: Self::default(),
55449             marker: ::std::marker::PhantomData,
55450         }
55451     }
55452 }
55453 #[repr(transparent)]
55454 pub struct PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'a> {
55455     inner: PhysicalDeviceLegacyDitheringFeaturesEXT,
55456     marker: ::std::marker::PhantomData<&'a ()>,
55457 }
55458 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'_> {}
55459 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLegacyDitheringFeaturesEXT {}
55460 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'_> {}
55461 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLegacyDitheringFeaturesEXT {}
55462 impl<'a> ::std::ops::Deref for PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'a> {
55463     type Target = PhysicalDeviceLegacyDitheringFeaturesEXT;
deref(&self) -> &Self::Target55464     fn deref(&self) -> &Self::Target {
55465         &self.inner
55466     }
55467 }
55468 impl<'a> ::std::ops::DerefMut for PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target55469     fn deref_mut(&mut self) -> &mut Self::Target {
55470         &mut self.inner
55471     }
55472 }
55473 impl<'a> PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'a> {
55474     #[inline]
legacy_dithering(mut self, legacy_dithering: bool) -> Self55475     pub fn legacy_dithering(mut self, legacy_dithering: bool) -> Self {
55476         self.inner.legacy_dithering = legacy_dithering.into();
55477         self
55478     }
55479     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55480     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55481     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceLegacyDitheringFeaturesEXT55482     pub fn build(self) -> PhysicalDeviceLegacyDitheringFeaturesEXT {
55483         self.inner
55484     }
55485 }
55486 #[repr(C)]
55487 #[cfg_attr(feature = "debug", derive(Debug))]
55488 #[derive(Copy, Clone)]
55489 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.html>"]
55490 pub struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {
55491     pub s_type: StructureType,
55492     pub p_next: *mut c_void,
55493     pub multisampled_render_to_single_sampled: Bool32,
55494 }
55495 impl ::std::default::Default for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {
55496     #[inline]
default() -> Self55497     fn default() -> Self {
55498         Self {
55499             s_type: Self::STRUCTURE_TYPE,
55500             p_next: ::std::ptr::null_mut(),
55501             multisampled_render_to_single_sampled: Bool32::default(),
55502         }
55503     }
55504 }
55505 unsafe impl TaggedStructure for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {
55506     const STRUCTURE_TYPE: StructureType =
55507         StructureType::PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
55508 }
55509 impl PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {
builder<'a>() -> PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a>55510     pub fn builder<'a>() -> PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a> {
55511         PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder {
55512             inner: Self::default(),
55513             marker: ::std::marker::PhantomData,
55514         }
55515     }
55516 }
55517 #[repr(transparent)]
55518 pub struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a> {
55519     inner: PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT,
55520     marker: ::std::marker::PhantomData<&'a ()>,
55521 }
55522 unsafe impl ExtendsPhysicalDeviceFeatures2
55523     for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'_>
55524 {
55525 }
55526 unsafe impl ExtendsPhysicalDeviceFeatures2
55527     for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT
55528 {
55529 }
55530 unsafe impl ExtendsDeviceCreateInfo
55531     for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'_>
55532 {
55533 }
55534 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {}
55535 impl<'a> ::std::ops::Deref
55536     for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a>
55537 {
55538     type Target = PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT;
deref(&self) -> &Self::Target55539     fn deref(&self) -> &Self::Target {
55540         &self.inner
55541     }
55542 }
55543 impl<'a> ::std::ops::DerefMut
55544     for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a>
55545 {
deref_mut(&mut self) -> &mut Self::Target55546     fn deref_mut(&mut self) -> &mut Self::Target {
55547         &mut self.inner
55548     }
55549 }
55550 impl<'a> PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a> {
55551     #[inline]
multisampled_render_to_single_sampled( mut self, multisampled_render_to_single_sampled: bool, ) -> Self55552     pub fn multisampled_render_to_single_sampled(
55553         mut self,
55554         multisampled_render_to_single_sampled: bool,
55555     ) -> Self {
55556         self.inner.multisampled_render_to_single_sampled =
55557             multisampled_render_to_single_sampled.into();
55558         self
55559     }
55560     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55561     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55562     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT55563     pub fn build(self) -> PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {
55564         self.inner
55565     }
55566 }
55567 #[repr(C)]
55568 #[cfg_attr(feature = "debug", derive(Debug))]
55569 #[derive(Copy, Clone)]
55570 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassResolvePerformanceQueryEXT.html>"]
55571 pub struct SubpassResolvePerformanceQueryEXT {
55572     pub s_type: StructureType,
55573     pub p_next: *mut c_void,
55574     pub optimal: Bool32,
55575 }
55576 impl ::std::default::Default for SubpassResolvePerformanceQueryEXT {
55577     #[inline]
default() -> Self55578     fn default() -> Self {
55579         Self {
55580             s_type: Self::STRUCTURE_TYPE,
55581             p_next: ::std::ptr::null_mut(),
55582             optimal: Bool32::default(),
55583         }
55584     }
55585 }
55586 unsafe impl TaggedStructure for SubpassResolvePerformanceQueryEXT {
55587     const STRUCTURE_TYPE: StructureType = StructureType::SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT;
55588 }
55589 impl SubpassResolvePerformanceQueryEXT {
builder<'a>() -> SubpassResolvePerformanceQueryEXTBuilder<'a>55590     pub fn builder<'a>() -> SubpassResolvePerformanceQueryEXTBuilder<'a> {
55591         SubpassResolvePerformanceQueryEXTBuilder {
55592             inner: Self::default(),
55593             marker: ::std::marker::PhantomData,
55594         }
55595     }
55596 }
55597 #[repr(transparent)]
55598 pub struct SubpassResolvePerformanceQueryEXTBuilder<'a> {
55599     inner: SubpassResolvePerformanceQueryEXT,
55600     marker: ::std::marker::PhantomData<&'a ()>,
55601 }
55602 unsafe impl ExtendsFormatProperties2 for SubpassResolvePerformanceQueryEXTBuilder<'_> {}
55603 unsafe impl ExtendsFormatProperties2 for SubpassResolvePerformanceQueryEXT {}
55604 impl<'a> ::std::ops::Deref for SubpassResolvePerformanceQueryEXTBuilder<'a> {
55605     type Target = SubpassResolvePerformanceQueryEXT;
deref(&self) -> &Self::Target55606     fn deref(&self) -> &Self::Target {
55607         &self.inner
55608     }
55609 }
55610 impl<'a> ::std::ops::DerefMut for SubpassResolvePerformanceQueryEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target55611     fn deref_mut(&mut self) -> &mut Self::Target {
55612         &mut self.inner
55613     }
55614 }
55615 impl<'a> SubpassResolvePerformanceQueryEXTBuilder<'a> {
55616     #[inline]
optimal(mut self, optimal: bool) -> Self55617     pub fn optimal(mut self, optimal: bool) -> Self {
55618         self.inner.optimal = optimal.into();
55619         self
55620     }
55621     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55622     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55623     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SubpassResolvePerformanceQueryEXT55624     pub fn build(self) -> SubpassResolvePerformanceQueryEXT {
55625         self.inner
55626     }
55627 }
55628 #[repr(C)]
55629 #[cfg_attr(feature = "debug", derive(Debug))]
55630 #[derive(Copy, Clone)]
55631 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMultisampledRenderToSingleSampledInfoEXT.html>"]
55632 pub struct MultisampledRenderToSingleSampledInfoEXT {
55633     pub s_type: StructureType,
55634     pub p_next: *const c_void,
55635     pub multisampled_render_to_single_sampled_enable: Bool32,
55636     pub rasterization_samples: SampleCountFlags,
55637 }
55638 impl ::std::default::Default for MultisampledRenderToSingleSampledInfoEXT {
55639     #[inline]
default() -> Self55640     fn default() -> Self {
55641         Self {
55642             s_type: Self::STRUCTURE_TYPE,
55643             p_next: ::std::ptr::null(),
55644             multisampled_render_to_single_sampled_enable: Bool32::default(),
55645             rasterization_samples: SampleCountFlags::default(),
55646         }
55647     }
55648 }
55649 unsafe impl TaggedStructure for MultisampledRenderToSingleSampledInfoEXT {
55650     const STRUCTURE_TYPE: StructureType =
55651         StructureType::MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT;
55652 }
55653 impl MultisampledRenderToSingleSampledInfoEXT {
builder<'a>() -> MultisampledRenderToSingleSampledInfoEXTBuilder<'a>55654     pub fn builder<'a>() -> MultisampledRenderToSingleSampledInfoEXTBuilder<'a> {
55655         MultisampledRenderToSingleSampledInfoEXTBuilder {
55656             inner: Self::default(),
55657             marker: ::std::marker::PhantomData,
55658         }
55659     }
55660 }
55661 #[repr(transparent)]
55662 pub struct MultisampledRenderToSingleSampledInfoEXTBuilder<'a> {
55663     inner: MultisampledRenderToSingleSampledInfoEXT,
55664     marker: ::std::marker::PhantomData<&'a ()>,
55665 }
55666 unsafe impl ExtendsSubpassDescription2 for MultisampledRenderToSingleSampledInfoEXTBuilder<'_> {}
55667 unsafe impl ExtendsSubpassDescription2 for MultisampledRenderToSingleSampledInfoEXT {}
55668 unsafe impl ExtendsRenderingInfo for MultisampledRenderToSingleSampledInfoEXTBuilder<'_> {}
55669 unsafe impl ExtendsRenderingInfo for MultisampledRenderToSingleSampledInfoEXT {}
55670 impl<'a> ::std::ops::Deref for MultisampledRenderToSingleSampledInfoEXTBuilder<'a> {
55671     type Target = MultisampledRenderToSingleSampledInfoEXT;
deref(&self) -> &Self::Target55672     fn deref(&self) -> &Self::Target {
55673         &self.inner
55674     }
55675 }
55676 impl<'a> ::std::ops::DerefMut for MultisampledRenderToSingleSampledInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target55677     fn deref_mut(&mut self) -> &mut Self::Target {
55678         &mut self.inner
55679     }
55680 }
55681 impl<'a> MultisampledRenderToSingleSampledInfoEXTBuilder<'a> {
55682     #[inline]
multisampled_render_to_single_sampled_enable( mut self, multisampled_render_to_single_sampled_enable: bool, ) -> Self55683     pub fn multisampled_render_to_single_sampled_enable(
55684         mut self,
55685         multisampled_render_to_single_sampled_enable: bool,
55686     ) -> Self {
55687         self.inner.multisampled_render_to_single_sampled_enable =
55688             multisampled_render_to_single_sampled_enable.into();
55689         self
55690     }
55691     #[inline]
rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self55692     pub fn rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self {
55693         self.inner.rasterization_samples = rasterization_samples;
55694         self
55695     }
55696     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55697     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55698     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MultisampledRenderToSingleSampledInfoEXT55699     pub fn build(self) -> MultisampledRenderToSingleSampledInfoEXT {
55700         self.inner
55701     }
55702 }
55703 #[repr(C)]
55704 #[cfg_attr(feature = "debug", derive(Debug))]
55705 #[derive(Copy, Clone)]
55706 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePipelineProtectedAccessFeaturesEXT.html>"]
55707 pub struct PhysicalDevicePipelineProtectedAccessFeaturesEXT {
55708     pub s_type: StructureType,
55709     pub p_next: *mut c_void,
55710     pub pipeline_protected_access: Bool32,
55711 }
55712 impl ::std::default::Default for PhysicalDevicePipelineProtectedAccessFeaturesEXT {
55713     #[inline]
default() -> Self55714     fn default() -> Self {
55715         Self {
55716             s_type: Self::STRUCTURE_TYPE,
55717             p_next: ::std::ptr::null_mut(),
55718             pipeline_protected_access: Bool32::default(),
55719         }
55720     }
55721 }
55722 unsafe impl TaggedStructure for PhysicalDevicePipelineProtectedAccessFeaturesEXT {
55723     const STRUCTURE_TYPE: StructureType =
55724         StructureType::PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT;
55725 }
55726 impl PhysicalDevicePipelineProtectedAccessFeaturesEXT {
builder<'a>() -> PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder<'a>55727     pub fn builder<'a>() -> PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder<'a> {
55728         PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder {
55729             inner: Self::default(),
55730             marker: ::std::marker::PhantomData,
55731         }
55732     }
55733 }
55734 #[repr(transparent)]
55735 pub struct PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder<'a> {
55736     inner: PhysicalDevicePipelineProtectedAccessFeaturesEXT,
55737     marker: ::std::marker::PhantomData<&'a ()>,
55738 }
55739 unsafe impl ExtendsPhysicalDeviceFeatures2
55740     for PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder<'_>
55741 {
55742 }
55743 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelineProtectedAccessFeaturesEXT {}
55744 unsafe impl ExtendsDeviceCreateInfo
55745     for PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder<'_>
55746 {
55747 }
55748 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineProtectedAccessFeaturesEXT {}
55749 impl<'a> ::std::ops::Deref for PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder<'a> {
55750     type Target = PhysicalDevicePipelineProtectedAccessFeaturesEXT;
deref(&self) -> &Self::Target55751     fn deref(&self) -> &Self::Target {
55752         &self.inner
55753     }
55754 }
55755 impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target55756     fn deref_mut(&mut self) -> &mut Self::Target {
55757         &mut self.inner
55758     }
55759 }
55760 impl<'a> PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder<'a> {
55761     #[inline]
pipeline_protected_access(mut self, pipeline_protected_access: bool) -> Self55762     pub fn pipeline_protected_access(mut self, pipeline_protected_access: bool) -> Self {
55763         self.inner.pipeline_protected_access = pipeline_protected_access.into();
55764         self
55765     }
55766     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55767     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55768     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePipelineProtectedAccessFeaturesEXT55769     pub fn build(self) -> PhysicalDevicePipelineProtectedAccessFeaturesEXT {
55770         self.inner
55771     }
55772 }
55773 #[repr(C)]
55774 #[cfg_attr(feature = "debug", derive(Debug))]
55775 #[derive(Copy, Clone)]
55776 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyVideoPropertiesKHR.html>"]
55777 pub struct QueueFamilyVideoPropertiesKHR {
55778     pub s_type: StructureType,
55779     pub p_next: *mut c_void,
55780     pub video_codec_operations: VideoCodecOperationFlagsKHR,
55781 }
55782 impl ::std::default::Default for QueueFamilyVideoPropertiesKHR {
55783     #[inline]
default() -> Self55784     fn default() -> Self {
55785         Self {
55786             s_type: Self::STRUCTURE_TYPE,
55787             p_next: ::std::ptr::null_mut(),
55788             video_codec_operations: VideoCodecOperationFlagsKHR::default(),
55789         }
55790     }
55791 }
55792 unsafe impl TaggedStructure for QueueFamilyVideoPropertiesKHR {
55793     const STRUCTURE_TYPE: StructureType = StructureType::QUEUE_FAMILY_VIDEO_PROPERTIES_KHR;
55794 }
55795 impl QueueFamilyVideoPropertiesKHR {
builder<'a>() -> QueueFamilyVideoPropertiesKHRBuilder<'a>55796     pub fn builder<'a>() -> QueueFamilyVideoPropertiesKHRBuilder<'a> {
55797         QueueFamilyVideoPropertiesKHRBuilder {
55798             inner: Self::default(),
55799             marker: ::std::marker::PhantomData,
55800         }
55801     }
55802 }
55803 #[repr(transparent)]
55804 pub struct QueueFamilyVideoPropertiesKHRBuilder<'a> {
55805     inner: QueueFamilyVideoPropertiesKHR,
55806     marker: ::std::marker::PhantomData<&'a ()>,
55807 }
55808 unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyVideoPropertiesKHRBuilder<'_> {}
55809 unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyVideoPropertiesKHR {}
55810 impl<'a> ::std::ops::Deref for QueueFamilyVideoPropertiesKHRBuilder<'a> {
55811     type Target = QueueFamilyVideoPropertiesKHR;
deref(&self) -> &Self::Target55812     fn deref(&self) -> &Self::Target {
55813         &self.inner
55814     }
55815 }
55816 impl<'a> ::std::ops::DerefMut for QueueFamilyVideoPropertiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target55817     fn deref_mut(&mut self) -> &mut Self::Target {
55818         &mut self.inner
55819     }
55820 }
55821 impl<'a> QueueFamilyVideoPropertiesKHRBuilder<'a> {
55822     #[inline]
video_codec_operations( mut self, video_codec_operations: VideoCodecOperationFlagsKHR, ) -> Self55823     pub fn video_codec_operations(
55824         mut self,
55825         video_codec_operations: VideoCodecOperationFlagsKHR,
55826     ) -> Self {
55827         self.inner.video_codec_operations = video_codec_operations;
55828         self
55829     }
55830     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55831     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55832     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> QueueFamilyVideoPropertiesKHR55833     pub fn build(self) -> QueueFamilyVideoPropertiesKHR {
55834         self.inner
55835     }
55836 }
55837 #[repr(C)]
55838 #[cfg_attr(feature = "debug", derive(Debug))]
55839 #[derive(Copy, Clone)]
55840 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyQueryResultStatusPropertiesKHR.html>"]
55841 pub struct QueueFamilyQueryResultStatusPropertiesKHR {
55842     pub s_type: StructureType,
55843     pub p_next: *mut c_void,
55844     pub query_result_status_support: Bool32,
55845 }
55846 impl ::std::default::Default for QueueFamilyQueryResultStatusPropertiesKHR {
55847     #[inline]
default() -> Self55848     fn default() -> Self {
55849         Self {
55850             s_type: Self::STRUCTURE_TYPE,
55851             p_next: ::std::ptr::null_mut(),
55852             query_result_status_support: Bool32::default(),
55853         }
55854     }
55855 }
55856 unsafe impl TaggedStructure for QueueFamilyQueryResultStatusPropertiesKHR {
55857     const STRUCTURE_TYPE: StructureType =
55858         StructureType::QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR;
55859 }
55860 impl QueueFamilyQueryResultStatusPropertiesKHR {
builder<'a>() -> QueueFamilyQueryResultStatusPropertiesKHRBuilder<'a>55861     pub fn builder<'a>() -> QueueFamilyQueryResultStatusPropertiesKHRBuilder<'a> {
55862         QueueFamilyQueryResultStatusPropertiesKHRBuilder {
55863             inner: Self::default(),
55864             marker: ::std::marker::PhantomData,
55865         }
55866     }
55867 }
55868 #[repr(transparent)]
55869 pub struct QueueFamilyQueryResultStatusPropertiesKHRBuilder<'a> {
55870     inner: QueueFamilyQueryResultStatusPropertiesKHR,
55871     marker: ::std::marker::PhantomData<&'a ()>,
55872 }
55873 unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyQueryResultStatusPropertiesKHRBuilder<'_> {}
55874 unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyQueryResultStatusPropertiesKHR {}
55875 impl<'a> ::std::ops::Deref for QueueFamilyQueryResultStatusPropertiesKHRBuilder<'a> {
55876     type Target = QueueFamilyQueryResultStatusPropertiesKHR;
deref(&self) -> &Self::Target55877     fn deref(&self) -> &Self::Target {
55878         &self.inner
55879     }
55880 }
55881 impl<'a> ::std::ops::DerefMut for QueueFamilyQueryResultStatusPropertiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target55882     fn deref_mut(&mut self) -> &mut Self::Target {
55883         &mut self.inner
55884     }
55885 }
55886 impl<'a> QueueFamilyQueryResultStatusPropertiesKHRBuilder<'a> {
55887     #[inline]
query_result_status_support(mut self, query_result_status_support: bool) -> Self55888     pub fn query_result_status_support(mut self, query_result_status_support: bool) -> Self {
55889         self.inner.query_result_status_support = query_result_status_support.into();
55890         self
55891     }
55892     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55893     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55894     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> QueueFamilyQueryResultStatusPropertiesKHR55895     pub fn build(self) -> QueueFamilyQueryResultStatusPropertiesKHR {
55896         self.inner
55897     }
55898 }
55899 #[repr(C)]
55900 #[cfg_attr(feature = "debug", derive(Debug))]
55901 #[derive(Copy, Clone)]
55902 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoProfileListInfoKHR.html>"]
55903 pub struct VideoProfileListInfoKHR {
55904     pub s_type: StructureType,
55905     pub p_next: *const c_void,
55906     pub profile_count: u32,
55907     pub p_profiles: *const VideoProfileInfoKHR,
55908 }
55909 impl ::std::default::Default for VideoProfileListInfoKHR {
55910     #[inline]
default() -> Self55911     fn default() -> Self {
55912         Self {
55913             s_type: Self::STRUCTURE_TYPE,
55914             p_next: ::std::ptr::null(),
55915             profile_count: u32::default(),
55916             p_profiles: ::std::ptr::null(),
55917         }
55918     }
55919 }
55920 unsafe impl TaggedStructure for VideoProfileListInfoKHR {
55921     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_PROFILE_LIST_INFO_KHR;
55922 }
55923 impl VideoProfileListInfoKHR {
builder<'a>() -> VideoProfileListInfoKHRBuilder<'a>55924     pub fn builder<'a>() -> VideoProfileListInfoKHRBuilder<'a> {
55925         VideoProfileListInfoKHRBuilder {
55926             inner: Self::default(),
55927             marker: ::std::marker::PhantomData,
55928         }
55929     }
55930 }
55931 #[repr(transparent)]
55932 pub struct VideoProfileListInfoKHRBuilder<'a> {
55933     inner: VideoProfileListInfoKHR,
55934     marker: ::std::marker::PhantomData<&'a ()>,
55935 }
55936 unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for VideoProfileListInfoKHRBuilder<'_> {}
55937 unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for VideoProfileListInfoKHR {}
55938 unsafe impl ExtendsPhysicalDeviceVideoFormatInfoKHR for VideoProfileListInfoKHRBuilder<'_> {}
55939 unsafe impl ExtendsPhysicalDeviceVideoFormatInfoKHR for VideoProfileListInfoKHR {}
55940 unsafe impl ExtendsImageCreateInfo for VideoProfileListInfoKHRBuilder<'_> {}
55941 unsafe impl ExtendsImageCreateInfo for VideoProfileListInfoKHR {}
55942 unsafe impl ExtendsBufferCreateInfo for VideoProfileListInfoKHRBuilder<'_> {}
55943 unsafe impl ExtendsBufferCreateInfo for VideoProfileListInfoKHR {}
55944 impl<'a> ::std::ops::Deref for VideoProfileListInfoKHRBuilder<'a> {
55945     type Target = VideoProfileListInfoKHR;
deref(&self) -> &Self::Target55946     fn deref(&self) -> &Self::Target {
55947         &self.inner
55948     }
55949 }
55950 impl<'a> ::std::ops::DerefMut for VideoProfileListInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target55951     fn deref_mut(&mut self) -> &mut Self::Target {
55952         &mut self.inner
55953     }
55954 }
55955 impl<'a> VideoProfileListInfoKHRBuilder<'a> {
55956     #[inline]
profiles(mut self, profiles: &'a [VideoProfileInfoKHR]) -> Self55957     pub fn profiles(mut self, profiles: &'a [VideoProfileInfoKHR]) -> Self {
55958         self.inner.profile_count = profiles.len() as _;
55959         self.inner.p_profiles = profiles.as_ptr();
55960         self
55961     }
55962     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55963     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55964     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoProfileListInfoKHR55965     pub fn build(self) -> VideoProfileListInfoKHR {
55966         self.inner
55967     }
55968 }
55969 #[repr(C)]
55970 #[cfg_attr(feature = "debug", derive(Debug))]
55971 #[derive(Copy, Clone)]
55972 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVideoFormatInfoKHR.html>"]
55973 pub struct PhysicalDeviceVideoFormatInfoKHR {
55974     pub s_type: StructureType,
55975     pub p_next: *const c_void,
55976     pub image_usage: ImageUsageFlags,
55977 }
55978 impl ::std::default::Default for PhysicalDeviceVideoFormatInfoKHR {
55979     #[inline]
default() -> Self55980     fn default() -> Self {
55981         Self {
55982             s_type: Self::STRUCTURE_TYPE,
55983             p_next: ::std::ptr::null(),
55984             image_usage: ImageUsageFlags::default(),
55985         }
55986     }
55987 }
55988 unsafe impl TaggedStructure for PhysicalDeviceVideoFormatInfoKHR {
55989     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR;
55990 }
55991 impl PhysicalDeviceVideoFormatInfoKHR {
builder<'a>() -> PhysicalDeviceVideoFormatInfoKHRBuilder<'a>55992     pub fn builder<'a>() -> PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
55993         PhysicalDeviceVideoFormatInfoKHRBuilder {
55994             inner: Self::default(),
55995             marker: ::std::marker::PhantomData,
55996         }
55997     }
55998 }
55999 #[repr(transparent)]
56000 pub struct PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
56001     inner: PhysicalDeviceVideoFormatInfoKHR,
56002     marker: ::std::marker::PhantomData<&'a ()>,
56003 }
56004 pub unsafe trait ExtendsPhysicalDeviceVideoFormatInfoKHR {}
56005 impl<'a> ::std::ops::Deref for PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
56006     type Target = PhysicalDeviceVideoFormatInfoKHR;
deref(&self) -> &Self::Target56007     fn deref(&self) -> &Self::Target {
56008         &self.inner
56009     }
56010 }
56011 impl<'a> ::std::ops::DerefMut for PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target56012     fn deref_mut(&mut self) -> &mut Self::Target {
56013         &mut self.inner
56014     }
56015 }
56016 impl<'a> PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
56017     #[inline]
image_usage(mut self, image_usage: ImageUsageFlags) -> Self56018     pub fn image_usage(mut self, image_usage: ImageUsageFlags) -> Self {
56019         self.inner.image_usage = image_usage;
56020         self
56021     }
56022     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
56023     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
56024     #[doc = r" valid extension structs can be pushed into the chain."]
56025     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
56026     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPhysicalDeviceVideoFormatInfoKHR>( mut self, next: &'a mut T, ) -> Self56027     pub fn push_next<T: ExtendsPhysicalDeviceVideoFormatInfoKHR>(
56028         mut self,
56029         next: &'a mut T,
56030     ) -> Self {
56031         unsafe {
56032             let next_ptr = <*const T>::cast(next);
56033             let last_next = ptr_chain_iter(next).last().unwrap();
56034             (*last_next).p_next = self.inner.p_next as _;
56035             self.inner.p_next = next_ptr;
56036         }
56037         self
56038     }
56039     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56040     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56041     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceVideoFormatInfoKHR56042     pub fn build(self) -> PhysicalDeviceVideoFormatInfoKHR {
56043         self.inner
56044     }
56045 }
56046 #[repr(C)]
56047 #[cfg_attr(feature = "debug", derive(Debug))]
56048 #[derive(Copy, Clone)]
56049 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoFormatPropertiesKHR.html>"]
56050 pub struct VideoFormatPropertiesKHR {
56051     pub s_type: StructureType,
56052     pub p_next: *mut c_void,
56053     pub format: Format,
56054     pub component_mapping: ComponentMapping,
56055     pub image_create_flags: ImageCreateFlags,
56056     pub image_type: ImageType,
56057     pub image_tiling: ImageTiling,
56058     pub image_usage_flags: ImageUsageFlags,
56059 }
56060 impl ::std::default::Default for VideoFormatPropertiesKHR {
56061     #[inline]
default() -> Self56062     fn default() -> Self {
56063         Self {
56064             s_type: Self::STRUCTURE_TYPE,
56065             p_next: ::std::ptr::null_mut(),
56066             format: Format::default(),
56067             component_mapping: ComponentMapping::default(),
56068             image_create_flags: ImageCreateFlags::default(),
56069             image_type: ImageType::default(),
56070             image_tiling: ImageTiling::default(),
56071             image_usage_flags: ImageUsageFlags::default(),
56072         }
56073     }
56074 }
56075 unsafe impl TaggedStructure for VideoFormatPropertiesKHR {
56076     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_FORMAT_PROPERTIES_KHR;
56077 }
56078 impl VideoFormatPropertiesKHR {
builder<'a>() -> VideoFormatPropertiesKHRBuilder<'a>56079     pub fn builder<'a>() -> VideoFormatPropertiesKHRBuilder<'a> {
56080         VideoFormatPropertiesKHRBuilder {
56081             inner: Self::default(),
56082             marker: ::std::marker::PhantomData,
56083         }
56084     }
56085 }
56086 #[repr(transparent)]
56087 pub struct VideoFormatPropertiesKHRBuilder<'a> {
56088     inner: VideoFormatPropertiesKHR,
56089     marker: ::std::marker::PhantomData<&'a ()>,
56090 }
56091 impl<'a> ::std::ops::Deref for VideoFormatPropertiesKHRBuilder<'a> {
56092     type Target = VideoFormatPropertiesKHR;
deref(&self) -> &Self::Target56093     fn deref(&self) -> &Self::Target {
56094         &self.inner
56095     }
56096 }
56097 impl<'a> ::std::ops::DerefMut for VideoFormatPropertiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target56098     fn deref_mut(&mut self) -> &mut Self::Target {
56099         &mut self.inner
56100     }
56101 }
56102 impl<'a> VideoFormatPropertiesKHRBuilder<'a> {
56103     #[inline]
format(mut self, format: Format) -> Self56104     pub fn format(mut self, format: Format) -> Self {
56105         self.inner.format = format;
56106         self
56107     }
56108     #[inline]
component_mapping(mut self, component_mapping: ComponentMapping) -> Self56109     pub fn component_mapping(mut self, component_mapping: ComponentMapping) -> Self {
56110         self.inner.component_mapping = component_mapping;
56111         self
56112     }
56113     #[inline]
image_create_flags(mut self, image_create_flags: ImageCreateFlags) -> Self56114     pub fn image_create_flags(mut self, image_create_flags: ImageCreateFlags) -> Self {
56115         self.inner.image_create_flags = image_create_flags;
56116         self
56117     }
56118     #[inline]
image_type(mut self, image_type: ImageType) -> Self56119     pub fn image_type(mut self, image_type: ImageType) -> Self {
56120         self.inner.image_type = image_type;
56121         self
56122     }
56123     #[inline]
image_tiling(mut self, image_tiling: ImageTiling) -> Self56124     pub fn image_tiling(mut self, image_tiling: ImageTiling) -> Self {
56125         self.inner.image_tiling = image_tiling;
56126         self
56127     }
56128     #[inline]
image_usage_flags(mut self, image_usage_flags: ImageUsageFlags) -> Self56129     pub fn image_usage_flags(mut self, image_usage_flags: ImageUsageFlags) -> Self {
56130         self.inner.image_usage_flags = image_usage_flags;
56131         self
56132     }
56133     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56134     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56135     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoFormatPropertiesKHR56136     pub fn build(self) -> VideoFormatPropertiesKHR {
56137         self.inner
56138     }
56139 }
56140 #[repr(C)]
56141 #[cfg_attr(feature = "debug", derive(Debug))]
56142 #[derive(Copy, Clone)]
56143 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoProfileInfoKHR.html>"]
56144 pub struct VideoProfileInfoKHR {
56145     pub s_type: StructureType,
56146     pub p_next: *const c_void,
56147     pub video_codec_operation: VideoCodecOperationFlagsKHR,
56148     pub chroma_subsampling: VideoChromaSubsamplingFlagsKHR,
56149     pub luma_bit_depth: VideoComponentBitDepthFlagsKHR,
56150     pub chroma_bit_depth: VideoComponentBitDepthFlagsKHR,
56151 }
56152 impl ::std::default::Default for VideoProfileInfoKHR {
56153     #[inline]
default() -> Self56154     fn default() -> Self {
56155         Self {
56156             s_type: Self::STRUCTURE_TYPE,
56157             p_next: ::std::ptr::null(),
56158             video_codec_operation: VideoCodecOperationFlagsKHR::default(),
56159             chroma_subsampling: VideoChromaSubsamplingFlagsKHR::default(),
56160             luma_bit_depth: VideoComponentBitDepthFlagsKHR::default(),
56161             chroma_bit_depth: VideoComponentBitDepthFlagsKHR::default(),
56162         }
56163     }
56164 }
56165 unsafe impl TaggedStructure for VideoProfileInfoKHR {
56166     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_PROFILE_INFO_KHR;
56167 }
56168 impl VideoProfileInfoKHR {
builder<'a>() -> VideoProfileInfoKHRBuilder<'a>56169     pub fn builder<'a>() -> VideoProfileInfoKHRBuilder<'a> {
56170         VideoProfileInfoKHRBuilder {
56171             inner: Self::default(),
56172             marker: ::std::marker::PhantomData,
56173         }
56174     }
56175 }
56176 #[repr(transparent)]
56177 pub struct VideoProfileInfoKHRBuilder<'a> {
56178     inner: VideoProfileInfoKHR,
56179     marker: ::std::marker::PhantomData<&'a ()>,
56180 }
56181 unsafe impl ExtendsQueryPoolCreateInfo for VideoProfileInfoKHRBuilder<'_> {}
56182 unsafe impl ExtendsQueryPoolCreateInfo for VideoProfileInfoKHR {}
56183 pub unsafe trait ExtendsVideoProfileInfoKHR {}
56184 impl<'a> ::std::ops::Deref for VideoProfileInfoKHRBuilder<'a> {
56185     type Target = VideoProfileInfoKHR;
deref(&self) -> &Self::Target56186     fn deref(&self) -> &Self::Target {
56187         &self.inner
56188     }
56189 }
56190 impl<'a> ::std::ops::DerefMut for VideoProfileInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target56191     fn deref_mut(&mut self) -> &mut Self::Target {
56192         &mut self.inner
56193     }
56194 }
56195 impl<'a> VideoProfileInfoKHRBuilder<'a> {
56196     #[inline]
video_codec_operation( mut self, video_codec_operation: VideoCodecOperationFlagsKHR, ) -> Self56197     pub fn video_codec_operation(
56198         mut self,
56199         video_codec_operation: VideoCodecOperationFlagsKHR,
56200     ) -> Self {
56201         self.inner.video_codec_operation = video_codec_operation;
56202         self
56203     }
56204     #[inline]
chroma_subsampling( mut self, chroma_subsampling: VideoChromaSubsamplingFlagsKHR, ) -> Self56205     pub fn chroma_subsampling(
56206         mut self,
56207         chroma_subsampling: VideoChromaSubsamplingFlagsKHR,
56208     ) -> Self {
56209         self.inner.chroma_subsampling = chroma_subsampling;
56210         self
56211     }
56212     #[inline]
luma_bit_depth(mut self, luma_bit_depth: VideoComponentBitDepthFlagsKHR) -> Self56213     pub fn luma_bit_depth(mut self, luma_bit_depth: VideoComponentBitDepthFlagsKHR) -> Self {
56214         self.inner.luma_bit_depth = luma_bit_depth;
56215         self
56216     }
56217     #[inline]
chroma_bit_depth(mut self, chroma_bit_depth: VideoComponentBitDepthFlagsKHR) -> Self56218     pub fn chroma_bit_depth(mut self, chroma_bit_depth: VideoComponentBitDepthFlagsKHR) -> Self {
56219         self.inner.chroma_bit_depth = chroma_bit_depth;
56220         self
56221     }
56222     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
56223     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
56224     #[doc = r" valid extension structs can be pushed into the chain."]
56225     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
56226     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsVideoProfileInfoKHR>(mut self, next: &'a mut T) -> Self56227     pub fn push_next<T: ExtendsVideoProfileInfoKHR>(mut self, next: &'a mut T) -> Self {
56228         unsafe {
56229             let next_ptr = <*const T>::cast(next);
56230             let last_next = ptr_chain_iter(next).last().unwrap();
56231             (*last_next).p_next = self.inner.p_next as _;
56232             self.inner.p_next = next_ptr;
56233         }
56234         self
56235     }
56236     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56237     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56238     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoProfileInfoKHR56239     pub fn build(self) -> VideoProfileInfoKHR {
56240         self.inner
56241     }
56242 }
56243 #[repr(C)]
56244 #[cfg_attr(feature = "debug", derive(Debug))]
56245 #[derive(Copy, Clone)]
56246 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCapabilitiesKHR.html>"]
56247 pub struct VideoCapabilitiesKHR {
56248     pub s_type: StructureType,
56249     pub p_next: *mut c_void,
56250     pub flags: VideoCapabilityFlagsKHR,
56251     pub min_bitstream_buffer_offset_alignment: DeviceSize,
56252     pub min_bitstream_buffer_size_alignment: DeviceSize,
56253     pub picture_access_granularity: Extent2D,
56254     pub min_coded_extent: Extent2D,
56255     pub max_coded_extent: Extent2D,
56256     pub max_dpb_slots: u32,
56257     pub max_active_reference_pictures: u32,
56258     pub std_header_version: ExtensionProperties,
56259 }
56260 impl ::std::default::Default for VideoCapabilitiesKHR {
56261     #[inline]
default() -> Self56262     fn default() -> Self {
56263         Self {
56264             s_type: Self::STRUCTURE_TYPE,
56265             p_next: ::std::ptr::null_mut(),
56266             flags: VideoCapabilityFlagsKHR::default(),
56267             min_bitstream_buffer_offset_alignment: DeviceSize::default(),
56268             min_bitstream_buffer_size_alignment: DeviceSize::default(),
56269             picture_access_granularity: Extent2D::default(),
56270             min_coded_extent: Extent2D::default(),
56271             max_coded_extent: Extent2D::default(),
56272             max_dpb_slots: u32::default(),
56273             max_active_reference_pictures: u32::default(),
56274             std_header_version: ExtensionProperties::default(),
56275         }
56276     }
56277 }
56278 unsafe impl TaggedStructure for VideoCapabilitiesKHR {
56279     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_CAPABILITIES_KHR;
56280 }
56281 impl VideoCapabilitiesKHR {
builder<'a>() -> VideoCapabilitiesKHRBuilder<'a>56282     pub fn builder<'a>() -> VideoCapabilitiesKHRBuilder<'a> {
56283         VideoCapabilitiesKHRBuilder {
56284             inner: Self::default(),
56285             marker: ::std::marker::PhantomData,
56286         }
56287     }
56288 }
56289 #[repr(transparent)]
56290 pub struct VideoCapabilitiesKHRBuilder<'a> {
56291     inner: VideoCapabilitiesKHR,
56292     marker: ::std::marker::PhantomData<&'a ()>,
56293 }
56294 pub unsafe trait ExtendsVideoCapabilitiesKHR {}
56295 impl<'a> ::std::ops::Deref for VideoCapabilitiesKHRBuilder<'a> {
56296     type Target = VideoCapabilitiesKHR;
deref(&self) -> &Self::Target56297     fn deref(&self) -> &Self::Target {
56298         &self.inner
56299     }
56300 }
56301 impl<'a> ::std::ops::DerefMut for VideoCapabilitiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target56302     fn deref_mut(&mut self) -> &mut Self::Target {
56303         &mut self.inner
56304     }
56305 }
56306 impl<'a> VideoCapabilitiesKHRBuilder<'a> {
56307     #[inline]
flags(mut self, flags: VideoCapabilityFlagsKHR) -> Self56308     pub fn flags(mut self, flags: VideoCapabilityFlagsKHR) -> Self {
56309         self.inner.flags = flags;
56310         self
56311     }
56312     #[inline]
min_bitstream_buffer_offset_alignment( mut self, min_bitstream_buffer_offset_alignment: DeviceSize, ) -> Self56313     pub fn min_bitstream_buffer_offset_alignment(
56314         mut self,
56315         min_bitstream_buffer_offset_alignment: DeviceSize,
56316     ) -> Self {
56317         self.inner.min_bitstream_buffer_offset_alignment = min_bitstream_buffer_offset_alignment;
56318         self
56319     }
56320     #[inline]
min_bitstream_buffer_size_alignment( mut self, min_bitstream_buffer_size_alignment: DeviceSize, ) -> Self56321     pub fn min_bitstream_buffer_size_alignment(
56322         mut self,
56323         min_bitstream_buffer_size_alignment: DeviceSize,
56324     ) -> Self {
56325         self.inner.min_bitstream_buffer_size_alignment = min_bitstream_buffer_size_alignment;
56326         self
56327     }
56328     #[inline]
picture_access_granularity(mut self, picture_access_granularity: Extent2D) -> Self56329     pub fn picture_access_granularity(mut self, picture_access_granularity: Extent2D) -> Self {
56330         self.inner.picture_access_granularity = picture_access_granularity;
56331         self
56332     }
56333     #[inline]
min_coded_extent(mut self, min_coded_extent: Extent2D) -> Self56334     pub fn min_coded_extent(mut self, min_coded_extent: Extent2D) -> Self {
56335         self.inner.min_coded_extent = min_coded_extent;
56336         self
56337     }
56338     #[inline]
max_coded_extent(mut self, max_coded_extent: Extent2D) -> Self56339     pub fn max_coded_extent(mut self, max_coded_extent: Extent2D) -> Self {
56340         self.inner.max_coded_extent = max_coded_extent;
56341         self
56342     }
56343     #[inline]
max_dpb_slots(mut self, max_dpb_slots: u32) -> Self56344     pub fn max_dpb_slots(mut self, max_dpb_slots: u32) -> Self {
56345         self.inner.max_dpb_slots = max_dpb_slots;
56346         self
56347     }
56348     #[inline]
max_active_reference_pictures(mut self, max_active_reference_pictures: u32) -> Self56349     pub fn max_active_reference_pictures(mut self, max_active_reference_pictures: u32) -> Self {
56350         self.inner.max_active_reference_pictures = max_active_reference_pictures;
56351         self
56352     }
56353     #[inline]
std_header_version(mut self, std_header_version: ExtensionProperties) -> Self56354     pub fn std_header_version(mut self, std_header_version: ExtensionProperties) -> Self {
56355         self.inner.std_header_version = std_header_version;
56356         self
56357     }
56358     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
56359     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
56360     #[doc = r" valid extension structs can be pushed into the chain."]
56361     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
56362     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsVideoCapabilitiesKHR>(mut self, next: &'a mut T) -> Self56363     pub fn push_next<T: ExtendsVideoCapabilitiesKHR>(mut self, next: &'a mut T) -> Self {
56364         unsafe {
56365             let next_ptr = <*mut T>::cast(next);
56366             let last_next = ptr_chain_iter(next).last().unwrap();
56367             (*last_next).p_next = self.inner.p_next as _;
56368             self.inner.p_next = next_ptr;
56369         }
56370         self
56371     }
56372     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56373     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56374     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoCapabilitiesKHR56375     pub fn build(self) -> VideoCapabilitiesKHR {
56376         self.inner
56377     }
56378 }
56379 #[repr(C)]
56380 #[cfg_attr(feature = "debug", derive(Debug))]
56381 #[derive(Copy, Clone)]
56382 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionMemoryRequirementsKHR.html>"]
56383 pub struct VideoSessionMemoryRequirementsKHR {
56384     pub s_type: StructureType,
56385     pub p_next: *mut c_void,
56386     pub memory_bind_index: u32,
56387     pub memory_requirements: MemoryRequirements,
56388 }
56389 impl ::std::default::Default for VideoSessionMemoryRequirementsKHR {
56390     #[inline]
default() -> Self56391     fn default() -> Self {
56392         Self {
56393             s_type: Self::STRUCTURE_TYPE,
56394             p_next: ::std::ptr::null_mut(),
56395             memory_bind_index: u32::default(),
56396             memory_requirements: MemoryRequirements::default(),
56397         }
56398     }
56399 }
56400 unsafe impl TaggedStructure for VideoSessionMemoryRequirementsKHR {
56401     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR;
56402 }
56403 impl VideoSessionMemoryRequirementsKHR {
builder<'a>() -> VideoSessionMemoryRequirementsKHRBuilder<'a>56404     pub fn builder<'a>() -> VideoSessionMemoryRequirementsKHRBuilder<'a> {
56405         VideoSessionMemoryRequirementsKHRBuilder {
56406             inner: Self::default(),
56407             marker: ::std::marker::PhantomData,
56408         }
56409     }
56410 }
56411 #[repr(transparent)]
56412 pub struct VideoSessionMemoryRequirementsKHRBuilder<'a> {
56413     inner: VideoSessionMemoryRequirementsKHR,
56414     marker: ::std::marker::PhantomData<&'a ()>,
56415 }
56416 impl<'a> ::std::ops::Deref for VideoSessionMemoryRequirementsKHRBuilder<'a> {
56417     type Target = VideoSessionMemoryRequirementsKHR;
deref(&self) -> &Self::Target56418     fn deref(&self) -> &Self::Target {
56419         &self.inner
56420     }
56421 }
56422 impl<'a> ::std::ops::DerefMut for VideoSessionMemoryRequirementsKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target56423     fn deref_mut(&mut self) -> &mut Self::Target {
56424         &mut self.inner
56425     }
56426 }
56427 impl<'a> VideoSessionMemoryRequirementsKHRBuilder<'a> {
56428     #[inline]
memory_bind_index(mut self, memory_bind_index: u32) -> Self56429     pub fn memory_bind_index(mut self, memory_bind_index: u32) -> Self {
56430         self.inner.memory_bind_index = memory_bind_index;
56431         self
56432     }
56433     #[inline]
memory_requirements(mut self, memory_requirements: MemoryRequirements) -> Self56434     pub fn memory_requirements(mut self, memory_requirements: MemoryRequirements) -> Self {
56435         self.inner.memory_requirements = memory_requirements;
56436         self
56437     }
56438     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56439     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56440     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoSessionMemoryRequirementsKHR56441     pub fn build(self) -> VideoSessionMemoryRequirementsKHR {
56442         self.inner
56443     }
56444 }
56445 #[repr(C)]
56446 #[cfg_attr(feature = "debug", derive(Debug))]
56447 #[derive(Copy, Clone)]
56448 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindVideoSessionMemoryInfoKHR.html>"]
56449 pub struct BindVideoSessionMemoryInfoKHR {
56450     pub s_type: StructureType,
56451     pub p_next: *const c_void,
56452     pub memory_bind_index: u32,
56453     pub memory: DeviceMemory,
56454     pub memory_offset: DeviceSize,
56455     pub memory_size: DeviceSize,
56456 }
56457 impl ::std::default::Default for BindVideoSessionMemoryInfoKHR {
56458     #[inline]
default() -> Self56459     fn default() -> Self {
56460         Self {
56461             s_type: Self::STRUCTURE_TYPE,
56462             p_next: ::std::ptr::null(),
56463             memory_bind_index: u32::default(),
56464             memory: DeviceMemory::default(),
56465             memory_offset: DeviceSize::default(),
56466             memory_size: DeviceSize::default(),
56467         }
56468     }
56469 }
56470 unsafe impl TaggedStructure for BindVideoSessionMemoryInfoKHR {
56471     const STRUCTURE_TYPE: StructureType = StructureType::BIND_VIDEO_SESSION_MEMORY_INFO_KHR;
56472 }
56473 impl BindVideoSessionMemoryInfoKHR {
builder<'a>() -> BindVideoSessionMemoryInfoKHRBuilder<'a>56474     pub fn builder<'a>() -> BindVideoSessionMemoryInfoKHRBuilder<'a> {
56475         BindVideoSessionMemoryInfoKHRBuilder {
56476             inner: Self::default(),
56477             marker: ::std::marker::PhantomData,
56478         }
56479     }
56480 }
56481 #[repr(transparent)]
56482 pub struct BindVideoSessionMemoryInfoKHRBuilder<'a> {
56483     inner: BindVideoSessionMemoryInfoKHR,
56484     marker: ::std::marker::PhantomData<&'a ()>,
56485 }
56486 impl<'a> ::std::ops::Deref for BindVideoSessionMemoryInfoKHRBuilder<'a> {
56487     type Target = BindVideoSessionMemoryInfoKHR;
deref(&self) -> &Self::Target56488     fn deref(&self) -> &Self::Target {
56489         &self.inner
56490     }
56491 }
56492 impl<'a> ::std::ops::DerefMut for BindVideoSessionMemoryInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target56493     fn deref_mut(&mut self) -> &mut Self::Target {
56494         &mut self.inner
56495     }
56496 }
56497 impl<'a> BindVideoSessionMemoryInfoKHRBuilder<'a> {
56498     #[inline]
memory_bind_index(mut self, memory_bind_index: u32) -> Self56499     pub fn memory_bind_index(mut self, memory_bind_index: u32) -> Self {
56500         self.inner.memory_bind_index = memory_bind_index;
56501         self
56502     }
56503     #[inline]
memory(mut self, memory: DeviceMemory) -> Self56504     pub fn memory(mut self, memory: DeviceMemory) -> Self {
56505         self.inner.memory = memory;
56506         self
56507     }
56508     #[inline]
memory_offset(mut self, memory_offset: DeviceSize) -> Self56509     pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self {
56510         self.inner.memory_offset = memory_offset;
56511         self
56512     }
56513     #[inline]
memory_size(mut self, memory_size: DeviceSize) -> Self56514     pub fn memory_size(mut self, memory_size: DeviceSize) -> Self {
56515         self.inner.memory_size = memory_size;
56516         self
56517     }
56518     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56519     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56520     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BindVideoSessionMemoryInfoKHR56521     pub fn build(self) -> BindVideoSessionMemoryInfoKHR {
56522         self.inner
56523     }
56524 }
56525 #[repr(C)]
56526 #[cfg_attr(feature = "debug", derive(Debug))]
56527 #[derive(Copy, Clone)]
56528 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoPictureResourceInfoKHR.html>"]
56529 pub struct VideoPictureResourceInfoKHR {
56530     pub s_type: StructureType,
56531     pub p_next: *const c_void,
56532     pub coded_offset: Offset2D,
56533     pub coded_extent: Extent2D,
56534     pub base_array_layer: u32,
56535     pub image_view_binding: ImageView,
56536 }
56537 impl ::std::default::Default for VideoPictureResourceInfoKHR {
56538     #[inline]
default() -> Self56539     fn default() -> Self {
56540         Self {
56541             s_type: Self::STRUCTURE_TYPE,
56542             p_next: ::std::ptr::null(),
56543             coded_offset: Offset2D::default(),
56544             coded_extent: Extent2D::default(),
56545             base_array_layer: u32::default(),
56546             image_view_binding: ImageView::default(),
56547         }
56548     }
56549 }
56550 unsafe impl TaggedStructure for VideoPictureResourceInfoKHR {
56551     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_PICTURE_RESOURCE_INFO_KHR;
56552 }
56553 impl VideoPictureResourceInfoKHR {
builder<'a>() -> VideoPictureResourceInfoKHRBuilder<'a>56554     pub fn builder<'a>() -> VideoPictureResourceInfoKHRBuilder<'a> {
56555         VideoPictureResourceInfoKHRBuilder {
56556             inner: Self::default(),
56557             marker: ::std::marker::PhantomData,
56558         }
56559     }
56560 }
56561 #[repr(transparent)]
56562 pub struct VideoPictureResourceInfoKHRBuilder<'a> {
56563     inner: VideoPictureResourceInfoKHR,
56564     marker: ::std::marker::PhantomData<&'a ()>,
56565 }
56566 impl<'a> ::std::ops::Deref for VideoPictureResourceInfoKHRBuilder<'a> {
56567     type Target = VideoPictureResourceInfoKHR;
deref(&self) -> &Self::Target56568     fn deref(&self) -> &Self::Target {
56569         &self.inner
56570     }
56571 }
56572 impl<'a> ::std::ops::DerefMut for VideoPictureResourceInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target56573     fn deref_mut(&mut self) -> &mut Self::Target {
56574         &mut self.inner
56575     }
56576 }
56577 impl<'a> VideoPictureResourceInfoKHRBuilder<'a> {
56578     #[inline]
coded_offset(mut self, coded_offset: Offset2D) -> Self56579     pub fn coded_offset(mut self, coded_offset: Offset2D) -> Self {
56580         self.inner.coded_offset = coded_offset;
56581         self
56582     }
56583     #[inline]
coded_extent(mut self, coded_extent: Extent2D) -> Self56584     pub fn coded_extent(mut self, coded_extent: Extent2D) -> Self {
56585         self.inner.coded_extent = coded_extent;
56586         self
56587     }
56588     #[inline]
base_array_layer(mut self, base_array_layer: u32) -> Self56589     pub fn base_array_layer(mut self, base_array_layer: u32) -> Self {
56590         self.inner.base_array_layer = base_array_layer;
56591         self
56592     }
56593     #[inline]
image_view_binding(mut self, image_view_binding: ImageView) -> Self56594     pub fn image_view_binding(mut self, image_view_binding: ImageView) -> Self {
56595         self.inner.image_view_binding = image_view_binding;
56596         self
56597     }
56598     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56599     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56600     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoPictureResourceInfoKHR56601     pub fn build(self) -> VideoPictureResourceInfoKHR {
56602         self.inner
56603     }
56604 }
56605 #[repr(C)]
56606 #[cfg_attr(feature = "debug", derive(Debug))]
56607 #[derive(Copy, Clone)]
56608 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoReferenceSlotInfoKHR.html>"]
56609 pub struct VideoReferenceSlotInfoKHR {
56610     pub s_type: StructureType,
56611     pub p_next: *const c_void,
56612     pub slot_index: i32,
56613     pub p_picture_resource: *const VideoPictureResourceInfoKHR,
56614 }
56615 impl ::std::default::Default for VideoReferenceSlotInfoKHR {
56616     #[inline]
default() -> Self56617     fn default() -> Self {
56618         Self {
56619             s_type: Self::STRUCTURE_TYPE,
56620             p_next: ::std::ptr::null(),
56621             slot_index: i32::default(),
56622             p_picture_resource: ::std::ptr::null(),
56623         }
56624     }
56625 }
56626 unsafe impl TaggedStructure for VideoReferenceSlotInfoKHR {
56627     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_REFERENCE_SLOT_INFO_KHR;
56628 }
56629 impl VideoReferenceSlotInfoKHR {
builder<'a>() -> VideoReferenceSlotInfoKHRBuilder<'a>56630     pub fn builder<'a>() -> VideoReferenceSlotInfoKHRBuilder<'a> {
56631         VideoReferenceSlotInfoKHRBuilder {
56632             inner: Self::default(),
56633             marker: ::std::marker::PhantomData,
56634         }
56635     }
56636 }
56637 #[repr(transparent)]
56638 pub struct VideoReferenceSlotInfoKHRBuilder<'a> {
56639     inner: VideoReferenceSlotInfoKHR,
56640     marker: ::std::marker::PhantomData<&'a ()>,
56641 }
56642 pub unsafe trait ExtendsVideoReferenceSlotInfoKHR {}
56643 impl<'a> ::std::ops::Deref for VideoReferenceSlotInfoKHRBuilder<'a> {
56644     type Target = VideoReferenceSlotInfoKHR;
deref(&self) -> &Self::Target56645     fn deref(&self) -> &Self::Target {
56646         &self.inner
56647     }
56648 }
56649 impl<'a> ::std::ops::DerefMut for VideoReferenceSlotInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target56650     fn deref_mut(&mut self) -> &mut Self::Target {
56651         &mut self.inner
56652     }
56653 }
56654 impl<'a> VideoReferenceSlotInfoKHRBuilder<'a> {
56655     #[inline]
slot_index(mut self, slot_index: i32) -> Self56656     pub fn slot_index(mut self, slot_index: i32) -> Self {
56657         self.inner.slot_index = slot_index;
56658         self
56659     }
56660     #[inline]
picture_resource(mut self, picture_resource: &'a VideoPictureResourceInfoKHR) -> Self56661     pub fn picture_resource(mut self, picture_resource: &'a VideoPictureResourceInfoKHR) -> Self {
56662         self.inner.p_picture_resource = picture_resource;
56663         self
56664     }
56665     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
56666     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
56667     #[doc = r" valid extension structs can be pushed into the chain."]
56668     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
56669     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsVideoReferenceSlotInfoKHR>(mut self, next: &'a mut T) -> Self56670     pub fn push_next<T: ExtendsVideoReferenceSlotInfoKHR>(mut self, next: &'a mut T) -> Self {
56671         unsafe {
56672             let next_ptr = <*const T>::cast(next);
56673             let last_next = ptr_chain_iter(next).last().unwrap();
56674             (*last_next).p_next = self.inner.p_next as _;
56675             self.inner.p_next = next_ptr;
56676         }
56677         self
56678     }
56679     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56680     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56681     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoReferenceSlotInfoKHR56682     pub fn build(self) -> VideoReferenceSlotInfoKHR {
56683         self.inner
56684     }
56685 }
56686 #[repr(C)]
56687 #[cfg_attr(feature = "debug", derive(Debug))]
56688 #[derive(Copy, Clone)]
56689 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeCapabilitiesKHR.html>"]
56690 pub struct VideoDecodeCapabilitiesKHR {
56691     pub s_type: StructureType,
56692     pub p_next: *mut c_void,
56693     pub flags: VideoDecodeCapabilityFlagsKHR,
56694 }
56695 impl ::std::default::Default for VideoDecodeCapabilitiesKHR {
56696     #[inline]
default() -> Self56697     fn default() -> Self {
56698         Self {
56699             s_type: Self::STRUCTURE_TYPE,
56700             p_next: ::std::ptr::null_mut(),
56701             flags: VideoDecodeCapabilityFlagsKHR::default(),
56702         }
56703     }
56704 }
56705 unsafe impl TaggedStructure for VideoDecodeCapabilitiesKHR {
56706     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_CAPABILITIES_KHR;
56707 }
56708 impl VideoDecodeCapabilitiesKHR {
builder<'a>() -> VideoDecodeCapabilitiesKHRBuilder<'a>56709     pub fn builder<'a>() -> VideoDecodeCapabilitiesKHRBuilder<'a> {
56710         VideoDecodeCapabilitiesKHRBuilder {
56711             inner: Self::default(),
56712             marker: ::std::marker::PhantomData,
56713         }
56714     }
56715 }
56716 #[repr(transparent)]
56717 pub struct VideoDecodeCapabilitiesKHRBuilder<'a> {
56718     inner: VideoDecodeCapabilitiesKHR,
56719     marker: ::std::marker::PhantomData<&'a ()>,
56720 }
56721 unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeCapabilitiesKHRBuilder<'_> {}
56722 unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeCapabilitiesKHR {}
56723 impl<'a> ::std::ops::Deref for VideoDecodeCapabilitiesKHRBuilder<'a> {
56724     type Target = VideoDecodeCapabilitiesKHR;
deref(&self) -> &Self::Target56725     fn deref(&self) -> &Self::Target {
56726         &self.inner
56727     }
56728 }
56729 impl<'a> ::std::ops::DerefMut for VideoDecodeCapabilitiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target56730     fn deref_mut(&mut self) -> &mut Self::Target {
56731         &mut self.inner
56732     }
56733 }
56734 impl<'a> VideoDecodeCapabilitiesKHRBuilder<'a> {
56735     #[inline]
flags(mut self, flags: VideoDecodeCapabilityFlagsKHR) -> Self56736     pub fn flags(mut self, flags: VideoDecodeCapabilityFlagsKHR) -> Self {
56737         self.inner.flags = flags;
56738         self
56739     }
56740     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56741     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56742     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoDecodeCapabilitiesKHR56743     pub fn build(self) -> VideoDecodeCapabilitiesKHR {
56744         self.inner
56745     }
56746 }
56747 #[repr(C)]
56748 #[cfg_attr(feature = "debug", derive(Debug))]
56749 #[derive(Copy, Clone)]
56750 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeUsageInfoKHR.html>"]
56751 pub struct VideoDecodeUsageInfoKHR {
56752     pub s_type: StructureType,
56753     pub p_next: *const c_void,
56754     pub video_usage_hints: VideoDecodeUsageFlagsKHR,
56755 }
56756 impl ::std::default::Default for VideoDecodeUsageInfoKHR {
56757     #[inline]
default() -> Self56758     fn default() -> Self {
56759         Self {
56760             s_type: Self::STRUCTURE_TYPE,
56761             p_next: ::std::ptr::null(),
56762             video_usage_hints: VideoDecodeUsageFlagsKHR::default(),
56763         }
56764     }
56765 }
56766 unsafe impl TaggedStructure for VideoDecodeUsageInfoKHR {
56767     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_USAGE_INFO_KHR;
56768 }
56769 impl VideoDecodeUsageInfoKHR {
builder<'a>() -> VideoDecodeUsageInfoKHRBuilder<'a>56770     pub fn builder<'a>() -> VideoDecodeUsageInfoKHRBuilder<'a> {
56771         VideoDecodeUsageInfoKHRBuilder {
56772             inner: Self::default(),
56773             marker: ::std::marker::PhantomData,
56774         }
56775     }
56776 }
56777 #[repr(transparent)]
56778 pub struct VideoDecodeUsageInfoKHRBuilder<'a> {
56779     inner: VideoDecodeUsageInfoKHR,
56780     marker: ::std::marker::PhantomData<&'a ()>,
56781 }
56782 unsafe impl ExtendsVideoProfileInfoKHR for VideoDecodeUsageInfoKHRBuilder<'_> {}
56783 unsafe impl ExtendsVideoProfileInfoKHR for VideoDecodeUsageInfoKHR {}
56784 unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeUsageInfoKHRBuilder<'_> {}
56785 unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeUsageInfoKHR {}
56786 impl<'a> ::std::ops::Deref for VideoDecodeUsageInfoKHRBuilder<'a> {
56787     type Target = VideoDecodeUsageInfoKHR;
deref(&self) -> &Self::Target56788     fn deref(&self) -> &Self::Target {
56789         &self.inner
56790     }
56791 }
56792 impl<'a> ::std::ops::DerefMut for VideoDecodeUsageInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target56793     fn deref_mut(&mut self) -> &mut Self::Target {
56794         &mut self.inner
56795     }
56796 }
56797 impl<'a> VideoDecodeUsageInfoKHRBuilder<'a> {
56798     #[inline]
video_usage_hints(mut self, video_usage_hints: VideoDecodeUsageFlagsKHR) -> Self56799     pub fn video_usage_hints(mut self, video_usage_hints: VideoDecodeUsageFlagsKHR) -> Self {
56800         self.inner.video_usage_hints = video_usage_hints;
56801         self
56802     }
56803     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56804     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56805     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoDecodeUsageInfoKHR56806     pub fn build(self) -> VideoDecodeUsageInfoKHR {
56807         self.inner
56808     }
56809 }
56810 #[repr(C)]
56811 #[cfg_attr(feature = "debug", derive(Debug))]
56812 #[derive(Copy, Clone)]
56813 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeInfoKHR.html>"]
56814 pub struct VideoDecodeInfoKHR {
56815     pub s_type: StructureType,
56816     pub p_next: *const c_void,
56817     pub flags: VideoDecodeFlagsKHR,
56818     pub src_buffer: Buffer,
56819     pub src_buffer_offset: DeviceSize,
56820     pub src_buffer_range: DeviceSize,
56821     pub dst_picture_resource: VideoPictureResourceInfoKHR,
56822     pub p_setup_reference_slot: *const VideoReferenceSlotInfoKHR,
56823     pub reference_slot_count: u32,
56824     pub p_reference_slots: *const VideoReferenceSlotInfoKHR,
56825 }
56826 impl ::std::default::Default for VideoDecodeInfoKHR {
56827     #[inline]
default() -> Self56828     fn default() -> Self {
56829         Self {
56830             s_type: Self::STRUCTURE_TYPE,
56831             p_next: ::std::ptr::null(),
56832             flags: VideoDecodeFlagsKHR::default(),
56833             src_buffer: Buffer::default(),
56834             src_buffer_offset: DeviceSize::default(),
56835             src_buffer_range: DeviceSize::default(),
56836             dst_picture_resource: VideoPictureResourceInfoKHR::default(),
56837             p_setup_reference_slot: ::std::ptr::null(),
56838             reference_slot_count: u32::default(),
56839             p_reference_slots: ::std::ptr::null(),
56840         }
56841     }
56842 }
56843 unsafe impl TaggedStructure for VideoDecodeInfoKHR {
56844     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_INFO_KHR;
56845 }
56846 impl VideoDecodeInfoKHR {
builder<'a>() -> VideoDecodeInfoKHRBuilder<'a>56847     pub fn builder<'a>() -> VideoDecodeInfoKHRBuilder<'a> {
56848         VideoDecodeInfoKHRBuilder {
56849             inner: Self::default(),
56850             marker: ::std::marker::PhantomData,
56851         }
56852     }
56853 }
56854 #[repr(transparent)]
56855 pub struct VideoDecodeInfoKHRBuilder<'a> {
56856     inner: VideoDecodeInfoKHR,
56857     marker: ::std::marker::PhantomData<&'a ()>,
56858 }
56859 pub unsafe trait ExtendsVideoDecodeInfoKHR {}
56860 impl<'a> ::std::ops::Deref for VideoDecodeInfoKHRBuilder<'a> {
56861     type Target = VideoDecodeInfoKHR;
deref(&self) -> &Self::Target56862     fn deref(&self) -> &Self::Target {
56863         &self.inner
56864     }
56865 }
56866 impl<'a> ::std::ops::DerefMut for VideoDecodeInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target56867     fn deref_mut(&mut self) -> &mut Self::Target {
56868         &mut self.inner
56869     }
56870 }
56871 impl<'a> VideoDecodeInfoKHRBuilder<'a> {
56872     #[inline]
flags(mut self, flags: VideoDecodeFlagsKHR) -> Self56873     pub fn flags(mut self, flags: VideoDecodeFlagsKHR) -> Self {
56874         self.inner.flags = flags;
56875         self
56876     }
56877     #[inline]
src_buffer(mut self, src_buffer: Buffer) -> Self56878     pub fn src_buffer(mut self, src_buffer: Buffer) -> Self {
56879         self.inner.src_buffer = src_buffer;
56880         self
56881     }
56882     #[inline]
src_buffer_offset(mut self, src_buffer_offset: DeviceSize) -> Self56883     pub fn src_buffer_offset(mut self, src_buffer_offset: DeviceSize) -> Self {
56884         self.inner.src_buffer_offset = src_buffer_offset;
56885         self
56886     }
56887     #[inline]
src_buffer_range(mut self, src_buffer_range: DeviceSize) -> Self56888     pub fn src_buffer_range(mut self, src_buffer_range: DeviceSize) -> Self {
56889         self.inner.src_buffer_range = src_buffer_range;
56890         self
56891     }
56892     #[inline]
dst_picture_resource( mut self, dst_picture_resource: VideoPictureResourceInfoKHR, ) -> Self56893     pub fn dst_picture_resource(
56894         mut self,
56895         dst_picture_resource: VideoPictureResourceInfoKHR,
56896     ) -> Self {
56897         self.inner.dst_picture_resource = dst_picture_resource;
56898         self
56899     }
56900     #[inline]
setup_reference_slot( mut self, setup_reference_slot: &'a VideoReferenceSlotInfoKHR, ) -> Self56901     pub fn setup_reference_slot(
56902         mut self,
56903         setup_reference_slot: &'a VideoReferenceSlotInfoKHR,
56904     ) -> Self {
56905         self.inner.p_setup_reference_slot = setup_reference_slot;
56906         self
56907     }
56908     #[inline]
reference_slots(mut self, reference_slots: &'a [VideoReferenceSlotInfoKHR]) -> Self56909     pub fn reference_slots(mut self, reference_slots: &'a [VideoReferenceSlotInfoKHR]) -> Self {
56910         self.inner.reference_slot_count = reference_slots.len() as _;
56911         self.inner.p_reference_slots = reference_slots.as_ptr();
56912         self
56913     }
56914     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
56915     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
56916     #[doc = r" valid extension structs can be pushed into the chain."]
56917     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
56918     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsVideoDecodeInfoKHR>(mut self, next: &'a mut T) -> Self56919     pub fn push_next<T: ExtendsVideoDecodeInfoKHR>(mut self, next: &'a mut T) -> Self {
56920         unsafe {
56921             let next_ptr = <*const T>::cast(next);
56922             let last_next = ptr_chain_iter(next).last().unwrap();
56923             (*last_next).p_next = self.inner.p_next as _;
56924             self.inner.p_next = next_ptr;
56925         }
56926         self
56927     }
56928     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56929     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56930     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoDecodeInfoKHR56931     pub fn build(self) -> VideoDecodeInfoKHR {
56932         self.inner
56933     }
56934 }
56935 #[repr(C)]
56936 #[cfg_attr(feature = "debug", derive(Debug))]
56937 #[derive(Copy, Clone)]
56938 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264ProfileInfoKHR.html>"]
56939 pub struct VideoDecodeH264ProfileInfoKHR {
56940     pub s_type: StructureType,
56941     pub p_next: *const c_void,
56942     pub std_profile_idc: StdVideoH264ProfileIdc,
56943     pub picture_layout: VideoDecodeH264PictureLayoutFlagsKHR,
56944 }
56945 impl ::std::default::Default for VideoDecodeH264ProfileInfoKHR {
56946     #[inline]
default() -> Self56947     fn default() -> Self {
56948         Self {
56949             s_type: Self::STRUCTURE_TYPE,
56950             p_next: ::std::ptr::null(),
56951             std_profile_idc: StdVideoH264ProfileIdc::default(),
56952             picture_layout: VideoDecodeH264PictureLayoutFlagsKHR::default(),
56953         }
56954     }
56955 }
56956 unsafe impl TaggedStructure for VideoDecodeH264ProfileInfoKHR {
56957     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H264_PROFILE_INFO_KHR;
56958 }
56959 impl VideoDecodeH264ProfileInfoKHR {
builder<'a>() -> VideoDecodeH264ProfileInfoKHRBuilder<'a>56960     pub fn builder<'a>() -> VideoDecodeH264ProfileInfoKHRBuilder<'a> {
56961         VideoDecodeH264ProfileInfoKHRBuilder {
56962             inner: Self::default(),
56963             marker: ::std::marker::PhantomData,
56964         }
56965     }
56966 }
56967 #[repr(transparent)]
56968 pub struct VideoDecodeH264ProfileInfoKHRBuilder<'a> {
56969     inner: VideoDecodeH264ProfileInfoKHR,
56970     marker: ::std::marker::PhantomData<&'a ()>,
56971 }
56972 unsafe impl ExtendsVideoProfileInfoKHR for VideoDecodeH264ProfileInfoKHRBuilder<'_> {}
56973 unsafe impl ExtendsVideoProfileInfoKHR for VideoDecodeH264ProfileInfoKHR {}
56974 unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH264ProfileInfoKHRBuilder<'_> {}
56975 unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH264ProfileInfoKHR {}
56976 impl<'a> ::std::ops::Deref for VideoDecodeH264ProfileInfoKHRBuilder<'a> {
56977     type Target = VideoDecodeH264ProfileInfoKHR;
deref(&self) -> &Self::Target56978     fn deref(&self) -> &Self::Target {
56979         &self.inner
56980     }
56981 }
56982 impl<'a> ::std::ops::DerefMut for VideoDecodeH264ProfileInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target56983     fn deref_mut(&mut self) -> &mut Self::Target {
56984         &mut self.inner
56985     }
56986 }
56987 impl<'a> VideoDecodeH264ProfileInfoKHRBuilder<'a> {
56988     #[inline]
std_profile_idc(mut self, std_profile_idc: StdVideoH264ProfileIdc) -> Self56989     pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH264ProfileIdc) -> Self {
56990         self.inner.std_profile_idc = std_profile_idc;
56991         self
56992     }
56993     #[inline]
picture_layout(mut self, picture_layout: VideoDecodeH264PictureLayoutFlagsKHR) -> Self56994     pub fn picture_layout(mut self, picture_layout: VideoDecodeH264PictureLayoutFlagsKHR) -> Self {
56995         self.inner.picture_layout = picture_layout;
56996         self
56997     }
56998     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56999     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
57000     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoDecodeH264ProfileInfoKHR57001     pub fn build(self) -> VideoDecodeH264ProfileInfoKHR {
57002         self.inner
57003     }
57004 }
57005 #[repr(C)]
57006 #[cfg_attr(feature = "debug", derive(Debug))]
57007 #[derive(Copy, Clone)]
57008 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264CapabilitiesKHR.html>"]
57009 pub struct VideoDecodeH264CapabilitiesKHR {
57010     pub s_type: StructureType,
57011     pub p_next: *mut c_void,
57012     pub max_level_idc: StdVideoH264LevelIdc,
57013     pub field_offset_granularity: Offset2D,
57014 }
57015 impl ::std::default::Default for VideoDecodeH264CapabilitiesKHR {
57016     #[inline]
default() -> Self57017     fn default() -> Self {
57018         Self {
57019             s_type: Self::STRUCTURE_TYPE,
57020             p_next: ::std::ptr::null_mut(),
57021             max_level_idc: StdVideoH264LevelIdc::default(),
57022             field_offset_granularity: Offset2D::default(),
57023         }
57024     }
57025 }
57026 unsafe impl TaggedStructure for VideoDecodeH264CapabilitiesKHR {
57027     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H264_CAPABILITIES_KHR;
57028 }
57029 impl VideoDecodeH264CapabilitiesKHR {
builder<'a>() -> VideoDecodeH264CapabilitiesKHRBuilder<'a>57030     pub fn builder<'a>() -> VideoDecodeH264CapabilitiesKHRBuilder<'a> {
57031         VideoDecodeH264CapabilitiesKHRBuilder {
57032             inner: Self::default(),
57033             marker: ::std::marker::PhantomData,
57034         }
57035     }
57036 }
57037 #[repr(transparent)]
57038 pub struct VideoDecodeH264CapabilitiesKHRBuilder<'a> {
57039     inner: VideoDecodeH264CapabilitiesKHR,
57040     marker: ::std::marker::PhantomData<&'a ()>,
57041 }
57042 unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH264CapabilitiesKHRBuilder<'_> {}
57043 unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH264CapabilitiesKHR {}
57044 impl<'a> ::std::ops::Deref for VideoDecodeH264CapabilitiesKHRBuilder<'a> {
57045     type Target = VideoDecodeH264CapabilitiesKHR;
deref(&self) -> &Self::Target57046     fn deref(&self) -> &Self::Target {
57047         &self.inner
57048     }
57049 }
57050 impl<'a> ::std::ops::DerefMut for VideoDecodeH264CapabilitiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target57051     fn deref_mut(&mut self) -> &mut Self::Target {
57052         &mut self.inner
57053     }
57054 }
57055 impl<'a> VideoDecodeH264CapabilitiesKHRBuilder<'a> {
57056     #[inline]
max_level_idc(mut self, max_level_idc: StdVideoH264LevelIdc) -> Self57057     pub fn max_level_idc(mut self, max_level_idc: StdVideoH264LevelIdc) -> Self {
57058         self.inner.max_level_idc = max_level_idc;
57059         self
57060     }
57061     #[inline]
field_offset_granularity(mut self, field_offset_granularity: Offset2D) -> Self57062     pub fn field_offset_granularity(mut self, field_offset_granularity: Offset2D) -> Self {
57063         self.inner.field_offset_granularity = field_offset_granularity;
57064         self
57065     }
57066     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
57067     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
57068     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoDecodeH264CapabilitiesKHR57069     pub fn build(self) -> VideoDecodeH264CapabilitiesKHR {
57070         self.inner
57071     }
57072 }
57073 #[repr(C)]
57074 #[cfg_attr(feature = "debug", derive(Debug))]
57075 #[derive(Copy, Clone)]
57076 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264SessionParametersAddInfoKHR.html>"]
57077 pub struct VideoDecodeH264SessionParametersAddInfoKHR {
57078     pub s_type: StructureType,
57079     pub p_next: *const c_void,
57080     pub std_sps_count: u32,
57081     pub p_std_sp_ss: *const StdVideoH264SequenceParameterSet,
57082     pub std_pps_count: u32,
57083     pub p_std_pp_ss: *const StdVideoH264PictureParameterSet,
57084 }
57085 impl ::std::default::Default for VideoDecodeH264SessionParametersAddInfoKHR {
57086     #[inline]
default() -> Self57087     fn default() -> Self {
57088         Self {
57089             s_type: Self::STRUCTURE_TYPE,
57090             p_next: ::std::ptr::null(),
57091             std_sps_count: u32::default(),
57092             p_std_sp_ss: ::std::ptr::null(),
57093             std_pps_count: u32::default(),
57094             p_std_pp_ss: ::std::ptr::null(),
57095         }
57096     }
57097 }
57098 unsafe impl TaggedStructure for VideoDecodeH264SessionParametersAddInfoKHR {
57099     const STRUCTURE_TYPE: StructureType =
57100         StructureType::VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR;
57101 }
57102 impl VideoDecodeH264SessionParametersAddInfoKHR {
builder<'a>() -> VideoDecodeH264SessionParametersAddInfoKHRBuilder<'a>57103     pub fn builder<'a>() -> VideoDecodeH264SessionParametersAddInfoKHRBuilder<'a> {
57104         VideoDecodeH264SessionParametersAddInfoKHRBuilder {
57105             inner: Self::default(),
57106             marker: ::std::marker::PhantomData,
57107         }
57108     }
57109 }
57110 #[repr(transparent)]
57111 pub struct VideoDecodeH264SessionParametersAddInfoKHRBuilder<'a> {
57112     inner: VideoDecodeH264SessionParametersAddInfoKHR,
57113     marker: ::std::marker::PhantomData<&'a ()>,
57114 }
57115 unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
57116     for VideoDecodeH264SessionParametersAddInfoKHRBuilder<'_>
57117 {
57118 }
57119 unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
57120     for VideoDecodeH264SessionParametersAddInfoKHR
57121 {
57122 }
57123 impl<'a> ::std::ops::Deref for VideoDecodeH264SessionParametersAddInfoKHRBuilder<'a> {
57124     type Target = VideoDecodeH264SessionParametersAddInfoKHR;
deref(&self) -> &Self::Target57125     fn deref(&self) -> &Self::Target {
57126         &self.inner
57127     }
57128 }
57129 impl<'a> ::std::ops::DerefMut for VideoDecodeH264SessionParametersAddInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target57130     fn deref_mut(&mut self) -> &mut Self::Target {
57131         &mut self.inner
57132     }
57133 }
57134 impl<'a> VideoDecodeH264SessionParametersAddInfoKHRBuilder<'a> {
57135     #[inline]
std_sp_ss(mut self, std_sp_ss: &'a [StdVideoH264SequenceParameterSet]) -> Self57136     pub fn std_sp_ss(mut self, std_sp_ss: &'a [StdVideoH264SequenceParameterSet]) -> Self {
57137         self.inner.std_sps_count = std_sp_ss.len() as _;
57138         self.inner.p_std_sp_ss = std_sp_ss.as_ptr();
57139         self
57140     }
57141     #[inline]
std_pp_ss(mut self, std_pp_ss: &'a [StdVideoH264PictureParameterSet]) -> Self57142     pub fn std_pp_ss(mut self, std_pp_ss: &'a [StdVideoH264PictureParameterSet]) -> Self {
57143         self.inner.std_pps_count = std_pp_ss.len() as _;
57144         self.inner.p_std_pp_ss = std_pp_ss.as_ptr();
57145         self
57146     }
57147     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
57148     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
57149     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoDecodeH264SessionParametersAddInfoKHR57150     pub fn build(self) -> VideoDecodeH264SessionParametersAddInfoKHR {
57151         self.inner
57152     }
57153 }
57154 #[repr(C)]
57155 #[cfg_attr(feature = "debug", derive(Debug))]
57156 #[derive(Copy, Clone)]
57157 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264SessionParametersCreateInfoKHR.html>"]
57158 pub struct VideoDecodeH264SessionParametersCreateInfoKHR {
57159     pub s_type: StructureType,
57160     pub p_next: *const c_void,
57161     pub max_std_sps_count: u32,
57162     pub max_std_pps_count: u32,
57163     pub p_parameters_add_info: *const VideoDecodeH264SessionParametersAddInfoKHR,
57164 }
57165 impl ::std::default::Default for VideoDecodeH264SessionParametersCreateInfoKHR {
57166     #[inline]
default() -> Self57167     fn default() -> Self {
57168         Self {
57169             s_type: Self::STRUCTURE_TYPE,
57170             p_next: ::std::ptr::null(),
57171             max_std_sps_count: u32::default(),
57172             max_std_pps_count: u32::default(),
57173             p_parameters_add_info: ::std::ptr::null(),
57174         }
57175     }
57176 }
57177 unsafe impl TaggedStructure for VideoDecodeH264SessionParametersCreateInfoKHR {
57178     const STRUCTURE_TYPE: StructureType =
57179         StructureType::VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR;
57180 }
57181 impl VideoDecodeH264SessionParametersCreateInfoKHR {
builder<'a>() -> VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'a>57182     pub fn builder<'a>() -> VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'a> {
57183         VideoDecodeH264SessionParametersCreateInfoKHRBuilder {
57184             inner: Self::default(),
57185             marker: ::std::marker::PhantomData,
57186         }
57187     }
57188 }
57189 #[repr(transparent)]
57190 pub struct VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'a> {
57191     inner: VideoDecodeH264SessionParametersCreateInfoKHR,
57192     marker: ::std::marker::PhantomData<&'a ()>,
57193 }
57194 unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
57195     for VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'_>
57196 {
57197 }
57198 unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
57199     for VideoDecodeH264SessionParametersCreateInfoKHR
57200 {
57201 }
57202 impl<'a> ::std::ops::Deref for VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'a> {
57203     type Target = VideoDecodeH264SessionParametersCreateInfoKHR;
deref(&self) -> &Self::Target57204     fn deref(&self) -> &Self::Target {
57205         &self.inner
57206     }
57207 }
57208 impl<'a> ::std::ops::DerefMut for VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target57209     fn deref_mut(&mut self) -> &mut Self::Target {
57210         &mut self.inner
57211     }
57212 }
57213 impl<'a> VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'a> {
57214     #[inline]
max_std_sps_count(mut self, max_std_sps_count: u32) -> Self57215     pub fn max_std_sps_count(mut self, max_std_sps_count: u32) -> Self {
57216         self.inner.max_std_sps_count = max_std_sps_count;
57217         self
57218     }
57219     #[inline]
max_std_pps_count(mut self, max_std_pps_count: u32) -> Self57220     pub fn max_std_pps_count(mut self, max_std_pps_count: u32) -> Self {
57221         self.inner.max_std_pps_count = max_std_pps_count;
57222         self
57223     }
57224     #[inline]
parameters_add_info( mut self, parameters_add_info: &'a VideoDecodeH264SessionParametersAddInfoKHR, ) -> Self57225     pub fn parameters_add_info(
57226         mut self,
57227         parameters_add_info: &'a VideoDecodeH264SessionParametersAddInfoKHR,
57228     ) -> Self {
57229         self.inner.p_parameters_add_info = parameters_add_info;
57230         self
57231     }
57232     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
57233     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
57234     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoDecodeH264SessionParametersCreateInfoKHR57235     pub fn build(self) -> VideoDecodeH264SessionParametersCreateInfoKHR {
57236         self.inner
57237     }
57238 }
57239 #[repr(C)]
57240 #[cfg_attr(feature = "debug", derive(Debug))]
57241 #[derive(Copy, Clone)]
57242 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264PictureInfoKHR.html>"]
57243 pub struct VideoDecodeH264PictureInfoKHR {
57244     pub s_type: StructureType,
57245     pub p_next: *const c_void,
57246     pub p_std_picture_info: *const StdVideoDecodeH264PictureInfo,
57247     pub slice_count: u32,
57248     pub p_slice_offsets: *const u32,
57249 }
57250 impl ::std::default::Default for VideoDecodeH264PictureInfoKHR {
57251     #[inline]
default() -> Self57252     fn default() -> Self {
57253         Self {
57254             s_type: Self::STRUCTURE_TYPE,
57255             p_next: ::std::ptr::null(),
57256             p_std_picture_info: ::std::ptr::null(),
57257             slice_count: u32::default(),
57258             p_slice_offsets: ::std::ptr::null(),
57259         }
57260     }
57261 }
57262 unsafe impl TaggedStructure for VideoDecodeH264PictureInfoKHR {
57263     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H264_PICTURE_INFO_KHR;
57264 }
57265 impl VideoDecodeH264PictureInfoKHR {
builder<'a>() -> VideoDecodeH264PictureInfoKHRBuilder<'a>57266     pub fn builder<'a>() -> VideoDecodeH264PictureInfoKHRBuilder<'a> {
57267         VideoDecodeH264PictureInfoKHRBuilder {
57268             inner: Self::default(),
57269             marker: ::std::marker::PhantomData,
57270         }
57271     }
57272 }
57273 #[repr(transparent)]
57274 pub struct VideoDecodeH264PictureInfoKHRBuilder<'a> {
57275     inner: VideoDecodeH264PictureInfoKHR,
57276     marker: ::std::marker::PhantomData<&'a ()>,
57277 }
57278 unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH264PictureInfoKHRBuilder<'_> {}
57279 unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH264PictureInfoKHR {}
57280 impl<'a> ::std::ops::Deref for VideoDecodeH264PictureInfoKHRBuilder<'a> {
57281     type Target = VideoDecodeH264PictureInfoKHR;
deref(&self) -> &Self::Target57282     fn deref(&self) -> &Self::Target {
57283         &self.inner
57284     }
57285 }
57286 impl<'a> ::std::ops::DerefMut for VideoDecodeH264PictureInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target57287     fn deref_mut(&mut self) -> &mut Self::Target {
57288         &mut self.inner
57289     }
57290 }
57291 impl<'a> VideoDecodeH264PictureInfoKHRBuilder<'a> {
57292     #[inline]
std_picture_info(mut self, std_picture_info: &'a StdVideoDecodeH264PictureInfo) -> Self57293     pub fn std_picture_info(mut self, std_picture_info: &'a StdVideoDecodeH264PictureInfo) -> Self {
57294         self.inner.p_std_picture_info = std_picture_info;
57295         self
57296     }
57297     #[inline]
slice_offsets(mut self, slice_offsets: &'a [u32]) -> Self57298     pub fn slice_offsets(mut self, slice_offsets: &'a [u32]) -> Self {
57299         self.inner.slice_count = slice_offsets.len() as _;
57300         self.inner.p_slice_offsets = slice_offsets.as_ptr();
57301         self
57302     }
57303     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
57304     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
57305     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoDecodeH264PictureInfoKHR57306     pub fn build(self) -> VideoDecodeH264PictureInfoKHR {
57307         self.inner
57308     }
57309 }
57310 #[repr(C)]
57311 #[cfg_attr(feature = "debug", derive(Debug))]
57312 #[derive(Copy, Clone)]
57313 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264DpbSlotInfoKHR.html>"]
57314 pub struct VideoDecodeH264DpbSlotInfoKHR {
57315     pub s_type: StructureType,
57316     pub p_next: *const c_void,
57317     pub p_std_reference_info: *const StdVideoDecodeH264ReferenceInfo,
57318 }
57319 impl ::std::default::Default for VideoDecodeH264DpbSlotInfoKHR {
57320     #[inline]
default() -> Self57321     fn default() -> Self {
57322         Self {
57323             s_type: Self::STRUCTURE_TYPE,
57324             p_next: ::std::ptr::null(),
57325             p_std_reference_info: ::std::ptr::null(),
57326         }
57327     }
57328 }
57329 unsafe impl TaggedStructure for VideoDecodeH264DpbSlotInfoKHR {
57330     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR;
57331 }
57332 impl VideoDecodeH264DpbSlotInfoKHR {
builder<'a>() -> VideoDecodeH264DpbSlotInfoKHRBuilder<'a>57333     pub fn builder<'a>() -> VideoDecodeH264DpbSlotInfoKHRBuilder<'a> {
57334         VideoDecodeH264DpbSlotInfoKHRBuilder {
57335             inner: Self::default(),
57336             marker: ::std::marker::PhantomData,
57337         }
57338     }
57339 }
57340 #[repr(transparent)]
57341 pub struct VideoDecodeH264DpbSlotInfoKHRBuilder<'a> {
57342     inner: VideoDecodeH264DpbSlotInfoKHR,
57343     marker: ::std::marker::PhantomData<&'a ()>,
57344 }
57345 unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoDecodeH264DpbSlotInfoKHRBuilder<'_> {}
57346 unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoDecodeH264DpbSlotInfoKHR {}
57347 impl<'a> ::std::ops::Deref for VideoDecodeH264DpbSlotInfoKHRBuilder<'a> {
57348     type Target = VideoDecodeH264DpbSlotInfoKHR;
deref(&self) -> &Self::Target57349     fn deref(&self) -> &Self::Target {
57350         &self.inner
57351     }
57352 }
57353 impl<'a> ::std::ops::DerefMut for VideoDecodeH264DpbSlotInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target57354     fn deref_mut(&mut self) -> &mut Self::Target {
57355         &mut self.inner
57356     }
57357 }
57358 impl<'a> VideoDecodeH264DpbSlotInfoKHRBuilder<'a> {
57359     #[inline]
std_reference_info( mut self, std_reference_info: &'a StdVideoDecodeH264ReferenceInfo, ) -> Self57360     pub fn std_reference_info(
57361         mut self,
57362         std_reference_info: &'a StdVideoDecodeH264ReferenceInfo,
57363     ) -> Self {
57364         self.inner.p_std_reference_info = std_reference_info;
57365         self
57366     }
57367     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
57368     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
57369     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoDecodeH264DpbSlotInfoKHR57370     pub fn build(self) -> VideoDecodeH264DpbSlotInfoKHR {
57371         self.inner
57372     }
57373 }
57374 #[repr(C)]
57375 #[cfg_attr(feature = "debug", derive(Debug))]
57376 #[derive(Copy, Clone)]
57377 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265ProfileInfoKHR.html>"]
57378 pub struct VideoDecodeH265ProfileInfoKHR {
57379     pub s_type: StructureType,
57380     pub p_next: *const c_void,
57381     pub std_profile_idc: StdVideoH265ProfileIdc,
57382 }
57383 impl ::std::default::Default for VideoDecodeH265ProfileInfoKHR {
57384     #[inline]
default() -> Self57385     fn default() -> Self {
57386         Self {
57387             s_type: Self::STRUCTURE_TYPE,
57388             p_next: ::std::ptr::null(),
57389             std_profile_idc: StdVideoH265ProfileIdc::default(),
57390         }
57391     }
57392 }
57393 unsafe impl TaggedStructure for VideoDecodeH265ProfileInfoKHR {
57394     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H265_PROFILE_INFO_KHR;
57395 }
57396 impl VideoDecodeH265ProfileInfoKHR {
builder<'a>() -> VideoDecodeH265ProfileInfoKHRBuilder<'a>57397     pub fn builder<'a>() -> VideoDecodeH265ProfileInfoKHRBuilder<'a> {
57398         VideoDecodeH265ProfileInfoKHRBuilder {
57399             inner: Self::default(),
57400             marker: ::std::marker::PhantomData,
57401         }
57402     }
57403 }
57404 #[repr(transparent)]
57405 pub struct VideoDecodeH265ProfileInfoKHRBuilder<'a> {
57406     inner: VideoDecodeH265ProfileInfoKHR,
57407     marker: ::std::marker::PhantomData<&'a ()>,
57408 }
57409 unsafe impl ExtendsVideoProfileInfoKHR for VideoDecodeH265ProfileInfoKHRBuilder<'_> {}
57410 unsafe impl ExtendsVideoProfileInfoKHR for VideoDecodeH265ProfileInfoKHR {}
57411 unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH265ProfileInfoKHRBuilder<'_> {}
57412 unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH265ProfileInfoKHR {}
57413 impl<'a> ::std::ops::Deref for VideoDecodeH265ProfileInfoKHRBuilder<'a> {
57414     type Target = VideoDecodeH265ProfileInfoKHR;
deref(&self) -> &Self::Target57415     fn deref(&self) -> &Self::Target {
57416         &self.inner
57417     }
57418 }
57419 impl<'a> ::std::ops::DerefMut for VideoDecodeH265ProfileInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target57420     fn deref_mut(&mut self) -> &mut Self::Target {
57421         &mut self.inner
57422     }
57423 }
57424 impl<'a> VideoDecodeH265ProfileInfoKHRBuilder<'a> {
57425     #[inline]
std_profile_idc(mut self, std_profile_idc: StdVideoH265ProfileIdc) -> Self57426     pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH265ProfileIdc) -> Self {
57427         self.inner.std_profile_idc = std_profile_idc;
57428         self
57429     }
57430     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
57431     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
57432     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoDecodeH265ProfileInfoKHR57433     pub fn build(self) -> VideoDecodeH265ProfileInfoKHR {
57434         self.inner
57435     }
57436 }
57437 #[repr(C)]
57438 #[cfg_attr(feature = "debug", derive(Debug))]
57439 #[derive(Copy, Clone)]
57440 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265CapabilitiesKHR.html>"]
57441 pub struct VideoDecodeH265CapabilitiesKHR {
57442     pub s_type: StructureType,
57443     pub p_next: *mut c_void,
57444     pub max_level_idc: StdVideoH265LevelIdc,
57445 }
57446 impl ::std::default::Default for VideoDecodeH265CapabilitiesKHR {
57447     #[inline]
default() -> Self57448     fn default() -> Self {
57449         Self {
57450             s_type: Self::STRUCTURE_TYPE,
57451             p_next: ::std::ptr::null_mut(),
57452             max_level_idc: StdVideoH265LevelIdc::default(),
57453         }
57454     }
57455 }
57456 unsafe impl TaggedStructure for VideoDecodeH265CapabilitiesKHR {
57457     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H265_CAPABILITIES_KHR;
57458 }
57459 impl VideoDecodeH265CapabilitiesKHR {
builder<'a>() -> VideoDecodeH265CapabilitiesKHRBuilder<'a>57460     pub fn builder<'a>() -> VideoDecodeH265CapabilitiesKHRBuilder<'a> {
57461         VideoDecodeH265CapabilitiesKHRBuilder {
57462             inner: Self::default(),
57463             marker: ::std::marker::PhantomData,
57464         }
57465     }
57466 }
57467 #[repr(transparent)]
57468 pub struct VideoDecodeH265CapabilitiesKHRBuilder<'a> {
57469     inner: VideoDecodeH265CapabilitiesKHR,
57470     marker: ::std::marker::PhantomData<&'a ()>,
57471 }
57472 unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH265CapabilitiesKHRBuilder<'_> {}
57473 unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH265CapabilitiesKHR {}
57474 impl<'a> ::std::ops::Deref for VideoDecodeH265CapabilitiesKHRBuilder<'a> {
57475     type Target = VideoDecodeH265CapabilitiesKHR;
deref(&self) -> &Self::Target57476     fn deref(&self) -> &Self::Target {
57477         &self.inner
57478     }
57479 }
57480 impl<'a> ::std::ops::DerefMut for VideoDecodeH265CapabilitiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target57481     fn deref_mut(&mut self) -> &mut Self::Target {
57482         &mut self.inner
57483     }
57484 }
57485 impl<'a> VideoDecodeH265CapabilitiesKHRBuilder<'a> {
57486     #[inline]
max_level_idc(mut self, max_level_idc: StdVideoH265LevelIdc) -> Self57487     pub fn max_level_idc(mut self, max_level_idc: StdVideoH265LevelIdc) -> Self {
57488         self.inner.max_level_idc = max_level_idc;
57489         self
57490     }
57491     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
57492     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
57493     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoDecodeH265CapabilitiesKHR57494     pub fn build(self) -> VideoDecodeH265CapabilitiesKHR {
57495         self.inner
57496     }
57497 }
57498 #[repr(C)]
57499 #[cfg_attr(feature = "debug", derive(Debug))]
57500 #[derive(Copy, Clone)]
57501 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265SessionParametersAddInfoKHR.html>"]
57502 pub struct VideoDecodeH265SessionParametersAddInfoKHR {
57503     pub s_type: StructureType,
57504     pub p_next: *const c_void,
57505     pub std_vps_count: u32,
57506     pub p_std_vp_ss: *const StdVideoH265VideoParameterSet,
57507     pub std_sps_count: u32,
57508     pub p_std_sp_ss: *const StdVideoH265SequenceParameterSet,
57509     pub std_pps_count: u32,
57510     pub p_std_pp_ss: *const StdVideoH265PictureParameterSet,
57511 }
57512 impl ::std::default::Default for VideoDecodeH265SessionParametersAddInfoKHR {
57513     #[inline]
default() -> Self57514     fn default() -> Self {
57515         Self {
57516             s_type: Self::STRUCTURE_TYPE,
57517             p_next: ::std::ptr::null(),
57518             std_vps_count: u32::default(),
57519             p_std_vp_ss: ::std::ptr::null(),
57520             std_sps_count: u32::default(),
57521             p_std_sp_ss: ::std::ptr::null(),
57522             std_pps_count: u32::default(),
57523             p_std_pp_ss: ::std::ptr::null(),
57524         }
57525     }
57526 }
57527 unsafe impl TaggedStructure for VideoDecodeH265SessionParametersAddInfoKHR {
57528     const STRUCTURE_TYPE: StructureType =
57529         StructureType::VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR;
57530 }
57531 impl VideoDecodeH265SessionParametersAddInfoKHR {
builder<'a>() -> VideoDecodeH265SessionParametersAddInfoKHRBuilder<'a>57532     pub fn builder<'a>() -> VideoDecodeH265SessionParametersAddInfoKHRBuilder<'a> {
57533         VideoDecodeH265SessionParametersAddInfoKHRBuilder {
57534             inner: Self::default(),
57535             marker: ::std::marker::PhantomData,
57536         }
57537     }
57538 }
57539 #[repr(transparent)]
57540 pub struct VideoDecodeH265SessionParametersAddInfoKHRBuilder<'a> {
57541     inner: VideoDecodeH265SessionParametersAddInfoKHR,
57542     marker: ::std::marker::PhantomData<&'a ()>,
57543 }
57544 unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
57545     for VideoDecodeH265SessionParametersAddInfoKHRBuilder<'_>
57546 {
57547 }
57548 unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
57549     for VideoDecodeH265SessionParametersAddInfoKHR
57550 {
57551 }
57552 impl<'a> ::std::ops::Deref for VideoDecodeH265SessionParametersAddInfoKHRBuilder<'a> {
57553     type Target = VideoDecodeH265SessionParametersAddInfoKHR;
deref(&self) -> &Self::Target57554     fn deref(&self) -> &Self::Target {
57555         &self.inner
57556     }
57557 }
57558 impl<'a> ::std::ops::DerefMut for VideoDecodeH265SessionParametersAddInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target57559     fn deref_mut(&mut self) -> &mut Self::Target {
57560         &mut self.inner
57561     }
57562 }
57563 impl<'a> VideoDecodeH265SessionParametersAddInfoKHRBuilder<'a> {
57564     #[inline]
std_vp_ss(mut self, std_vp_ss: &'a [StdVideoH265VideoParameterSet]) -> Self57565     pub fn std_vp_ss(mut self, std_vp_ss: &'a [StdVideoH265VideoParameterSet]) -> Self {
57566         self.inner.std_vps_count = std_vp_ss.len() as _;
57567         self.inner.p_std_vp_ss = std_vp_ss.as_ptr();
57568         self
57569     }
57570     #[inline]
std_sp_ss(mut self, std_sp_ss: &'a [StdVideoH265SequenceParameterSet]) -> Self57571     pub fn std_sp_ss(mut self, std_sp_ss: &'a [StdVideoH265SequenceParameterSet]) -> Self {
57572         self.inner.std_sps_count = std_sp_ss.len() as _;
57573         self.inner.p_std_sp_ss = std_sp_ss.as_ptr();
57574         self
57575     }
57576     #[inline]
std_pp_ss(mut self, std_pp_ss: &'a [StdVideoH265PictureParameterSet]) -> Self57577     pub fn std_pp_ss(mut self, std_pp_ss: &'a [StdVideoH265PictureParameterSet]) -> Self {
57578         self.inner.std_pps_count = std_pp_ss.len() as _;
57579         self.inner.p_std_pp_ss = std_pp_ss.as_ptr();
57580         self
57581     }
57582     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
57583     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
57584     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoDecodeH265SessionParametersAddInfoKHR57585     pub fn build(self) -> VideoDecodeH265SessionParametersAddInfoKHR {
57586         self.inner
57587     }
57588 }
57589 #[repr(C)]
57590 #[cfg_attr(feature = "debug", derive(Debug))]
57591 #[derive(Copy, Clone)]
57592 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265SessionParametersCreateInfoKHR.html>"]
57593 pub struct VideoDecodeH265SessionParametersCreateInfoKHR {
57594     pub s_type: StructureType,
57595     pub p_next: *const c_void,
57596     pub max_std_vps_count: u32,
57597     pub max_std_sps_count: u32,
57598     pub max_std_pps_count: u32,
57599     pub p_parameters_add_info: *const VideoDecodeH265SessionParametersAddInfoKHR,
57600 }
57601 impl ::std::default::Default for VideoDecodeH265SessionParametersCreateInfoKHR {
57602     #[inline]
default() -> Self57603     fn default() -> Self {
57604         Self {
57605             s_type: Self::STRUCTURE_TYPE,
57606             p_next: ::std::ptr::null(),
57607             max_std_vps_count: u32::default(),
57608             max_std_sps_count: u32::default(),
57609             max_std_pps_count: u32::default(),
57610             p_parameters_add_info: ::std::ptr::null(),
57611         }
57612     }
57613 }
57614 unsafe impl TaggedStructure for VideoDecodeH265SessionParametersCreateInfoKHR {
57615     const STRUCTURE_TYPE: StructureType =
57616         StructureType::VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR;
57617 }
57618 impl VideoDecodeH265SessionParametersCreateInfoKHR {
builder<'a>() -> VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'a>57619     pub fn builder<'a>() -> VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'a> {
57620         VideoDecodeH265SessionParametersCreateInfoKHRBuilder {
57621             inner: Self::default(),
57622             marker: ::std::marker::PhantomData,
57623         }
57624     }
57625 }
57626 #[repr(transparent)]
57627 pub struct VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'a> {
57628     inner: VideoDecodeH265SessionParametersCreateInfoKHR,
57629     marker: ::std::marker::PhantomData<&'a ()>,
57630 }
57631 unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
57632     for VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'_>
57633 {
57634 }
57635 unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
57636     for VideoDecodeH265SessionParametersCreateInfoKHR
57637 {
57638 }
57639 impl<'a> ::std::ops::Deref for VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'a> {
57640     type Target = VideoDecodeH265SessionParametersCreateInfoKHR;
deref(&self) -> &Self::Target57641     fn deref(&self) -> &Self::Target {
57642         &self.inner
57643     }
57644 }
57645 impl<'a> ::std::ops::DerefMut for VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target57646     fn deref_mut(&mut self) -> &mut Self::Target {
57647         &mut self.inner
57648     }
57649 }
57650 impl<'a> VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'a> {
57651     #[inline]
max_std_vps_count(mut self, max_std_vps_count: u32) -> Self57652     pub fn max_std_vps_count(mut self, max_std_vps_count: u32) -> Self {
57653         self.inner.max_std_vps_count = max_std_vps_count;
57654         self
57655     }
57656     #[inline]
max_std_sps_count(mut self, max_std_sps_count: u32) -> Self57657     pub fn max_std_sps_count(mut self, max_std_sps_count: u32) -> Self {
57658         self.inner.max_std_sps_count = max_std_sps_count;
57659         self
57660     }
57661     #[inline]
max_std_pps_count(mut self, max_std_pps_count: u32) -> Self57662     pub fn max_std_pps_count(mut self, max_std_pps_count: u32) -> Self {
57663         self.inner.max_std_pps_count = max_std_pps_count;
57664         self
57665     }
57666     #[inline]
parameters_add_info( mut self, parameters_add_info: &'a VideoDecodeH265SessionParametersAddInfoKHR, ) -> Self57667     pub fn parameters_add_info(
57668         mut self,
57669         parameters_add_info: &'a VideoDecodeH265SessionParametersAddInfoKHR,
57670     ) -> Self {
57671         self.inner.p_parameters_add_info = parameters_add_info;
57672         self
57673     }
57674     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
57675     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
57676     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoDecodeH265SessionParametersCreateInfoKHR57677     pub fn build(self) -> VideoDecodeH265SessionParametersCreateInfoKHR {
57678         self.inner
57679     }
57680 }
57681 #[repr(C)]
57682 #[cfg_attr(feature = "debug", derive(Debug))]
57683 #[derive(Copy, Clone)]
57684 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265PictureInfoKHR.html>"]
57685 pub struct VideoDecodeH265PictureInfoKHR {
57686     pub s_type: StructureType,
57687     pub p_next: *const c_void,
57688     pub p_std_picture_info: *const StdVideoDecodeH265PictureInfo,
57689     pub slice_segment_count: u32,
57690     pub p_slice_segment_offsets: *const u32,
57691 }
57692 impl ::std::default::Default for VideoDecodeH265PictureInfoKHR {
57693     #[inline]
default() -> Self57694     fn default() -> Self {
57695         Self {
57696             s_type: Self::STRUCTURE_TYPE,
57697             p_next: ::std::ptr::null(),
57698             p_std_picture_info: ::std::ptr::null(),
57699             slice_segment_count: u32::default(),
57700             p_slice_segment_offsets: ::std::ptr::null(),
57701         }
57702     }
57703 }
57704 unsafe impl TaggedStructure for VideoDecodeH265PictureInfoKHR {
57705     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H265_PICTURE_INFO_KHR;
57706 }
57707 impl VideoDecodeH265PictureInfoKHR {
builder<'a>() -> VideoDecodeH265PictureInfoKHRBuilder<'a>57708     pub fn builder<'a>() -> VideoDecodeH265PictureInfoKHRBuilder<'a> {
57709         VideoDecodeH265PictureInfoKHRBuilder {
57710             inner: Self::default(),
57711             marker: ::std::marker::PhantomData,
57712         }
57713     }
57714 }
57715 #[repr(transparent)]
57716 pub struct VideoDecodeH265PictureInfoKHRBuilder<'a> {
57717     inner: VideoDecodeH265PictureInfoKHR,
57718     marker: ::std::marker::PhantomData<&'a ()>,
57719 }
57720 unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH265PictureInfoKHRBuilder<'_> {}
57721 unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH265PictureInfoKHR {}
57722 impl<'a> ::std::ops::Deref for VideoDecodeH265PictureInfoKHRBuilder<'a> {
57723     type Target = VideoDecodeH265PictureInfoKHR;
deref(&self) -> &Self::Target57724     fn deref(&self) -> &Self::Target {
57725         &self.inner
57726     }
57727 }
57728 impl<'a> ::std::ops::DerefMut for VideoDecodeH265PictureInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target57729     fn deref_mut(&mut self) -> &mut Self::Target {
57730         &mut self.inner
57731     }
57732 }
57733 impl<'a> VideoDecodeH265PictureInfoKHRBuilder<'a> {
57734     #[inline]
std_picture_info(mut self, std_picture_info: &'a StdVideoDecodeH265PictureInfo) -> Self57735     pub fn std_picture_info(mut self, std_picture_info: &'a StdVideoDecodeH265PictureInfo) -> Self {
57736         self.inner.p_std_picture_info = std_picture_info;
57737         self
57738     }
57739     #[inline]
slice_segment_offsets(mut self, slice_segment_offsets: &'a [u32]) -> Self57740     pub fn slice_segment_offsets(mut self, slice_segment_offsets: &'a [u32]) -> Self {
57741         self.inner.slice_segment_count = slice_segment_offsets.len() as _;
57742         self.inner.p_slice_segment_offsets = slice_segment_offsets.as_ptr();
57743         self
57744     }
57745     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
57746     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
57747     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoDecodeH265PictureInfoKHR57748     pub fn build(self) -> VideoDecodeH265PictureInfoKHR {
57749         self.inner
57750     }
57751 }
57752 #[repr(C)]
57753 #[cfg_attr(feature = "debug", derive(Debug))]
57754 #[derive(Copy, Clone)]
57755 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265DpbSlotInfoKHR.html>"]
57756 pub struct VideoDecodeH265DpbSlotInfoKHR {
57757     pub s_type: StructureType,
57758     pub p_next: *const c_void,
57759     pub p_std_reference_info: *const StdVideoDecodeH265ReferenceInfo,
57760 }
57761 impl ::std::default::Default for VideoDecodeH265DpbSlotInfoKHR {
57762     #[inline]
default() -> Self57763     fn default() -> Self {
57764         Self {
57765             s_type: Self::STRUCTURE_TYPE,
57766             p_next: ::std::ptr::null(),
57767             p_std_reference_info: ::std::ptr::null(),
57768         }
57769     }
57770 }
57771 unsafe impl TaggedStructure for VideoDecodeH265DpbSlotInfoKHR {
57772     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR;
57773 }
57774 impl VideoDecodeH265DpbSlotInfoKHR {
builder<'a>() -> VideoDecodeH265DpbSlotInfoKHRBuilder<'a>57775     pub fn builder<'a>() -> VideoDecodeH265DpbSlotInfoKHRBuilder<'a> {
57776         VideoDecodeH265DpbSlotInfoKHRBuilder {
57777             inner: Self::default(),
57778             marker: ::std::marker::PhantomData,
57779         }
57780     }
57781 }
57782 #[repr(transparent)]
57783 pub struct VideoDecodeH265DpbSlotInfoKHRBuilder<'a> {
57784     inner: VideoDecodeH265DpbSlotInfoKHR,
57785     marker: ::std::marker::PhantomData<&'a ()>,
57786 }
57787 unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoDecodeH265DpbSlotInfoKHRBuilder<'_> {}
57788 unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoDecodeH265DpbSlotInfoKHR {}
57789 impl<'a> ::std::ops::Deref for VideoDecodeH265DpbSlotInfoKHRBuilder<'a> {
57790     type Target = VideoDecodeH265DpbSlotInfoKHR;
deref(&self) -> &Self::Target57791     fn deref(&self) -> &Self::Target {
57792         &self.inner
57793     }
57794 }
57795 impl<'a> ::std::ops::DerefMut for VideoDecodeH265DpbSlotInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target57796     fn deref_mut(&mut self) -> &mut Self::Target {
57797         &mut self.inner
57798     }
57799 }
57800 impl<'a> VideoDecodeH265DpbSlotInfoKHRBuilder<'a> {
57801     #[inline]
std_reference_info( mut self, std_reference_info: &'a StdVideoDecodeH265ReferenceInfo, ) -> Self57802     pub fn std_reference_info(
57803         mut self,
57804         std_reference_info: &'a StdVideoDecodeH265ReferenceInfo,
57805     ) -> Self {
57806         self.inner.p_std_reference_info = std_reference_info;
57807         self
57808     }
57809     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
57810     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
57811     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoDecodeH265DpbSlotInfoKHR57812     pub fn build(self) -> VideoDecodeH265DpbSlotInfoKHR {
57813         self.inner
57814     }
57815 }
57816 #[repr(C)]
57817 #[cfg_attr(feature = "debug", derive(Debug))]
57818 #[derive(Copy, Clone)]
57819 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionCreateInfoKHR.html>"]
57820 pub struct VideoSessionCreateInfoKHR {
57821     pub s_type: StructureType,
57822     pub p_next: *const c_void,
57823     pub queue_family_index: u32,
57824     pub flags: VideoSessionCreateFlagsKHR,
57825     pub p_video_profile: *const VideoProfileInfoKHR,
57826     pub picture_format: Format,
57827     pub max_coded_extent: Extent2D,
57828     pub reference_picture_format: Format,
57829     pub max_dpb_slots: u32,
57830     pub max_active_reference_pictures: u32,
57831     pub p_std_header_version: *const ExtensionProperties,
57832 }
57833 impl ::std::default::Default for VideoSessionCreateInfoKHR {
57834     #[inline]
default() -> Self57835     fn default() -> Self {
57836         Self {
57837             s_type: Self::STRUCTURE_TYPE,
57838             p_next: ::std::ptr::null(),
57839             queue_family_index: u32::default(),
57840             flags: VideoSessionCreateFlagsKHR::default(),
57841             p_video_profile: ::std::ptr::null(),
57842             picture_format: Format::default(),
57843             max_coded_extent: Extent2D::default(),
57844             reference_picture_format: Format::default(),
57845             max_dpb_slots: u32::default(),
57846             max_active_reference_pictures: u32::default(),
57847             p_std_header_version: ::std::ptr::null(),
57848         }
57849     }
57850 }
57851 unsafe impl TaggedStructure for VideoSessionCreateInfoKHR {
57852     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_SESSION_CREATE_INFO_KHR;
57853 }
57854 impl VideoSessionCreateInfoKHR {
builder<'a>() -> VideoSessionCreateInfoKHRBuilder<'a>57855     pub fn builder<'a>() -> VideoSessionCreateInfoKHRBuilder<'a> {
57856         VideoSessionCreateInfoKHRBuilder {
57857             inner: Self::default(),
57858             marker: ::std::marker::PhantomData,
57859         }
57860     }
57861 }
57862 #[repr(transparent)]
57863 pub struct VideoSessionCreateInfoKHRBuilder<'a> {
57864     inner: VideoSessionCreateInfoKHR,
57865     marker: ::std::marker::PhantomData<&'a ()>,
57866 }
57867 impl<'a> ::std::ops::Deref for VideoSessionCreateInfoKHRBuilder<'a> {
57868     type Target = VideoSessionCreateInfoKHR;
deref(&self) -> &Self::Target57869     fn deref(&self) -> &Self::Target {
57870         &self.inner
57871     }
57872 }
57873 impl<'a> ::std::ops::DerefMut for VideoSessionCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target57874     fn deref_mut(&mut self) -> &mut Self::Target {
57875         &mut self.inner
57876     }
57877 }
57878 impl<'a> VideoSessionCreateInfoKHRBuilder<'a> {
57879     #[inline]
queue_family_index(mut self, queue_family_index: u32) -> Self57880     pub fn queue_family_index(mut self, queue_family_index: u32) -> Self {
57881         self.inner.queue_family_index = queue_family_index;
57882         self
57883     }
57884     #[inline]
flags(mut self, flags: VideoSessionCreateFlagsKHR) -> Self57885     pub fn flags(mut self, flags: VideoSessionCreateFlagsKHR) -> Self {
57886         self.inner.flags = flags;
57887         self
57888     }
57889     #[inline]
video_profile(mut self, video_profile: &'a VideoProfileInfoKHR) -> Self57890     pub fn video_profile(mut self, video_profile: &'a VideoProfileInfoKHR) -> Self {
57891         self.inner.p_video_profile = video_profile;
57892         self
57893     }
57894     #[inline]
picture_format(mut self, picture_format: Format) -> Self57895     pub fn picture_format(mut self, picture_format: Format) -> Self {
57896         self.inner.picture_format = picture_format;
57897         self
57898     }
57899     #[inline]
max_coded_extent(mut self, max_coded_extent: Extent2D) -> Self57900     pub fn max_coded_extent(mut self, max_coded_extent: Extent2D) -> Self {
57901         self.inner.max_coded_extent = max_coded_extent;
57902         self
57903     }
57904     #[inline]
reference_picture_format(mut self, reference_picture_format: Format) -> Self57905     pub fn reference_picture_format(mut self, reference_picture_format: Format) -> Self {
57906         self.inner.reference_picture_format = reference_picture_format;
57907         self
57908     }
57909     #[inline]
max_dpb_slots(mut self, max_dpb_slots: u32) -> Self57910     pub fn max_dpb_slots(mut self, max_dpb_slots: u32) -> Self {
57911         self.inner.max_dpb_slots = max_dpb_slots;
57912         self
57913     }
57914     #[inline]
max_active_reference_pictures(mut self, max_active_reference_pictures: u32) -> Self57915     pub fn max_active_reference_pictures(mut self, max_active_reference_pictures: u32) -> Self {
57916         self.inner.max_active_reference_pictures = max_active_reference_pictures;
57917         self
57918     }
57919     #[inline]
std_header_version(mut self, std_header_version: &'a ExtensionProperties) -> Self57920     pub fn std_header_version(mut self, std_header_version: &'a ExtensionProperties) -> Self {
57921         self.inner.p_std_header_version = std_header_version;
57922         self
57923     }
57924     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
57925     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
57926     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoSessionCreateInfoKHR57927     pub fn build(self) -> VideoSessionCreateInfoKHR {
57928         self.inner
57929     }
57930 }
57931 #[repr(C)]
57932 #[cfg_attr(feature = "debug", derive(Debug))]
57933 #[derive(Copy, Clone)]
57934 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionParametersCreateInfoKHR.html>"]
57935 pub struct VideoSessionParametersCreateInfoKHR {
57936     pub s_type: StructureType,
57937     pub p_next: *const c_void,
57938     pub flags: VideoSessionParametersCreateFlagsKHR,
57939     pub video_session_parameters_template: VideoSessionParametersKHR,
57940     pub video_session: VideoSessionKHR,
57941 }
57942 impl ::std::default::Default for VideoSessionParametersCreateInfoKHR {
57943     #[inline]
default() -> Self57944     fn default() -> Self {
57945         Self {
57946             s_type: Self::STRUCTURE_TYPE,
57947             p_next: ::std::ptr::null(),
57948             flags: VideoSessionParametersCreateFlagsKHR::default(),
57949             video_session_parameters_template: VideoSessionParametersKHR::default(),
57950             video_session: VideoSessionKHR::default(),
57951         }
57952     }
57953 }
57954 unsafe impl TaggedStructure for VideoSessionParametersCreateInfoKHR {
57955     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR;
57956 }
57957 impl VideoSessionParametersCreateInfoKHR {
builder<'a>() -> VideoSessionParametersCreateInfoKHRBuilder<'a>57958     pub fn builder<'a>() -> VideoSessionParametersCreateInfoKHRBuilder<'a> {
57959         VideoSessionParametersCreateInfoKHRBuilder {
57960             inner: Self::default(),
57961             marker: ::std::marker::PhantomData,
57962         }
57963     }
57964 }
57965 #[repr(transparent)]
57966 pub struct VideoSessionParametersCreateInfoKHRBuilder<'a> {
57967     inner: VideoSessionParametersCreateInfoKHR,
57968     marker: ::std::marker::PhantomData<&'a ()>,
57969 }
57970 pub unsafe trait ExtendsVideoSessionParametersCreateInfoKHR {}
57971 impl<'a> ::std::ops::Deref for VideoSessionParametersCreateInfoKHRBuilder<'a> {
57972     type Target = VideoSessionParametersCreateInfoKHR;
deref(&self) -> &Self::Target57973     fn deref(&self) -> &Self::Target {
57974         &self.inner
57975     }
57976 }
57977 impl<'a> ::std::ops::DerefMut for VideoSessionParametersCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target57978     fn deref_mut(&mut self) -> &mut Self::Target {
57979         &mut self.inner
57980     }
57981 }
57982 impl<'a> VideoSessionParametersCreateInfoKHRBuilder<'a> {
57983     #[inline]
flags(mut self, flags: VideoSessionParametersCreateFlagsKHR) -> Self57984     pub fn flags(mut self, flags: VideoSessionParametersCreateFlagsKHR) -> Self {
57985         self.inner.flags = flags;
57986         self
57987     }
57988     #[inline]
video_session_parameters_template( mut self, video_session_parameters_template: VideoSessionParametersKHR, ) -> Self57989     pub fn video_session_parameters_template(
57990         mut self,
57991         video_session_parameters_template: VideoSessionParametersKHR,
57992     ) -> Self {
57993         self.inner.video_session_parameters_template = video_session_parameters_template;
57994         self
57995     }
57996     #[inline]
video_session(mut self, video_session: VideoSessionKHR) -> Self57997     pub fn video_session(mut self, video_session: VideoSessionKHR) -> Self {
57998         self.inner.video_session = video_session;
57999         self
58000     }
58001     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
58002     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
58003     #[doc = r" valid extension structs can be pushed into the chain."]
58004     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
58005     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsVideoSessionParametersCreateInfoKHR>( mut self, next: &'a mut T, ) -> Self58006     pub fn push_next<T: ExtendsVideoSessionParametersCreateInfoKHR>(
58007         mut self,
58008         next: &'a mut T,
58009     ) -> Self {
58010         unsafe {
58011             let next_ptr = <*const T>::cast(next);
58012             let last_next = ptr_chain_iter(next).last().unwrap();
58013             (*last_next).p_next = self.inner.p_next as _;
58014             self.inner.p_next = next_ptr;
58015         }
58016         self
58017     }
58018     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
58019     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
58020     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoSessionParametersCreateInfoKHR58021     pub fn build(self) -> VideoSessionParametersCreateInfoKHR {
58022         self.inner
58023     }
58024 }
58025 #[repr(C)]
58026 #[cfg_attr(feature = "debug", derive(Debug))]
58027 #[derive(Copy, Clone)]
58028 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionParametersUpdateInfoKHR.html>"]
58029 pub struct VideoSessionParametersUpdateInfoKHR {
58030     pub s_type: StructureType,
58031     pub p_next: *const c_void,
58032     pub update_sequence_count: u32,
58033 }
58034 impl ::std::default::Default for VideoSessionParametersUpdateInfoKHR {
58035     #[inline]
default() -> Self58036     fn default() -> Self {
58037         Self {
58038             s_type: Self::STRUCTURE_TYPE,
58039             p_next: ::std::ptr::null(),
58040             update_sequence_count: u32::default(),
58041         }
58042     }
58043 }
58044 unsafe impl TaggedStructure for VideoSessionParametersUpdateInfoKHR {
58045     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR;
58046 }
58047 impl VideoSessionParametersUpdateInfoKHR {
builder<'a>() -> VideoSessionParametersUpdateInfoKHRBuilder<'a>58048     pub fn builder<'a>() -> VideoSessionParametersUpdateInfoKHRBuilder<'a> {
58049         VideoSessionParametersUpdateInfoKHRBuilder {
58050             inner: Self::default(),
58051             marker: ::std::marker::PhantomData,
58052         }
58053     }
58054 }
58055 #[repr(transparent)]
58056 pub struct VideoSessionParametersUpdateInfoKHRBuilder<'a> {
58057     inner: VideoSessionParametersUpdateInfoKHR,
58058     marker: ::std::marker::PhantomData<&'a ()>,
58059 }
58060 pub unsafe trait ExtendsVideoSessionParametersUpdateInfoKHR {}
58061 impl<'a> ::std::ops::Deref for VideoSessionParametersUpdateInfoKHRBuilder<'a> {
58062     type Target = VideoSessionParametersUpdateInfoKHR;
deref(&self) -> &Self::Target58063     fn deref(&self) -> &Self::Target {
58064         &self.inner
58065     }
58066 }
58067 impl<'a> ::std::ops::DerefMut for VideoSessionParametersUpdateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target58068     fn deref_mut(&mut self) -> &mut Self::Target {
58069         &mut self.inner
58070     }
58071 }
58072 impl<'a> VideoSessionParametersUpdateInfoKHRBuilder<'a> {
58073     #[inline]
update_sequence_count(mut self, update_sequence_count: u32) -> Self58074     pub fn update_sequence_count(mut self, update_sequence_count: u32) -> Self {
58075         self.inner.update_sequence_count = update_sequence_count;
58076         self
58077     }
58078     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
58079     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
58080     #[doc = r" valid extension structs can be pushed into the chain."]
58081     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
58082     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsVideoSessionParametersUpdateInfoKHR>( mut self, next: &'a mut T, ) -> Self58083     pub fn push_next<T: ExtendsVideoSessionParametersUpdateInfoKHR>(
58084         mut self,
58085         next: &'a mut T,
58086     ) -> Self {
58087         unsafe {
58088             let next_ptr = <*const T>::cast(next);
58089             let last_next = ptr_chain_iter(next).last().unwrap();
58090             (*last_next).p_next = self.inner.p_next as _;
58091             self.inner.p_next = next_ptr;
58092         }
58093         self
58094     }
58095     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
58096     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
58097     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoSessionParametersUpdateInfoKHR58098     pub fn build(self) -> VideoSessionParametersUpdateInfoKHR {
58099         self.inner
58100     }
58101 }
58102 #[repr(C)]
58103 #[cfg_attr(feature = "debug", derive(Debug))]
58104 #[derive(Copy, Clone)]
58105 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoBeginCodingInfoKHR.html>"]
58106 pub struct VideoBeginCodingInfoKHR {
58107     pub s_type: StructureType,
58108     pub p_next: *const c_void,
58109     pub flags: VideoBeginCodingFlagsKHR,
58110     pub video_session: VideoSessionKHR,
58111     pub video_session_parameters: VideoSessionParametersKHR,
58112     pub reference_slot_count: u32,
58113     pub p_reference_slots: *const VideoReferenceSlotInfoKHR,
58114 }
58115 impl ::std::default::Default for VideoBeginCodingInfoKHR {
58116     #[inline]
default() -> Self58117     fn default() -> Self {
58118         Self {
58119             s_type: Self::STRUCTURE_TYPE,
58120             p_next: ::std::ptr::null(),
58121             flags: VideoBeginCodingFlagsKHR::default(),
58122             video_session: VideoSessionKHR::default(),
58123             video_session_parameters: VideoSessionParametersKHR::default(),
58124             reference_slot_count: u32::default(),
58125             p_reference_slots: ::std::ptr::null(),
58126         }
58127     }
58128 }
58129 unsafe impl TaggedStructure for VideoBeginCodingInfoKHR {
58130     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_BEGIN_CODING_INFO_KHR;
58131 }
58132 impl VideoBeginCodingInfoKHR {
builder<'a>() -> VideoBeginCodingInfoKHRBuilder<'a>58133     pub fn builder<'a>() -> VideoBeginCodingInfoKHRBuilder<'a> {
58134         VideoBeginCodingInfoKHRBuilder {
58135             inner: Self::default(),
58136             marker: ::std::marker::PhantomData,
58137         }
58138     }
58139 }
58140 #[repr(transparent)]
58141 pub struct VideoBeginCodingInfoKHRBuilder<'a> {
58142     inner: VideoBeginCodingInfoKHR,
58143     marker: ::std::marker::PhantomData<&'a ()>,
58144 }
58145 impl<'a> ::std::ops::Deref for VideoBeginCodingInfoKHRBuilder<'a> {
58146     type Target = VideoBeginCodingInfoKHR;
deref(&self) -> &Self::Target58147     fn deref(&self) -> &Self::Target {
58148         &self.inner
58149     }
58150 }
58151 impl<'a> ::std::ops::DerefMut for VideoBeginCodingInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target58152     fn deref_mut(&mut self) -> &mut Self::Target {
58153         &mut self.inner
58154     }
58155 }
58156 impl<'a> VideoBeginCodingInfoKHRBuilder<'a> {
58157     #[inline]
flags(mut self, flags: VideoBeginCodingFlagsKHR) -> Self58158     pub fn flags(mut self, flags: VideoBeginCodingFlagsKHR) -> Self {
58159         self.inner.flags = flags;
58160         self
58161     }
58162     #[inline]
video_session(mut self, video_session: VideoSessionKHR) -> Self58163     pub fn video_session(mut self, video_session: VideoSessionKHR) -> Self {
58164         self.inner.video_session = video_session;
58165         self
58166     }
58167     #[inline]
video_session_parameters( mut self, video_session_parameters: VideoSessionParametersKHR, ) -> Self58168     pub fn video_session_parameters(
58169         mut self,
58170         video_session_parameters: VideoSessionParametersKHR,
58171     ) -> Self {
58172         self.inner.video_session_parameters = video_session_parameters;
58173         self
58174     }
58175     #[inline]
reference_slots(mut self, reference_slots: &'a [VideoReferenceSlotInfoKHR]) -> Self58176     pub fn reference_slots(mut self, reference_slots: &'a [VideoReferenceSlotInfoKHR]) -> Self {
58177         self.inner.reference_slot_count = reference_slots.len() as _;
58178         self.inner.p_reference_slots = reference_slots.as_ptr();
58179         self
58180     }
58181     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
58182     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
58183     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoBeginCodingInfoKHR58184     pub fn build(self) -> VideoBeginCodingInfoKHR {
58185         self.inner
58186     }
58187 }
58188 #[repr(C)]
58189 #[cfg_attr(feature = "debug", derive(Debug))]
58190 #[derive(Copy, Clone)]
58191 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEndCodingInfoKHR.html>"]
58192 pub struct VideoEndCodingInfoKHR {
58193     pub s_type: StructureType,
58194     pub p_next: *const c_void,
58195     pub flags: VideoEndCodingFlagsKHR,
58196 }
58197 impl ::std::default::Default for VideoEndCodingInfoKHR {
58198     #[inline]
default() -> Self58199     fn default() -> Self {
58200         Self {
58201             s_type: Self::STRUCTURE_TYPE,
58202             p_next: ::std::ptr::null(),
58203             flags: VideoEndCodingFlagsKHR::default(),
58204         }
58205     }
58206 }
58207 unsafe impl TaggedStructure for VideoEndCodingInfoKHR {
58208     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_END_CODING_INFO_KHR;
58209 }
58210 impl VideoEndCodingInfoKHR {
builder<'a>() -> VideoEndCodingInfoKHRBuilder<'a>58211     pub fn builder<'a>() -> VideoEndCodingInfoKHRBuilder<'a> {
58212         VideoEndCodingInfoKHRBuilder {
58213             inner: Self::default(),
58214             marker: ::std::marker::PhantomData,
58215         }
58216     }
58217 }
58218 #[repr(transparent)]
58219 pub struct VideoEndCodingInfoKHRBuilder<'a> {
58220     inner: VideoEndCodingInfoKHR,
58221     marker: ::std::marker::PhantomData<&'a ()>,
58222 }
58223 impl<'a> ::std::ops::Deref for VideoEndCodingInfoKHRBuilder<'a> {
58224     type Target = VideoEndCodingInfoKHR;
deref(&self) -> &Self::Target58225     fn deref(&self) -> &Self::Target {
58226         &self.inner
58227     }
58228 }
58229 impl<'a> ::std::ops::DerefMut for VideoEndCodingInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target58230     fn deref_mut(&mut self) -> &mut Self::Target {
58231         &mut self.inner
58232     }
58233 }
58234 impl<'a> VideoEndCodingInfoKHRBuilder<'a> {
58235     #[inline]
flags(mut self, flags: VideoEndCodingFlagsKHR) -> Self58236     pub fn flags(mut self, flags: VideoEndCodingFlagsKHR) -> Self {
58237         self.inner.flags = flags;
58238         self
58239     }
58240     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
58241     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
58242     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoEndCodingInfoKHR58243     pub fn build(self) -> VideoEndCodingInfoKHR {
58244         self.inner
58245     }
58246 }
58247 #[repr(C)]
58248 #[cfg_attr(feature = "debug", derive(Debug))]
58249 #[derive(Copy, Clone)]
58250 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCodingControlInfoKHR.html>"]
58251 pub struct VideoCodingControlInfoKHR {
58252     pub s_type: StructureType,
58253     pub p_next: *const c_void,
58254     pub flags: VideoCodingControlFlagsKHR,
58255 }
58256 impl ::std::default::Default for VideoCodingControlInfoKHR {
58257     #[inline]
default() -> Self58258     fn default() -> Self {
58259         Self {
58260             s_type: Self::STRUCTURE_TYPE,
58261             p_next: ::std::ptr::null(),
58262             flags: VideoCodingControlFlagsKHR::default(),
58263         }
58264     }
58265 }
58266 unsafe impl TaggedStructure for VideoCodingControlInfoKHR {
58267     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_CODING_CONTROL_INFO_KHR;
58268 }
58269 impl VideoCodingControlInfoKHR {
builder<'a>() -> VideoCodingControlInfoKHRBuilder<'a>58270     pub fn builder<'a>() -> VideoCodingControlInfoKHRBuilder<'a> {
58271         VideoCodingControlInfoKHRBuilder {
58272             inner: Self::default(),
58273             marker: ::std::marker::PhantomData,
58274         }
58275     }
58276 }
58277 #[repr(transparent)]
58278 pub struct VideoCodingControlInfoKHRBuilder<'a> {
58279     inner: VideoCodingControlInfoKHR,
58280     marker: ::std::marker::PhantomData<&'a ()>,
58281 }
58282 pub unsafe trait ExtendsVideoCodingControlInfoKHR {}
58283 impl<'a> ::std::ops::Deref for VideoCodingControlInfoKHRBuilder<'a> {
58284     type Target = VideoCodingControlInfoKHR;
deref(&self) -> &Self::Target58285     fn deref(&self) -> &Self::Target {
58286         &self.inner
58287     }
58288 }
58289 impl<'a> ::std::ops::DerefMut for VideoCodingControlInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target58290     fn deref_mut(&mut self) -> &mut Self::Target {
58291         &mut self.inner
58292     }
58293 }
58294 impl<'a> VideoCodingControlInfoKHRBuilder<'a> {
58295     #[inline]
flags(mut self, flags: VideoCodingControlFlagsKHR) -> Self58296     pub fn flags(mut self, flags: VideoCodingControlFlagsKHR) -> Self {
58297         self.inner.flags = flags;
58298         self
58299     }
58300     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
58301     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
58302     #[doc = r" valid extension structs can be pushed into the chain."]
58303     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
58304     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsVideoCodingControlInfoKHR>(mut self, next: &'a mut T) -> Self58305     pub fn push_next<T: ExtendsVideoCodingControlInfoKHR>(mut self, next: &'a mut T) -> Self {
58306         unsafe {
58307             let next_ptr = <*const T>::cast(next);
58308             let last_next = ptr_chain_iter(next).last().unwrap();
58309             (*last_next).p_next = self.inner.p_next as _;
58310             self.inner.p_next = next_ptr;
58311         }
58312         self
58313     }
58314     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
58315     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
58316     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoCodingControlInfoKHR58317     pub fn build(self) -> VideoCodingControlInfoKHR {
58318         self.inner
58319     }
58320 }
58321 #[repr(C)]
58322 #[cfg_attr(feature = "debug", derive(Debug))]
58323 #[derive(Copy, Clone)]
58324 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeUsageInfoKHR.html>"]
58325 pub struct VideoEncodeUsageInfoKHR {
58326     pub s_type: StructureType,
58327     pub p_next: *const c_void,
58328     pub video_usage_hints: VideoEncodeUsageFlagsKHR,
58329     pub video_content_hints: VideoEncodeContentFlagsKHR,
58330     pub tuning_mode: VideoEncodeTuningModeKHR,
58331 }
58332 impl ::std::default::Default for VideoEncodeUsageInfoKHR {
58333     #[inline]
default() -> Self58334     fn default() -> Self {
58335         Self {
58336             s_type: Self::STRUCTURE_TYPE,
58337             p_next: ::std::ptr::null(),
58338             video_usage_hints: VideoEncodeUsageFlagsKHR::default(),
58339             video_content_hints: VideoEncodeContentFlagsKHR::default(),
58340             tuning_mode: VideoEncodeTuningModeKHR::default(),
58341         }
58342     }
58343 }
58344 unsafe impl TaggedStructure for VideoEncodeUsageInfoKHR {
58345     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_USAGE_INFO_KHR;
58346 }
58347 impl VideoEncodeUsageInfoKHR {
builder<'a>() -> VideoEncodeUsageInfoKHRBuilder<'a>58348     pub fn builder<'a>() -> VideoEncodeUsageInfoKHRBuilder<'a> {
58349         VideoEncodeUsageInfoKHRBuilder {
58350             inner: Self::default(),
58351             marker: ::std::marker::PhantomData,
58352         }
58353     }
58354 }
58355 #[repr(transparent)]
58356 pub struct VideoEncodeUsageInfoKHRBuilder<'a> {
58357     inner: VideoEncodeUsageInfoKHR,
58358     marker: ::std::marker::PhantomData<&'a ()>,
58359 }
58360 unsafe impl ExtendsVideoProfileInfoKHR for VideoEncodeUsageInfoKHRBuilder<'_> {}
58361 unsafe impl ExtendsVideoProfileInfoKHR for VideoEncodeUsageInfoKHR {}
58362 unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeUsageInfoKHRBuilder<'_> {}
58363 unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeUsageInfoKHR {}
58364 impl<'a> ::std::ops::Deref for VideoEncodeUsageInfoKHRBuilder<'a> {
58365     type Target = VideoEncodeUsageInfoKHR;
deref(&self) -> &Self::Target58366     fn deref(&self) -> &Self::Target {
58367         &self.inner
58368     }
58369 }
58370 impl<'a> ::std::ops::DerefMut for VideoEncodeUsageInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target58371     fn deref_mut(&mut self) -> &mut Self::Target {
58372         &mut self.inner
58373     }
58374 }
58375 impl<'a> VideoEncodeUsageInfoKHRBuilder<'a> {
58376     #[inline]
video_usage_hints(mut self, video_usage_hints: VideoEncodeUsageFlagsKHR) -> Self58377     pub fn video_usage_hints(mut self, video_usage_hints: VideoEncodeUsageFlagsKHR) -> Self {
58378         self.inner.video_usage_hints = video_usage_hints;
58379         self
58380     }
58381     #[inline]
video_content_hints(mut self, video_content_hints: VideoEncodeContentFlagsKHR) -> Self58382     pub fn video_content_hints(mut self, video_content_hints: VideoEncodeContentFlagsKHR) -> Self {
58383         self.inner.video_content_hints = video_content_hints;
58384         self
58385     }
58386     #[inline]
tuning_mode(mut self, tuning_mode: VideoEncodeTuningModeKHR) -> Self58387     pub fn tuning_mode(mut self, tuning_mode: VideoEncodeTuningModeKHR) -> Self {
58388         self.inner.tuning_mode = tuning_mode;
58389         self
58390     }
58391     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
58392     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
58393     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoEncodeUsageInfoKHR58394     pub fn build(self) -> VideoEncodeUsageInfoKHR {
58395         self.inner
58396     }
58397 }
58398 #[repr(C)]
58399 #[cfg_attr(feature = "debug", derive(Debug))]
58400 #[derive(Copy, Clone)]
58401 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeInfoKHR.html>"]
58402 pub struct VideoEncodeInfoKHR {
58403     pub s_type: StructureType,
58404     pub p_next: *const c_void,
58405     pub flags: VideoEncodeFlagsKHR,
58406     pub quality_level: u32,
58407     pub dst_buffer: Buffer,
58408     pub dst_buffer_offset: DeviceSize,
58409     pub dst_buffer_range: DeviceSize,
58410     pub src_picture_resource: VideoPictureResourceInfoKHR,
58411     pub p_setup_reference_slot: *const VideoReferenceSlotInfoKHR,
58412     pub reference_slot_count: u32,
58413     pub p_reference_slots: *const VideoReferenceSlotInfoKHR,
58414     pub preceding_externally_encoded_bytes: u32,
58415 }
58416 impl ::std::default::Default for VideoEncodeInfoKHR {
58417     #[inline]
default() -> Self58418     fn default() -> Self {
58419         Self {
58420             s_type: Self::STRUCTURE_TYPE,
58421             p_next: ::std::ptr::null(),
58422             flags: VideoEncodeFlagsKHR::default(),
58423             quality_level: u32::default(),
58424             dst_buffer: Buffer::default(),
58425             dst_buffer_offset: DeviceSize::default(),
58426             dst_buffer_range: DeviceSize::default(),
58427             src_picture_resource: VideoPictureResourceInfoKHR::default(),
58428             p_setup_reference_slot: ::std::ptr::null(),
58429             reference_slot_count: u32::default(),
58430             p_reference_slots: ::std::ptr::null(),
58431             preceding_externally_encoded_bytes: u32::default(),
58432         }
58433     }
58434 }
58435 unsafe impl TaggedStructure for VideoEncodeInfoKHR {
58436     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_INFO_KHR;
58437 }
58438 impl VideoEncodeInfoKHR {
builder<'a>() -> VideoEncodeInfoKHRBuilder<'a>58439     pub fn builder<'a>() -> VideoEncodeInfoKHRBuilder<'a> {
58440         VideoEncodeInfoKHRBuilder {
58441             inner: Self::default(),
58442             marker: ::std::marker::PhantomData,
58443         }
58444     }
58445 }
58446 #[repr(transparent)]
58447 pub struct VideoEncodeInfoKHRBuilder<'a> {
58448     inner: VideoEncodeInfoKHR,
58449     marker: ::std::marker::PhantomData<&'a ()>,
58450 }
58451 pub unsafe trait ExtendsVideoEncodeInfoKHR {}
58452 impl<'a> ::std::ops::Deref for VideoEncodeInfoKHRBuilder<'a> {
58453     type Target = VideoEncodeInfoKHR;
deref(&self) -> &Self::Target58454     fn deref(&self) -> &Self::Target {
58455         &self.inner
58456     }
58457 }
58458 impl<'a> ::std::ops::DerefMut for VideoEncodeInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target58459     fn deref_mut(&mut self) -> &mut Self::Target {
58460         &mut self.inner
58461     }
58462 }
58463 impl<'a> VideoEncodeInfoKHRBuilder<'a> {
58464     #[inline]
flags(mut self, flags: VideoEncodeFlagsKHR) -> Self58465     pub fn flags(mut self, flags: VideoEncodeFlagsKHR) -> Self {
58466         self.inner.flags = flags;
58467         self
58468     }
58469     #[inline]
quality_level(mut self, quality_level: u32) -> Self58470     pub fn quality_level(mut self, quality_level: u32) -> Self {
58471         self.inner.quality_level = quality_level;
58472         self
58473     }
58474     #[inline]
dst_buffer(mut self, dst_buffer: Buffer) -> Self58475     pub fn dst_buffer(mut self, dst_buffer: Buffer) -> Self {
58476         self.inner.dst_buffer = dst_buffer;
58477         self
58478     }
58479     #[inline]
dst_buffer_offset(mut self, dst_buffer_offset: DeviceSize) -> Self58480     pub fn dst_buffer_offset(mut self, dst_buffer_offset: DeviceSize) -> Self {
58481         self.inner.dst_buffer_offset = dst_buffer_offset;
58482         self
58483     }
58484     #[inline]
dst_buffer_range(mut self, dst_buffer_range: DeviceSize) -> Self58485     pub fn dst_buffer_range(mut self, dst_buffer_range: DeviceSize) -> Self {
58486         self.inner.dst_buffer_range = dst_buffer_range;
58487         self
58488     }
58489     #[inline]
src_picture_resource( mut self, src_picture_resource: VideoPictureResourceInfoKHR, ) -> Self58490     pub fn src_picture_resource(
58491         mut self,
58492         src_picture_resource: VideoPictureResourceInfoKHR,
58493     ) -> Self {
58494         self.inner.src_picture_resource = src_picture_resource;
58495         self
58496     }
58497     #[inline]
setup_reference_slot( mut self, setup_reference_slot: &'a VideoReferenceSlotInfoKHR, ) -> Self58498     pub fn setup_reference_slot(
58499         mut self,
58500         setup_reference_slot: &'a VideoReferenceSlotInfoKHR,
58501     ) -> Self {
58502         self.inner.p_setup_reference_slot = setup_reference_slot;
58503         self
58504     }
58505     #[inline]
reference_slots(mut self, reference_slots: &'a [VideoReferenceSlotInfoKHR]) -> Self58506     pub fn reference_slots(mut self, reference_slots: &'a [VideoReferenceSlotInfoKHR]) -> Self {
58507         self.inner.reference_slot_count = reference_slots.len() as _;
58508         self.inner.p_reference_slots = reference_slots.as_ptr();
58509         self
58510     }
58511     #[inline]
preceding_externally_encoded_bytes( mut self, preceding_externally_encoded_bytes: u32, ) -> Self58512     pub fn preceding_externally_encoded_bytes(
58513         mut self,
58514         preceding_externally_encoded_bytes: u32,
58515     ) -> Self {
58516         self.inner.preceding_externally_encoded_bytes = preceding_externally_encoded_bytes;
58517         self
58518     }
58519     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
58520     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
58521     #[doc = r" valid extension structs can be pushed into the chain."]
58522     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
58523     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsVideoEncodeInfoKHR>(mut self, next: &'a mut T) -> Self58524     pub fn push_next<T: ExtendsVideoEncodeInfoKHR>(mut self, next: &'a mut T) -> Self {
58525         unsafe {
58526             let next_ptr = <*const T>::cast(next);
58527             let last_next = ptr_chain_iter(next).last().unwrap();
58528             (*last_next).p_next = self.inner.p_next as _;
58529             self.inner.p_next = next_ptr;
58530         }
58531         self
58532     }
58533     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
58534     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
58535     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoEncodeInfoKHR58536     pub fn build(self) -> VideoEncodeInfoKHR {
58537         self.inner
58538     }
58539 }
58540 #[repr(C)]
58541 #[cfg_attr(feature = "debug", derive(Debug))]
58542 #[derive(Copy, Clone)]
58543 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPoolVideoEncodeFeedbackCreateInfoKHR.html>"]
58544 pub struct QueryPoolVideoEncodeFeedbackCreateInfoKHR {
58545     pub s_type: StructureType,
58546     pub p_next: *const c_void,
58547     pub encode_feedback_flags: VideoEncodeFeedbackFlagsKHR,
58548 }
58549 impl ::std::default::Default for QueryPoolVideoEncodeFeedbackCreateInfoKHR {
58550     #[inline]
default() -> Self58551     fn default() -> Self {
58552         Self {
58553             s_type: Self::STRUCTURE_TYPE,
58554             p_next: ::std::ptr::null(),
58555             encode_feedback_flags: VideoEncodeFeedbackFlagsKHR::default(),
58556         }
58557     }
58558 }
58559 unsafe impl TaggedStructure for QueryPoolVideoEncodeFeedbackCreateInfoKHR {
58560     const STRUCTURE_TYPE: StructureType =
58561         StructureType::QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR;
58562 }
58563 impl QueryPoolVideoEncodeFeedbackCreateInfoKHR {
builder<'a>() -> QueryPoolVideoEncodeFeedbackCreateInfoKHRBuilder<'a>58564     pub fn builder<'a>() -> QueryPoolVideoEncodeFeedbackCreateInfoKHRBuilder<'a> {
58565         QueryPoolVideoEncodeFeedbackCreateInfoKHRBuilder {
58566             inner: Self::default(),
58567             marker: ::std::marker::PhantomData,
58568         }
58569     }
58570 }
58571 #[repr(transparent)]
58572 pub struct QueryPoolVideoEncodeFeedbackCreateInfoKHRBuilder<'a> {
58573     inner: QueryPoolVideoEncodeFeedbackCreateInfoKHR,
58574     marker: ::std::marker::PhantomData<&'a ()>,
58575 }
58576 unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolVideoEncodeFeedbackCreateInfoKHRBuilder<'_> {}
58577 unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolVideoEncodeFeedbackCreateInfoKHR {}
58578 impl<'a> ::std::ops::Deref for QueryPoolVideoEncodeFeedbackCreateInfoKHRBuilder<'a> {
58579     type Target = QueryPoolVideoEncodeFeedbackCreateInfoKHR;
deref(&self) -> &Self::Target58580     fn deref(&self) -> &Self::Target {
58581         &self.inner
58582     }
58583 }
58584 impl<'a> ::std::ops::DerefMut for QueryPoolVideoEncodeFeedbackCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target58585     fn deref_mut(&mut self) -> &mut Self::Target {
58586         &mut self.inner
58587     }
58588 }
58589 impl<'a> QueryPoolVideoEncodeFeedbackCreateInfoKHRBuilder<'a> {
58590     #[inline]
encode_feedback_flags( mut self, encode_feedback_flags: VideoEncodeFeedbackFlagsKHR, ) -> Self58591     pub fn encode_feedback_flags(
58592         mut self,
58593         encode_feedback_flags: VideoEncodeFeedbackFlagsKHR,
58594     ) -> Self {
58595         self.inner.encode_feedback_flags = encode_feedback_flags;
58596         self
58597     }
58598     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
58599     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
58600     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> QueryPoolVideoEncodeFeedbackCreateInfoKHR58601     pub fn build(self) -> QueryPoolVideoEncodeFeedbackCreateInfoKHR {
58602         self.inner
58603     }
58604 }
58605 #[repr(C)]
58606 #[cfg_attr(feature = "debug", derive(Debug))]
58607 #[derive(Copy, Clone)]
58608 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeRateControlInfoKHR.html>"]
58609 pub struct VideoEncodeRateControlInfoKHR {
58610     pub s_type: StructureType,
58611     pub p_next: *const c_void,
58612     pub flags: VideoEncodeRateControlFlagsKHR,
58613     pub rate_control_mode: VideoEncodeRateControlModeFlagsKHR,
58614     pub layer_count: u32,
58615     pub p_layers: *const VideoEncodeRateControlLayerInfoKHR,
58616 }
58617 impl ::std::default::Default for VideoEncodeRateControlInfoKHR {
58618     #[inline]
default() -> Self58619     fn default() -> Self {
58620         Self {
58621             s_type: Self::STRUCTURE_TYPE,
58622             p_next: ::std::ptr::null(),
58623             flags: VideoEncodeRateControlFlagsKHR::default(),
58624             rate_control_mode: VideoEncodeRateControlModeFlagsKHR::default(),
58625             layer_count: u32::default(),
58626             p_layers: ::std::ptr::null(),
58627         }
58628     }
58629 }
58630 unsafe impl TaggedStructure for VideoEncodeRateControlInfoKHR {
58631     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_RATE_CONTROL_INFO_KHR;
58632 }
58633 impl VideoEncodeRateControlInfoKHR {
builder<'a>() -> VideoEncodeRateControlInfoKHRBuilder<'a>58634     pub fn builder<'a>() -> VideoEncodeRateControlInfoKHRBuilder<'a> {
58635         VideoEncodeRateControlInfoKHRBuilder {
58636             inner: Self::default(),
58637             marker: ::std::marker::PhantomData,
58638         }
58639     }
58640 }
58641 #[repr(transparent)]
58642 pub struct VideoEncodeRateControlInfoKHRBuilder<'a> {
58643     inner: VideoEncodeRateControlInfoKHR,
58644     marker: ::std::marker::PhantomData<&'a ()>,
58645 }
58646 unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlInfoKHRBuilder<'_> {}
58647 unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlInfoKHR {}
58648 impl<'a> ::std::ops::Deref for VideoEncodeRateControlInfoKHRBuilder<'a> {
58649     type Target = VideoEncodeRateControlInfoKHR;
deref(&self) -> &Self::Target58650     fn deref(&self) -> &Self::Target {
58651         &self.inner
58652     }
58653 }
58654 impl<'a> ::std::ops::DerefMut for VideoEncodeRateControlInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target58655     fn deref_mut(&mut self) -> &mut Self::Target {
58656         &mut self.inner
58657     }
58658 }
58659 impl<'a> VideoEncodeRateControlInfoKHRBuilder<'a> {
58660     #[inline]
flags(mut self, flags: VideoEncodeRateControlFlagsKHR) -> Self58661     pub fn flags(mut self, flags: VideoEncodeRateControlFlagsKHR) -> Self {
58662         self.inner.flags = flags;
58663         self
58664     }
58665     #[inline]
rate_control_mode( mut self, rate_control_mode: VideoEncodeRateControlModeFlagsKHR, ) -> Self58666     pub fn rate_control_mode(
58667         mut self,
58668         rate_control_mode: VideoEncodeRateControlModeFlagsKHR,
58669     ) -> Self {
58670         self.inner.rate_control_mode = rate_control_mode;
58671         self
58672     }
58673     #[inline]
layers(mut self, layers: &'a [VideoEncodeRateControlLayerInfoKHR]) -> Self58674     pub fn layers(mut self, layers: &'a [VideoEncodeRateControlLayerInfoKHR]) -> Self {
58675         self.inner.layer_count = layers.len() as _;
58676         self.inner.p_layers = layers.as_ptr();
58677         self
58678     }
58679     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
58680     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
58681     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoEncodeRateControlInfoKHR58682     pub fn build(self) -> VideoEncodeRateControlInfoKHR {
58683         self.inner
58684     }
58685 }
58686 #[repr(C)]
58687 #[cfg_attr(feature = "debug", derive(Debug))]
58688 #[derive(Copy, Clone)]
58689 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeRateControlLayerInfoKHR.html>"]
58690 pub struct VideoEncodeRateControlLayerInfoKHR {
58691     pub s_type: StructureType,
58692     pub p_next: *const c_void,
58693     pub average_bitrate: u64,
58694     pub max_bitrate: u64,
58695     pub frame_rate_numerator: u32,
58696     pub frame_rate_denominator: u32,
58697     pub virtual_buffer_size_in_ms: u32,
58698     pub initial_virtual_buffer_size_in_ms: u32,
58699 }
58700 impl ::std::default::Default for VideoEncodeRateControlLayerInfoKHR {
58701     #[inline]
default() -> Self58702     fn default() -> Self {
58703         Self {
58704             s_type: Self::STRUCTURE_TYPE,
58705             p_next: ::std::ptr::null(),
58706             average_bitrate: u64::default(),
58707             max_bitrate: u64::default(),
58708             frame_rate_numerator: u32::default(),
58709             frame_rate_denominator: u32::default(),
58710             virtual_buffer_size_in_ms: u32::default(),
58711             initial_virtual_buffer_size_in_ms: u32::default(),
58712         }
58713     }
58714 }
58715 unsafe impl TaggedStructure for VideoEncodeRateControlLayerInfoKHR {
58716     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR;
58717 }
58718 impl VideoEncodeRateControlLayerInfoKHR {
builder<'a>() -> VideoEncodeRateControlLayerInfoKHRBuilder<'a>58719     pub fn builder<'a>() -> VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
58720         VideoEncodeRateControlLayerInfoKHRBuilder {
58721             inner: Self::default(),
58722             marker: ::std::marker::PhantomData,
58723         }
58724     }
58725 }
58726 #[repr(transparent)]
58727 pub struct VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
58728     inner: VideoEncodeRateControlLayerInfoKHR,
58729     marker: ::std::marker::PhantomData<&'a ()>,
58730 }
58731 unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlLayerInfoKHRBuilder<'_> {}
58732 unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlLayerInfoKHR {}
58733 pub unsafe trait ExtendsVideoEncodeRateControlLayerInfoKHR {}
58734 impl<'a> ::std::ops::Deref for VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
58735     type Target = VideoEncodeRateControlLayerInfoKHR;
deref(&self) -> &Self::Target58736     fn deref(&self) -> &Self::Target {
58737         &self.inner
58738     }
58739 }
58740 impl<'a> ::std::ops::DerefMut for VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target58741     fn deref_mut(&mut self) -> &mut Self::Target {
58742         &mut self.inner
58743     }
58744 }
58745 impl<'a> VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
58746     #[inline]
average_bitrate(mut self, average_bitrate: u64) -> Self58747     pub fn average_bitrate(mut self, average_bitrate: u64) -> Self {
58748         self.inner.average_bitrate = average_bitrate;
58749         self
58750     }
58751     #[inline]
max_bitrate(mut self, max_bitrate: u64) -> Self58752     pub fn max_bitrate(mut self, max_bitrate: u64) -> Self {
58753         self.inner.max_bitrate = max_bitrate;
58754         self
58755     }
58756     #[inline]
frame_rate_numerator(mut self, frame_rate_numerator: u32) -> Self58757     pub fn frame_rate_numerator(mut self, frame_rate_numerator: u32) -> Self {
58758         self.inner.frame_rate_numerator = frame_rate_numerator;
58759         self
58760     }
58761     #[inline]
frame_rate_denominator(mut self, frame_rate_denominator: u32) -> Self58762     pub fn frame_rate_denominator(mut self, frame_rate_denominator: u32) -> Self {
58763         self.inner.frame_rate_denominator = frame_rate_denominator;
58764         self
58765     }
58766     #[inline]
virtual_buffer_size_in_ms(mut self, virtual_buffer_size_in_ms: u32) -> Self58767     pub fn virtual_buffer_size_in_ms(mut self, virtual_buffer_size_in_ms: u32) -> Self {
58768         self.inner.virtual_buffer_size_in_ms = virtual_buffer_size_in_ms;
58769         self
58770     }
58771     #[inline]
initial_virtual_buffer_size_in_ms( mut self, initial_virtual_buffer_size_in_ms: u32, ) -> Self58772     pub fn initial_virtual_buffer_size_in_ms(
58773         mut self,
58774         initial_virtual_buffer_size_in_ms: u32,
58775     ) -> Self {
58776         self.inner.initial_virtual_buffer_size_in_ms = initial_virtual_buffer_size_in_ms;
58777         self
58778     }
58779     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
58780     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
58781     #[doc = r" valid extension structs can be pushed into the chain."]
58782     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
58783     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsVideoEncodeRateControlLayerInfoKHR>( mut self, next: &'a mut T, ) -> Self58784     pub fn push_next<T: ExtendsVideoEncodeRateControlLayerInfoKHR>(
58785         mut self,
58786         next: &'a mut T,
58787     ) -> Self {
58788         unsafe {
58789             let next_ptr = <*const T>::cast(next);
58790             let last_next = ptr_chain_iter(next).last().unwrap();
58791             (*last_next).p_next = self.inner.p_next as _;
58792             self.inner.p_next = next_ptr;
58793         }
58794         self
58795     }
58796     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
58797     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
58798     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoEncodeRateControlLayerInfoKHR58799     pub fn build(self) -> VideoEncodeRateControlLayerInfoKHR {
58800         self.inner
58801     }
58802 }
58803 #[repr(C)]
58804 #[cfg_attr(feature = "debug", derive(Debug))]
58805 #[derive(Copy, Clone)]
58806 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeCapabilitiesKHR.html>"]
58807 pub struct VideoEncodeCapabilitiesKHR {
58808     pub s_type: StructureType,
58809     pub p_next: *mut c_void,
58810     pub flags: VideoEncodeCapabilityFlagsKHR,
58811     pub rate_control_modes: VideoEncodeRateControlModeFlagsKHR,
58812     pub max_rate_control_layers: u32,
58813     pub max_quality_levels: u32,
58814     pub input_image_data_fill_alignment: Extent2D,
58815     pub supported_encode_feedback_flags: VideoEncodeFeedbackFlagsKHR,
58816 }
58817 impl ::std::default::Default for VideoEncodeCapabilitiesKHR {
58818     #[inline]
default() -> Self58819     fn default() -> Self {
58820         Self {
58821             s_type: Self::STRUCTURE_TYPE,
58822             p_next: ::std::ptr::null_mut(),
58823             flags: VideoEncodeCapabilityFlagsKHR::default(),
58824             rate_control_modes: VideoEncodeRateControlModeFlagsKHR::default(),
58825             max_rate_control_layers: u32::default(),
58826             max_quality_levels: u32::default(),
58827             input_image_data_fill_alignment: Extent2D::default(),
58828             supported_encode_feedback_flags: VideoEncodeFeedbackFlagsKHR::default(),
58829         }
58830     }
58831 }
58832 unsafe impl TaggedStructure for VideoEncodeCapabilitiesKHR {
58833     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_CAPABILITIES_KHR;
58834 }
58835 impl VideoEncodeCapabilitiesKHR {
builder<'a>() -> VideoEncodeCapabilitiesKHRBuilder<'a>58836     pub fn builder<'a>() -> VideoEncodeCapabilitiesKHRBuilder<'a> {
58837         VideoEncodeCapabilitiesKHRBuilder {
58838             inner: Self::default(),
58839             marker: ::std::marker::PhantomData,
58840         }
58841     }
58842 }
58843 #[repr(transparent)]
58844 pub struct VideoEncodeCapabilitiesKHRBuilder<'a> {
58845     inner: VideoEncodeCapabilitiesKHR,
58846     marker: ::std::marker::PhantomData<&'a ()>,
58847 }
58848 unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeCapabilitiesKHRBuilder<'_> {}
58849 unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeCapabilitiesKHR {}
58850 impl<'a> ::std::ops::Deref for VideoEncodeCapabilitiesKHRBuilder<'a> {
58851     type Target = VideoEncodeCapabilitiesKHR;
deref(&self) -> &Self::Target58852     fn deref(&self) -> &Self::Target {
58853         &self.inner
58854     }
58855 }
58856 impl<'a> ::std::ops::DerefMut for VideoEncodeCapabilitiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target58857     fn deref_mut(&mut self) -> &mut Self::Target {
58858         &mut self.inner
58859     }
58860 }
58861 impl<'a> VideoEncodeCapabilitiesKHRBuilder<'a> {
58862     #[inline]
flags(mut self, flags: VideoEncodeCapabilityFlagsKHR) -> Self58863     pub fn flags(mut self, flags: VideoEncodeCapabilityFlagsKHR) -> Self {
58864         self.inner.flags = flags;
58865         self
58866     }
58867     #[inline]
rate_control_modes( mut self, rate_control_modes: VideoEncodeRateControlModeFlagsKHR, ) -> Self58868     pub fn rate_control_modes(
58869         mut self,
58870         rate_control_modes: VideoEncodeRateControlModeFlagsKHR,
58871     ) -> Self {
58872         self.inner.rate_control_modes = rate_control_modes;
58873         self
58874     }
58875     #[inline]
max_rate_control_layers(mut self, max_rate_control_layers: u32) -> Self58876     pub fn max_rate_control_layers(mut self, max_rate_control_layers: u32) -> Self {
58877         self.inner.max_rate_control_layers = max_rate_control_layers;
58878         self
58879     }
58880     #[inline]
max_quality_levels(mut self, max_quality_levels: u32) -> Self58881     pub fn max_quality_levels(mut self, max_quality_levels: u32) -> Self {
58882         self.inner.max_quality_levels = max_quality_levels;
58883         self
58884     }
58885     #[inline]
input_image_data_fill_alignment( mut self, input_image_data_fill_alignment: Extent2D, ) -> Self58886     pub fn input_image_data_fill_alignment(
58887         mut self,
58888         input_image_data_fill_alignment: Extent2D,
58889     ) -> Self {
58890         self.inner.input_image_data_fill_alignment = input_image_data_fill_alignment;
58891         self
58892     }
58893     #[inline]
supported_encode_feedback_flags( mut self, supported_encode_feedback_flags: VideoEncodeFeedbackFlagsKHR, ) -> Self58894     pub fn supported_encode_feedback_flags(
58895         mut self,
58896         supported_encode_feedback_flags: VideoEncodeFeedbackFlagsKHR,
58897     ) -> Self {
58898         self.inner.supported_encode_feedback_flags = supported_encode_feedback_flags;
58899         self
58900     }
58901     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
58902     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
58903     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoEncodeCapabilitiesKHR58904     pub fn build(self) -> VideoEncodeCapabilitiesKHR {
58905         self.inner
58906     }
58907 }
58908 #[repr(C)]
58909 #[cfg_attr(feature = "debug", derive(Debug))]
58910 #[derive(Copy, Clone)]
58911 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264CapabilitiesEXT.html>"]
58912 pub struct VideoEncodeH264CapabilitiesEXT {
58913     pub s_type: StructureType,
58914     pub p_next: *mut c_void,
58915     pub flags: VideoEncodeH264CapabilityFlagsEXT,
58916     pub max_p_picture_l0_reference_count: u32,
58917     pub max_b_picture_l0_reference_count: u32,
58918     pub max_l1_reference_count: u32,
58919     pub motion_vectors_over_pic_boundaries_flag: Bool32,
58920     pub max_bytes_per_pic_denom: u32,
58921     pub max_bits_per_mb_denom: u32,
58922     pub log2_max_mv_length_horizontal: u32,
58923     pub log2_max_mv_length_vertical: u32,
58924 }
58925 impl ::std::default::Default for VideoEncodeH264CapabilitiesEXT {
58926     #[inline]
default() -> Self58927     fn default() -> Self {
58928         Self {
58929             s_type: Self::STRUCTURE_TYPE,
58930             p_next: ::std::ptr::null_mut(),
58931             flags: VideoEncodeH264CapabilityFlagsEXT::default(),
58932             max_p_picture_l0_reference_count: u32::default(),
58933             max_b_picture_l0_reference_count: u32::default(),
58934             max_l1_reference_count: u32::default(),
58935             motion_vectors_over_pic_boundaries_flag: Bool32::default(),
58936             max_bytes_per_pic_denom: u32::default(),
58937             max_bits_per_mb_denom: u32::default(),
58938             log2_max_mv_length_horizontal: u32::default(),
58939             log2_max_mv_length_vertical: u32::default(),
58940         }
58941     }
58942 }
58943 unsafe impl TaggedStructure for VideoEncodeH264CapabilitiesEXT {
58944     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_CAPABILITIES_EXT;
58945 }
58946 impl VideoEncodeH264CapabilitiesEXT {
builder<'a>() -> VideoEncodeH264CapabilitiesEXTBuilder<'a>58947     pub fn builder<'a>() -> VideoEncodeH264CapabilitiesEXTBuilder<'a> {
58948         VideoEncodeH264CapabilitiesEXTBuilder {
58949             inner: Self::default(),
58950             marker: ::std::marker::PhantomData,
58951         }
58952     }
58953 }
58954 #[repr(transparent)]
58955 pub struct VideoEncodeH264CapabilitiesEXTBuilder<'a> {
58956     inner: VideoEncodeH264CapabilitiesEXT,
58957     marker: ::std::marker::PhantomData<&'a ()>,
58958 }
58959 unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeH264CapabilitiesEXTBuilder<'_> {}
58960 unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeH264CapabilitiesEXT {}
58961 impl<'a> ::std::ops::Deref for VideoEncodeH264CapabilitiesEXTBuilder<'a> {
58962     type Target = VideoEncodeH264CapabilitiesEXT;
deref(&self) -> &Self::Target58963     fn deref(&self) -> &Self::Target {
58964         &self.inner
58965     }
58966 }
58967 impl<'a> ::std::ops::DerefMut for VideoEncodeH264CapabilitiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target58968     fn deref_mut(&mut self) -> &mut Self::Target {
58969         &mut self.inner
58970     }
58971 }
58972 impl<'a> VideoEncodeH264CapabilitiesEXTBuilder<'a> {
58973     #[inline]
flags(mut self, flags: VideoEncodeH264CapabilityFlagsEXT) -> Self58974     pub fn flags(mut self, flags: VideoEncodeH264CapabilityFlagsEXT) -> Self {
58975         self.inner.flags = flags;
58976         self
58977     }
58978     #[inline]
max_p_picture_l0_reference_count( mut self, max_p_picture_l0_reference_count: u32, ) -> Self58979     pub fn max_p_picture_l0_reference_count(
58980         mut self,
58981         max_p_picture_l0_reference_count: u32,
58982     ) -> Self {
58983         self.inner.max_p_picture_l0_reference_count = max_p_picture_l0_reference_count;
58984         self
58985     }
58986     #[inline]
max_b_picture_l0_reference_count( mut self, max_b_picture_l0_reference_count: u32, ) -> Self58987     pub fn max_b_picture_l0_reference_count(
58988         mut self,
58989         max_b_picture_l0_reference_count: u32,
58990     ) -> Self {
58991         self.inner.max_b_picture_l0_reference_count = max_b_picture_l0_reference_count;
58992         self
58993     }
58994     #[inline]
max_l1_reference_count(mut self, max_l1_reference_count: u32) -> Self58995     pub fn max_l1_reference_count(mut self, max_l1_reference_count: u32) -> Self {
58996         self.inner.max_l1_reference_count = max_l1_reference_count;
58997         self
58998     }
58999     #[inline]
motion_vectors_over_pic_boundaries_flag( mut self, motion_vectors_over_pic_boundaries_flag: bool, ) -> Self59000     pub fn motion_vectors_over_pic_boundaries_flag(
59001         mut self,
59002         motion_vectors_over_pic_boundaries_flag: bool,
59003     ) -> Self {
59004         self.inner.motion_vectors_over_pic_boundaries_flag =
59005             motion_vectors_over_pic_boundaries_flag.into();
59006         self
59007     }
59008     #[inline]
max_bytes_per_pic_denom(mut self, max_bytes_per_pic_denom: u32) -> Self59009     pub fn max_bytes_per_pic_denom(mut self, max_bytes_per_pic_denom: u32) -> Self {
59010         self.inner.max_bytes_per_pic_denom = max_bytes_per_pic_denom;
59011         self
59012     }
59013     #[inline]
max_bits_per_mb_denom(mut self, max_bits_per_mb_denom: u32) -> Self59014     pub fn max_bits_per_mb_denom(mut self, max_bits_per_mb_denom: u32) -> Self {
59015         self.inner.max_bits_per_mb_denom = max_bits_per_mb_denom;
59016         self
59017     }
59018     #[inline]
log2_max_mv_length_horizontal(mut self, log2_max_mv_length_horizontal: u32) -> Self59019     pub fn log2_max_mv_length_horizontal(mut self, log2_max_mv_length_horizontal: u32) -> Self {
59020         self.inner.log2_max_mv_length_horizontal = log2_max_mv_length_horizontal;
59021         self
59022     }
59023     #[inline]
log2_max_mv_length_vertical(mut self, log2_max_mv_length_vertical: u32) -> Self59024     pub fn log2_max_mv_length_vertical(mut self, log2_max_mv_length_vertical: u32) -> Self {
59025         self.inner.log2_max_mv_length_vertical = log2_max_mv_length_vertical;
59026         self
59027     }
59028     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
59029     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
59030     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoEncodeH264CapabilitiesEXT59031     pub fn build(self) -> VideoEncodeH264CapabilitiesEXT {
59032         self.inner
59033     }
59034 }
59035 #[repr(C)]
59036 #[cfg_attr(feature = "debug", derive(Debug))]
59037 #[derive(Copy, Clone)]
59038 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264SessionParametersAddInfoEXT.html>"]
59039 pub struct VideoEncodeH264SessionParametersAddInfoEXT {
59040     pub s_type: StructureType,
59041     pub p_next: *const c_void,
59042     pub std_sps_count: u32,
59043     pub p_std_sp_ss: *const StdVideoH264SequenceParameterSet,
59044     pub std_pps_count: u32,
59045     pub p_std_pp_ss: *const StdVideoH264PictureParameterSet,
59046 }
59047 impl ::std::default::Default for VideoEncodeH264SessionParametersAddInfoEXT {
59048     #[inline]
default() -> Self59049     fn default() -> Self {
59050         Self {
59051             s_type: Self::STRUCTURE_TYPE,
59052             p_next: ::std::ptr::null(),
59053             std_sps_count: u32::default(),
59054             p_std_sp_ss: ::std::ptr::null(),
59055             std_pps_count: u32::default(),
59056             p_std_pp_ss: ::std::ptr::null(),
59057         }
59058     }
59059 }
59060 unsafe impl TaggedStructure for VideoEncodeH264SessionParametersAddInfoEXT {
59061     const STRUCTURE_TYPE: StructureType =
59062         StructureType::VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT;
59063 }
59064 impl VideoEncodeH264SessionParametersAddInfoEXT {
builder<'a>() -> VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a>59065     pub fn builder<'a>() -> VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> {
59066         VideoEncodeH264SessionParametersAddInfoEXTBuilder {
59067             inner: Self::default(),
59068             marker: ::std::marker::PhantomData,
59069         }
59070     }
59071 }
59072 #[repr(transparent)]
59073 pub struct VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> {
59074     inner: VideoEncodeH264SessionParametersAddInfoEXT,
59075     marker: ::std::marker::PhantomData<&'a ()>,
59076 }
59077 unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
59078     for VideoEncodeH264SessionParametersAddInfoEXTBuilder<'_>
59079 {
59080 }
59081 unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
59082     for VideoEncodeH264SessionParametersAddInfoEXT
59083 {
59084 }
59085 impl<'a> ::std::ops::Deref for VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> {
59086     type Target = VideoEncodeH264SessionParametersAddInfoEXT;
deref(&self) -> &Self::Target59087     fn deref(&self) -> &Self::Target {
59088         &self.inner
59089     }
59090 }
59091 impl<'a> ::std::ops::DerefMut for VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target59092     fn deref_mut(&mut self) -> &mut Self::Target {
59093         &mut self.inner
59094     }
59095 }
59096 impl<'a> VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> {
59097     #[inline]
std_sp_ss(mut self, std_sp_ss: &'a [StdVideoH264SequenceParameterSet]) -> Self59098     pub fn std_sp_ss(mut self, std_sp_ss: &'a [StdVideoH264SequenceParameterSet]) -> Self {
59099         self.inner.std_sps_count = std_sp_ss.len() as _;
59100         self.inner.p_std_sp_ss = std_sp_ss.as_ptr();
59101         self
59102     }
59103     #[inline]
std_pp_ss(mut self, std_pp_ss: &'a [StdVideoH264PictureParameterSet]) -> Self59104     pub fn std_pp_ss(mut self, std_pp_ss: &'a [StdVideoH264PictureParameterSet]) -> Self {
59105         self.inner.std_pps_count = std_pp_ss.len() as _;
59106         self.inner.p_std_pp_ss = std_pp_ss.as_ptr();
59107         self
59108     }
59109     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
59110     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
59111     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoEncodeH264SessionParametersAddInfoEXT59112     pub fn build(self) -> VideoEncodeH264SessionParametersAddInfoEXT {
59113         self.inner
59114     }
59115 }
59116 #[repr(C)]
59117 #[cfg_attr(feature = "debug", derive(Debug))]
59118 #[derive(Copy, Clone)]
59119 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264SessionParametersCreateInfoEXT.html>"]
59120 pub struct VideoEncodeH264SessionParametersCreateInfoEXT {
59121     pub s_type: StructureType,
59122     pub p_next: *const c_void,
59123     pub max_std_sps_count: u32,
59124     pub max_std_pps_count: u32,
59125     pub p_parameters_add_info: *const VideoEncodeH264SessionParametersAddInfoEXT,
59126 }
59127 impl ::std::default::Default for VideoEncodeH264SessionParametersCreateInfoEXT {
59128     #[inline]
default() -> Self59129     fn default() -> Self {
59130         Self {
59131             s_type: Self::STRUCTURE_TYPE,
59132             p_next: ::std::ptr::null(),
59133             max_std_sps_count: u32::default(),
59134             max_std_pps_count: u32::default(),
59135             p_parameters_add_info: ::std::ptr::null(),
59136         }
59137     }
59138 }
59139 unsafe impl TaggedStructure for VideoEncodeH264SessionParametersCreateInfoEXT {
59140     const STRUCTURE_TYPE: StructureType =
59141         StructureType::VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT;
59142 }
59143 impl VideoEncodeH264SessionParametersCreateInfoEXT {
builder<'a>() -> VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a>59144     pub fn builder<'a>() -> VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> {
59145         VideoEncodeH264SessionParametersCreateInfoEXTBuilder {
59146             inner: Self::default(),
59147             marker: ::std::marker::PhantomData,
59148         }
59149     }
59150 }
59151 #[repr(transparent)]
59152 pub struct VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> {
59153     inner: VideoEncodeH264SessionParametersCreateInfoEXT,
59154     marker: ::std::marker::PhantomData<&'a ()>,
59155 }
59156 unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
59157     for VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'_>
59158 {
59159 }
59160 unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
59161     for VideoEncodeH264SessionParametersCreateInfoEXT
59162 {
59163 }
59164 impl<'a> ::std::ops::Deref for VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> {
59165     type Target = VideoEncodeH264SessionParametersCreateInfoEXT;
deref(&self) -> &Self::Target59166     fn deref(&self) -> &Self::Target {
59167         &self.inner
59168     }
59169 }
59170 impl<'a> ::std::ops::DerefMut for VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target59171     fn deref_mut(&mut self) -> &mut Self::Target {
59172         &mut self.inner
59173     }
59174 }
59175 impl<'a> VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> {
59176     #[inline]
max_std_sps_count(mut self, max_std_sps_count: u32) -> Self59177     pub fn max_std_sps_count(mut self, max_std_sps_count: u32) -> Self {
59178         self.inner.max_std_sps_count = max_std_sps_count;
59179         self
59180     }
59181     #[inline]
max_std_pps_count(mut self, max_std_pps_count: u32) -> Self59182     pub fn max_std_pps_count(mut self, max_std_pps_count: u32) -> Self {
59183         self.inner.max_std_pps_count = max_std_pps_count;
59184         self
59185     }
59186     #[inline]
parameters_add_info( mut self, parameters_add_info: &'a VideoEncodeH264SessionParametersAddInfoEXT, ) -> Self59187     pub fn parameters_add_info(
59188         mut self,
59189         parameters_add_info: &'a VideoEncodeH264SessionParametersAddInfoEXT,
59190     ) -> Self {
59191         self.inner.p_parameters_add_info = parameters_add_info;
59192         self
59193     }
59194     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
59195     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
59196     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoEncodeH264SessionParametersCreateInfoEXT59197     pub fn build(self) -> VideoEncodeH264SessionParametersCreateInfoEXT {
59198         self.inner
59199     }
59200 }
59201 #[repr(C)]
59202 #[cfg_attr(feature = "debug", derive(Debug))]
59203 #[derive(Copy, Clone)]
59204 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264DpbSlotInfoEXT.html>"]
59205 pub struct VideoEncodeH264DpbSlotInfoEXT {
59206     pub s_type: StructureType,
59207     pub p_next: *const c_void,
59208     pub p_std_reference_info: *const StdVideoEncodeH264ReferenceInfo,
59209 }
59210 impl ::std::default::Default for VideoEncodeH264DpbSlotInfoEXT {
59211     #[inline]
default() -> Self59212     fn default() -> Self {
59213         Self {
59214             s_type: Self::STRUCTURE_TYPE,
59215             p_next: ::std::ptr::null(),
59216             p_std_reference_info: ::std::ptr::null(),
59217         }
59218     }
59219 }
59220 unsafe impl TaggedStructure for VideoEncodeH264DpbSlotInfoEXT {
59221     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT;
59222 }
59223 impl VideoEncodeH264DpbSlotInfoEXT {
builder<'a>() -> VideoEncodeH264DpbSlotInfoEXTBuilder<'a>59224     pub fn builder<'a>() -> VideoEncodeH264DpbSlotInfoEXTBuilder<'a> {
59225         VideoEncodeH264DpbSlotInfoEXTBuilder {
59226             inner: Self::default(),
59227             marker: ::std::marker::PhantomData,
59228         }
59229     }
59230 }
59231 #[repr(transparent)]
59232 pub struct VideoEncodeH264DpbSlotInfoEXTBuilder<'a> {
59233     inner: VideoEncodeH264DpbSlotInfoEXT,
59234     marker: ::std::marker::PhantomData<&'a ()>,
59235 }
59236 unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoEncodeH264DpbSlotInfoEXTBuilder<'_> {}
59237 unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoEncodeH264DpbSlotInfoEXT {}
59238 impl<'a> ::std::ops::Deref for VideoEncodeH264DpbSlotInfoEXTBuilder<'a> {
59239     type Target = VideoEncodeH264DpbSlotInfoEXT;
deref(&self) -> &Self::Target59240     fn deref(&self) -> &Self::Target {
59241         &self.inner
59242     }
59243 }
59244 impl<'a> ::std::ops::DerefMut for VideoEncodeH264DpbSlotInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target59245     fn deref_mut(&mut self) -> &mut Self::Target {
59246         &mut self.inner
59247     }
59248 }
59249 impl<'a> VideoEncodeH264DpbSlotInfoEXTBuilder<'a> {
59250     #[inline]
std_reference_info( mut self, std_reference_info: &'a StdVideoEncodeH264ReferenceInfo, ) -> Self59251     pub fn std_reference_info(
59252         mut self,
59253         std_reference_info: &'a StdVideoEncodeH264ReferenceInfo,
59254     ) -> Self {
59255         self.inner.p_std_reference_info = std_reference_info;
59256         self
59257     }
59258     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
59259     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
59260     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoEncodeH264DpbSlotInfoEXT59261     pub fn build(self) -> VideoEncodeH264DpbSlotInfoEXT {
59262         self.inner
59263     }
59264 }
59265 #[repr(C)]
59266 #[cfg_attr(feature = "debug", derive(Debug))]
59267 #[derive(Copy, Clone)]
59268 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264VclFrameInfoEXT.html>"]
59269 pub struct VideoEncodeH264VclFrameInfoEXT {
59270     pub s_type: StructureType,
59271     pub p_next: *const c_void,
59272     pub p_std_reference_final_lists: *const StdVideoEncodeH264ReferenceListsInfo,
59273     pub nalu_slice_entry_count: u32,
59274     pub p_nalu_slice_entries: *const VideoEncodeH264NaluSliceInfoEXT,
59275     pub p_std_picture_info: *const StdVideoEncodeH264PictureInfo,
59276 }
59277 impl ::std::default::Default for VideoEncodeH264VclFrameInfoEXT {
59278     #[inline]
default() -> Self59279     fn default() -> Self {
59280         Self {
59281             s_type: Self::STRUCTURE_TYPE,
59282             p_next: ::std::ptr::null(),
59283             p_std_reference_final_lists: ::std::ptr::null(),
59284             nalu_slice_entry_count: u32::default(),
59285             p_nalu_slice_entries: ::std::ptr::null(),
59286             p_std_picture_info: ::std::ptr::null(),
59287         }
59288     }
59289 }
59290 unsafe impl TaggedStructure for VideoEncodeH264VclFrameInfoEXT {
59291     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT;
59292 }
59293 impl VideoEncodeH264VclFrameInfoEXT {
builder<'a>() -> VideoEncodeH264VclFrameInfoEXTBuilder<'a>59294     pub fn builder<'a>() -> VideoEncodeH264VclFrameInfoEXTBuilder<'a> {
59295         VideoEncodeH264VclFrameInfoEXTBuilder {
59296             inner: Self::default(),
59297             marker: ::std::marker::PhantomData,
59298         }
59299     }
59300 }
59301 #[repr(transparent)]
59302 pub struct VideoEncodeH264VclFrameInfoEXTBuilder<'a> {
59303     inner: VideoEncodeH264VclFrameInfoEXT,
59304     marker: ::std::marker::PhantomData<&'a ()>,
59305 }
59306 unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264VclFrameInfoEXTBuilder<'_> {}
59307 unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264VclFrameInfoEXT {}
59308 impl<'a> ::std::ops::Deref for VideoEncodeH264VclFrameInfoEXTBuilder<'a> {
59309     type Target = VideoEncodeH264VclFrameInfoEXT;
deref(&self) -> &Self::Target59310     fn deref(&self) -> &Self::Target {
59311         &self.inner
59312     }
59313 }
59314 impl<'a> ::std::ops::DerefMut for VideoEncodeH264VclFrameInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target59315     fn deref_mut(&mut self) -> &mut Self::Target {
59316         &mut self.inner
59317     }
59318 }
59319 impl<'a> VideoEncodeH264VclFrameInfoEXTBuilder<'a> {
59320     #[inline]
std_reference_final_lists( mut self, std_reference_final_lists: &'a StdVideoEncodeH264ReferenceListsInfo, ) -> Self59321     pub fn std_reference_final_lists(
59322         mut self,
59323         std_reference_final_lists: &'a StdVideoEncodeH264ReferenceListsInfo,
59324     ) -> Self {
59325         self.inner.p_std_reference_final_lists = std_reference_final_lists;
59326         self
59327     }
59328     #[inline]
nalu_slice_entries( mut self, nalu_slice_entries: &'a [VideoEncodeH264NaluSliceInfoEXT], ) -> Self59329     pub fn nalu_slice_entries(
59330         mut self,
59331         nalu_slice_entries: &'a [VideoEncodeH264NaluSliceInfoEXT],
59332     ) -> Self {
59333         self.inner.nalu_slice_entry_count = nalu_slice_entries.len() as _;
59334         self.inner.p_nalu_slice_entries = nalu_slice_entries.as_ptr();
59335         self
59336     }
59337     #[inline]
std_picture_info(mut self, std_picture_info: &'a StdVideoEncodeH264PictureInfo) -> Self59338     pub fn std_picture_info(mut self, std_picture_info: &'a StdVideoEncodeH264PictureInfo) -> Self {
59339         self.inner.p_std_picture_info = std_picture_info;
59340         self
59341     }
59342     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
59343     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
59344     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoEncodeH264VclFrameInfoEXT59345     pub fn build(self) -> VideoEncodeH264VclFrameInfoEXT {
59346         self.inner
59347     }
59348 }
59349 #[repr(C)]
59350 #[cfg_attr(feature = "debug", derive(Debug))]
59351 #[derive(Copy, Clone)]
59352 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264ProfileInfoEXT.html>"]
59353 pub struct VideoEncodeH264ProfileInfoEXT {
59354     pub s_type: StructureType,
59355     pub p_next: *const c_void,
59356     pub std_profile_idc: StdVideoH264ProfileIdc,
59357 }
59358 impl ::std::default::Default for VideoEncodeH264ProfileInfoEXT {
59359     #[inline]
default() -> Self59360     fn default() -> Self {
59361         Self {
59362             s_type: Self::STRUCTURE_TYPE,
59363             p_next: ::std::ptr::null(),
59364             std_profile_idc: StdVideoH264ProfileIdc::default(),
59365         }
59366     }
59367 }
59368 unsafe impl TaggedStructure for VideoEncodeH264ProfileInfoEXT {
59369     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_PROFILE_INFO_EXT;
59370 }
59371 impl VideoEncodeH264ProfileInfoEXT {
builder<'a>() -> VideoEncodeH264ProfileInfoEXTBuilder<'a>59372     pub fn builder<'a>() -> VideoEncodeH264ProfileInfoEXTBuilder<'a> {
59373         VideoEncodeH264ProfileInfoEXTBuilder {
59374             inner: Self::default(),
59375             marker: ::std::marker::PhantomData,
59376         }
59377     }
59378 }
59379 #[repr(transparent)]
59380 pub struct VideoEncodeH264ProfileInfoEXTBuilder<'a> {
59381     inner: VideoEncodeH264ProfileInfoEXT,
59382     marker: ::std::marker::PhantomData<&'a ()>,
59383 }
59384 unsafe impl ExtendsVideoProfileInfoKHR for VideoEncodeH264ProfileInfoEXTBuilder<'_> {}
59385 unsafe impl ExtendsVideoProfileInfoKHR for VideoEncodeH264ProfileInfoEXT {}
59386 unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH264ProfileInfoEXTBuilder<'_> {}
59387 unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH264ProfileInfoEXT {}
59388 impl<'a> ::std::ops::Deref for VideoEncodeH264ProfileInfoEXTBuilder<'a> {
59389     type Target = VideoEncodeH264ProfileInfoEXT;
deref(&self) -> &Self::Target59390     fn deref(&self) -> &Self::Target {
59391         &self.inner
59392     }
59393 }
59394 impl<'a> ::std::ops::DerefMut for VideoEncodeH264ProfileInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target59395     fn deref_mut(&mut self) -> &mut Self::Target {
59396         &mut self.inner
59397     }
59398 }
59399 impl<'a> VideoEncodeH264ProfileInfoEXTBuilder<'a> {
59400     #[inline]
std_profile_idc(mut self, std_profile_idc: StdVideoH264ProfileIdc) -> Self59401     pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH264ProfileIdc) -> Self {
59402         self.inner.std_profile_idc = std_profile_idc;
59403         self
59404     }
59405     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
59406     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
59407     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoEncodeH264ProfileInfoEXT59408     pub fn build(self) -> VideoEncodeH264ProfileInfoEXT {
59409         self.inner
59410     }
59411 }
59412 #[repr(C)]
59413 #[cfg_attr(feature = "debug", derive(Debug))]
59414 #[derive(Copy, Clone)]
59415 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264NaluSliceInfoEXT.html>"]
59416 pub struct VideoEncodeH264NaluSliceInfoEXT {
59417     pub s_type: StructureType,
59418     pub p_next: *const c_void,
59419     pub mb_count: u32,
59420     pub p_std_reference_final_lists: *const StdVideoEncodeH264ReferenceListsInfo,
59421     pub p_std_slice_header: *const StdVideoEncodeH264SliceHeader,
59422 }
59423 impl ::std::default::Default for VideoEncodeH264NaluSliceInfoEXT {
59424     #[inline]
default() -> Self59425     fn default() -> Self {
59426         Self {
59427             s_type: Self::STRUCTURE_TYPE,
59428             p_next: ::std::ptr::null(),
59429             mb_count: u32::default(),
59430             p_std_reference_final_lists: ::std::ptr::null(),
59431             p_std_slice_header: ::std::ptr::null(),
59432         }
59433     }
59434 }
59435 unsafe impl TaggedStructure for VideoEncodeH264NaluSliceInfoEXT {
59436     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT;
59437 }
59438 impl VideoEncodeH264NaluSliceInfoEXT {
builder<'a>() -> VideoEncodeH264NaluSliceInfoEXTBuilder<'a>59439     pub fn builder<'a>() -> VideoEncodeH264NaluSliceInfoEXTBuilder<'a> {
59440         VideoEncodeH264NaluSliceInfoEXTBuilder {
59441             inner: Self::default(),
59442             marker: ::std::marker::PhantomData,
59443         }
59444     }
59445 }
59446 #[repr(transparent)]
59447 pub struct VideoEncodeH264NaluSliceInfoEXTBuilder<'a> {
59448     inner: VideoEncodeH264NaluSliceInfoEXT,
59449     marker: ::std::marker::PhantomData<&'a ()>,
59450 }
59451 impl<'a> ::std::ops::Deref for VideoEncodeH264NaluSliceInfoEXTBuilder<'a> {
59452     type Target = VideoEncodeH264NaluSliceInfoEXT;
deref(&self) -> &Self::Target59453     fn deref(&self) -> &Self::Target {
59454         &self.inner
59455     }
59456 }
59457 impl<'a> ::std::ops::DerefMut for VideoEncodeH264NaluSliceInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target59458     fn deref_mut(&mut self) -> &mut Self::Target {
59459         &mut self.inner
59460     }
59461 }
59462 impl<'a> VideoEncodeH264NaluSliceInfoEXTBuilder<'a> {
59463     #[inline]
mb_count(mut self, mb_count: u32) -> Self59464     pub fn mb_count(mut self, mb_count: u32) -> Self {
59465         self.inner.mb_count = mb_count;
59466         self
59467     }
59468     #[inline]
std_reference_final_lists( mut self, std_reference_final_lists: &'a StdVideoEncodeH264ReferenceListsInfo, ) -> Self59469     pub fn std_reference_final_lists(
59470         mut self,
59471         std_reference_final_lists: &'a StdVideoEncodeH264ReferenceListsInfo,
59472     ) -> Self {
59473         self.inner.p_std_reference_final_lists = std_reference_final_lists;
59474         self
59475     }
59476     #[inline]
std_slice_header(mut self, std_slice_header: &'a StdVideoEncodeH264SliceHeader) -> Self59477     pub fn std_slice_header(mut self, std_slice_header: &'a StdVideoEncodeH264SliceHeader) -> Self {
59478         self.inner.p_std_slice_header = std_slice_header;
59479         self
59480     }
59481     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
59482     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
59483     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoEncodeH264NaluSliceInfoEXT59484     pub fn build(self) -> VideoEncodeH264NaluSliceInfoEXT {
59485         self.inner
59486     }
59487 }
59488 #[repr(C)]
59489 #[cfg_attr(feature = "debug", derive(Debug))]
59490 #[derive(Copy, Clone)]
59491 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264RateControlInfoEXT.html>"]
59492 pub struct VideoEncodeH264RateControlInfoEXT {
59493     pub s_type: StructureType,
59494     pub p_next: *const c_void,
59495     pub gop_frame_count: u32,
59496     pub idr_period: u32,
59497     pub consecutive_b_frame_count: u32,
59498     pub rate_control_structure: VideoEncodeH264RateControlStructureEXT,
59499     pub temporal_layer_count: u32,
59500 }
59501 impl ::std::default::Default for VideoEncodeH264RateControlInfoEXT {
59502     #[inline]
default() -> Self59503     fn default() -> Self {
59504         Self {
59505             s_type: Self::STRUCTURE_TYPE,
59506             p_next: ::std::ptr::null(),
59507             gop_frame_count: u32::default(),
59508             idr_period: u32::default(),
59509             consecutive_b_frame_count: u32::default(),
59510             rate_control_structure: VideoEncodeH264RateControlStructureEXT::default(),
59511             temporal_layer_count: u32::default(),
59512         }
59513     }
59514 }
59515 unsafe impl TaggedStructure for VideoEncodeH264RateControlInfoEXT {
59516     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT;
59517 }
59518 impl VideoEncodeH264RateControlInfoEXT {
builder<'a>() -> VideoEncodeH264RateControlInfoEXTBuilder<'a>59519     pub fn builder<'a>() -> VideoEncodeH264RateControlInfoEXTBuilder<'a> {
59520         VideoEncodeH264RateControlInfoEXTBuilder {
59521             inner: Self::default(),
59522             marker: ::std::marker::PhantomData,
59523         }
59524     }
59525 }
59526 #[repr(transparent)]
59527 pub struct VideoEncodeH264RateControlInfoEXTBuilder<'a> {
59528     inner: VideoEncodeH264RateControlInfoEXT,
59529     marker: ::std::marker::PhantomData<&'a ()>,
59530 }
59531 unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH264RateControlInfoEXTBuilder<'_> {}
59532 unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH264RateControlInfoEXT {}
59533 impl<'a> ::std::ops::Deref for VideoEncodeH264RateControlInfoEXTBuilder<'a> {
59534     type Target = VideoEncodeH264RateControlInfoEXT;
deref(&self) -> &Self::Target59535     fn deref(&self) -> &Self::Target {
59536         &self.inner
59537     }
59538 }
59539 impl<'a> ::std::ops::DerefMut for VideoEncodeH264RateControlInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target59540     fn deref_mut(&mut self) -> &mut Self::Target {
59541         &mut self.inner
59542     }
59543 }
59544 impl<'a> VideoEncodeH264RateControlInfoEXTBuilder<'a> {
59545     #[inline]
gop_frame_count(mut self, gop_frame_count: u32) -> Self59546     pub fn gop_frame_count(mut self, gop_frame_count: u32) -> Self {
59547         self.inner.gop_frame_count = gop_frame_count;
59548         self
59549     }
59550     #[inline]
idr_period(mut self, idr_period: u32) -> Self59551     pub fn idr_period(mut self, idr_period: u32) -> Self {
59552         self.inner.idr_period = idr_period;
59553         self
59554     }
59555     #[inline]
consecutive_b_frame_count(mut self, consecutive_b_frame_count: u32) -> Self59556     pub fn consecutive_b_frame_count(mut self, consecutive_b_frame_count: u32) -> Self {
59557         self.inner.consecutive_b_frame_count = consecutive_b_frame_count;
59558         self
59559     }
59560     #[inline]
rate_control_structure( mut self, rate_control_structure: VideoEncodeH264RateControlStructureEXT, ) -> Self59561     pub fn rate_control_structure(
59562         mut self,
59563         rate_control_structure: VideoEncodeH264RateControlStructureEXT,
59564     ) -> Self {
59565         self.inner.rate_control_structure = rate_control_structure;
59566         self
59567     }
59568     #[inline]
temporal_layer_count(mut self, temporal_layer_count: u32) -> Self59569     pub fn temporal_layer_count(mut self, temporal_layer_count: u32) -> Self {
59570         self.inner.temporal_layer_count = temporal_layer_count;
59571         self
59572     }
59573     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
59574     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
59575     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoEncodeH264RateControlInfoEXT59576     pub fn build(self) -> VideoEncodeH264RateControlInfoEXT {
59577         self.inner
59578     }
59579 }
59580 #[repr(C)]
59581 #[cfg_attr(feature = "debug", derive(Debug))]
59582 #[derive(Copy, Clone, Default)]
59583 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264QpEXT.html>"]
59584 pub struct VideoEncodeH264QpEXT {
59585     pub qp_i: i32,
59586     pub qp_p: i32,
59587     pub qp_b: i32,
59588 }
59589 impl VideoEncodeH264QpEXT {
builder<'a>() -> VideoEncodeH264QpEXTBuilder<'a>59590     pub fn builder<'a>() -> VideoEncodeH264QpEXTBuilder<'a> {
59591         VideoEncodeH264QpEXTBuilder {
59592             inner: Self::default(),
59593             marker: ::std::marker::PhantomData,
59594         }
59595     }
59596 }
59597 #[repr(transparent)]
59598 pub struct VideoEncodeH264QpEXTBuilder<'a> {
59599     inner: VideoEncodeH264QpEXT,
59600     marker: ::std::marker::PhantomData<&'a ()>,
59601 }
59602 impl<'a> ::std::ops::Deref for VideoEncodeH264QpEXTBuilder<'a> {
59603     type Target = VideoEncodeH264QpEXT;
deref(&self) -> &Self::Target59604     fn deref(&self) -> &Self::Target {
59605         &self.inner
59606     }
59607 }
59608 impl<'a> ::std::ops::DerefMut for VideoEncodeH264QpEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target59609     fn deref_mut(&mut self) -> &mut Self::Target {
59610         &mut self.inner
59611     }
59612 }
59613 impl<'a> VideoEncodeH264QpEXTBuilder<'a> {
59614     #[inline]
qp_i(mut self, qp_i: i32) -> Self59615     pub fn qp_i(mut self, qp_i: i32) -> Self {
59616         self.inner.qp_i = qp_i;
59617         self
59618     }
59619     #[inline]
qp_p(mut self, qp_p: i32) -> Self59620     pub fn qp_p(mut self, qp_p: i32) -> Self {
59621         self.inner.qp_p = qp_p;
59622         self
59623     }
59624     #[inline]
qp_b(mut self, qp_b: i32) -> Self59625     pub fn qp_b(mut self, qp_b: i32) -> Self {
59626         self.inner.qp_b = qp_b;
59627         self
59628     }
59629     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
59630     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
59631     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoEncodeH264QpEXT59632     pub fn build(self) -> VideoEncodeH264QpEXT {
59633         self.inner
59634     }
59635 }
59636 #[repr(C)]
59637 #[cfg_attr(feature = "debug", derive(Debug))]
59638 #[derive(Copy, Clone, Default)]
59639 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264FrameSizeEXT.html>"]
59640 pub struct VideoEncodeH264FrameSizeEXT {
59641     pub frame_i_size: u32,
59642     pub frame_p_size: u32,
59643     pub frame_b_size: u32,
59644 }
59645 impl VideoEncodeH264FrameSizeEXT {
builder<'a>() -> VideoEncodeH264FrameSizeEXTBuilder<'a>59646     pub fn builder<'a>() -> VideoEncodeH264FrameSizeEXTBuilder<'a> {
59647         VideoEncodeH264FrameSizeEXTBuilder {
59648             inner: Self::default(),
59649             marker: ::std::marker::PhantomData,
59650         }
59651     }
59652 }
59653 #[repr(transparent)]
59654 pub struct VideoEncodeH264FrameSizeEXTBuilder<'a> {
59655     inner: VideoEncodeH264FrameSizeEXT,
59656     marker: ::std::marker::PhantomData<&'a ()>,
59657 }
59658 impl<'a> ::std::ops::Deref for VideoEncodeH264FrameSizeEXTBuilder<'a> {
59659     type Target = VideoEncodeH264FrameSizeEXT;
deref(&self) -> &Self::Target59660     fn deref(&self) -> &Self::Target {
59661         &self.inner
59662     }
59663 }
59664 impl<'a> ::std::ops::DerefMut for VideoEncodeH264FrameSizeEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target59665     fn deref_mut(&mut self) -> &mut Self::Target {
59666         &mut self.inner
59667     }
59668 }
59669 impl<'a> VideoEncodeH264FrameSizeEXTBuilder<'a> {
59670     #[inline]
frame_i_size(mut self, frame_i_size: u32) -> Self59671     pub fn frame_i_size(mut self, frame_i_size: u32) -> Self {
59672         self.inner.frame_i_size = frame_i_size;
59673         self
59674     }
59675     #[inline]
frame_p_size(mut self, frame_p_size: u32) -> Self59676     pub fn frame_p_size(mut self, frame_p_size: u32) -> Self {
59677         self.inner.frame_p_size = frame_p_size;
59678         self
59679     }
59680     #[inline]
frame_b_size(mut self, frame_b_size: u32) -> Self59681     pub fn frame_b_size(mut self, frame_b_size: u32) -> Self {
59682         self.inner.frame_b_size = frame_b_size;
59683         self
59684     }
59685     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
59686     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
59687     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoEncodeH264FrameSizeEXT59688     pub fn build(self) -> VideoEncodeH264FrameSizeEXT {
59689         self.inner
59690     }
59691 }
59692 #[repr(C)]
59693 #[cfg_attr(feature = "debug", derive(Debug))]
59694 #[derive(Copy, Clone)]
59695 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264RateControlLayerInfoEXT.html>"]
59696 pub struct VideoEncodeH264RateControlLayerInfoEXT {
59697     pub s_type: StructureType,
59698     pub p_next: *const c_void,
59699     pub temporal_layer_id: u32,
59700     pub use_initial_rc_qp: Bool32,
59701     pub initial_rc_qp: VideoEncodeH264QpEXT,
59702     pub use_min_qp: Bool32,
59703     pub min_qp: VideoEncodeH264QpEXT,
59704     pub use_max_qp: Bool32,
59705     pub max_qp: VideoEncodeH264QpEXT,
59706     pub use_max_frame_size: Bool32,
59707     pub max_frame_size: VideoEncodeH264FrameSizeEXT,
59708 }
59709 impl ::std::default::Default for VideoEncodeH264RateControlLayerInfoEXT {
59710     #[inline]
default() -> Self59711     fn default() -> Self {
59712         Self {
59713             s_type: Self::STRUCTURE_TYPE,
59714             p_next: ::std::ptr::null(),
59715             temporal_layer_id: u32::default(),
59716             use_initial_rc_qp: Bool32::default(),
59717             initial_rc_qp: VideoEncodeH264QpEXT::default(),
59718             use_min_qp: Bool32::default(),
59719             min_qp: VideoEncodeH264QpEXT::default(),
59720             use_max_qp: Bool32::default(),
59721             max_qp: VideoEncodeH264QpEXT::default(),
59722             use_max_frame_size: Bool32::default(),
59723             max_frame_size: VideoEncodeH264FrameSizeEXT::default(),
59724         }
59725     }
59726 }
59727 unsafe impl TaggedStructure for VideoEncodeH264RateControlLayerInfoEXT {
59728     const STRUCTURE_TYPE: StructureType =
59729         StructureType::VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT;
59730 }
59731 impl VideoEncodeH264RateControlLayerInfoEXT {
builder<'a>() -> VideoEncodeH264RateControlLayerInfoEXTBuilder<'a>59732     pub fn builder<'a>() -> VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> {
59733         VideoEncodeH264RateControlLayerInfoEXTBuilder {
59734             inner: Self::default(),
59735             marker: ::std::marker::PhantomData,
59736         }
59737     }
59738 }
59739 #[repr(transparent)]
59740 pub struct VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> {
59741     inner: VideoEncodeH264RateControlLayerInfoEXT,
59742     marker: ::std::marker::PhantomData<&'a ()>,
59743 }
59744 unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH264RateControlLayerInfoEXTBuilder<'_> {}
59745 unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH264RateControlLayerInfoEXT {}
59746 unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR
59747     for VideoEncodeH264RateControlLayerInfoEXTBuilder<'_>
59748 {
59749 }
59750 unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR for VideoEncodeH264RateControlLayerInfoEXT {}
59751 impl<'a> ::std::ops::Deref for VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> {
59752     type Target = VideoEncodeH264RateControlLayerInfoEXT;
deref(&self) -> &Self::Target59753     fn deref(&self) -> &Self::Target {
59754         &self.inner
59755     }
59756 }
59757 impl<'a> ::std::ops::DerefMut for VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target59758     fn deref_mut(&mut self) -> &mut Self::Target {
59759         &mut self.inner
59760     }
59761 }
59762 impl<'a> VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> {
59763     #[inline]
temporal_layer_id(mut self, temporal_layer_id: u32) -> Self59764     pub fn temporal_layer_id(mut self, temporal_layer_id: u32) -> Self {
59765         self.inner.temporal_layer_id = temporal_layer_id;
59766         self
59767     }
59768     #[inline]
use_initial_rc_qp(mut self, use_initial_rc_qp: bool) -> Self59769     pub fn use_initial_rc_qp(mut self, use_initial_rc_qp: bool) -> Self {
59770         self.inner.use_initial_rc_qp = use_initial_rc_qp.into();
59771         self
59772     }
59773     #[inline]
initial_rc_qp(mut self, initial_rc_qp: VideoEncodeH264QpEXT) -> Self59774     pub fn initial_rc_qp(mut self, initial_rc_qp: VideoEncodeH264QpEXT) -> Self {
59775         self.inner.initial_rc_qp = initial_rc_qp;
59776         self
59777     }
59778     #[inline]
use_min_qp(mut self, use_min_qp: bool) -> Self59779     pub fn use_min_qp(mut self, use_min_qp: bool) -> Self {
59780         self.inner.use_min_qp = use_min_qp.into();
59781         self
59782     }
59783     #[inline]
min_qp(mut self, min_qp: VideoEncodeH264QpEXT) -> Self59784     pub fn min_qp(mut self, min_qp: VideoEncodeH264QpEXT) -> Self {
59785         self.inner.min_qp = min_qp;
59786         self
59787     }
59788     #[inline]
use_max_qp(mut self, use_max_qp: bool) -> Self59789     pub fn use_max_qp(mut self, use_max_qp: bool) -> Self {
59790         self.inner.use_max_qp = use_max_qp.into();
59791         self
59792     }
59793     #[inline]
max_qp(mut self, max_qp: VideoEncodeH264QpEXT) -> Self59794     pub fn max_qp(mut self, max_qp: VideoEncodeH264QpEXT) -> Self {
59795         self.inner.max_qp = max_qp;
59796         self
59797     }
59798     #[inline]
use_max_frame_size(mut self, use_max_frame_size: bool) -> Self59799     pub fn use_max_frame_size(mut self, use_max_frame_size: bool) -> Self {
59800         self.inner.use_max_frame_size = use_max_frame_size.into();
59801         self
59802     }
59803     #[inline]
max_frame_size(mut self, max_frame_size: VideoEncodeH264FrameSizeEXT) -> Self59804     pub fn max_frame_size(mut self, max_frame_size: VideoEncodeH264FrameSizeEXT) -> Self {
59805         self.inner.max_frame_size = max_frame_size;
59806         self
59807     }
59808     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
59809     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
59810     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoEncodeH264RateControlLayerInfoEXT59811     pub fn build(self) -> VideoEncodeH264RateControlLayerInfoEXT {
59812         self.inner
59813     }
59814 }
59815 #[repr(C)]
59816 #[cfg_attr(feature = "debug", derive(Debug))]
59817 #[derive(Copy, Clone)]
59818 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265CapabilitiesEXT.html>"]
59819 pub struct VideoEncodeH265CapabilitiesEXT {
59820     pub s_type: StructureType,
59821     pub p_next: *mut c_void,
59822     pub flags: VideoEncodeH265CapabilityFlagsEXT,
59823     pub ctb_sizes: VideoEncodeH265CtbSizeFlagsEXT,
59824     pub transform_block_sizes: VideoEncodeH265TransformBlockSizeFlagsEXT,
59825     pub max_p_picture_l0_reference_count: u32,
59826     pub max_b_picture_l0_reference_count: u32,
59827     pub max_l1_reference_count: u32,
59828     pub max_sub_layers_count: u32,
59829     pub min_log2_min_luma_coding_block_size_minus3: u32,
59830     pub max_log2_min_luma_coding_block_size_minus3: u32,
59831     pub min_log2_min_luma_transform_block_size_minus2: u32,
59832     pub max_log2_min_luma_transform_block_size_minus2: u32,
59833     pub min_max_transform_hierarchy_depth_inter: u32,
59834     pub max_max_transform_hierarchy_depth_inter: u32,
59835     pub min_max_transform_hierarchy_depth_intra: u32,
59836     pub max_max_transform_hierarchy_depth_intra: u32,
59837     pub max_diff_cu_qp_delta_depth: u32,
59838     pub min_max_num_merge_cand: u32,
59839     pub max_max_num_merge_cand: u32,
59840 }
59841 impl ::std::default::Default for VideoEncodeH265CapabilitiesEXT {
59842     #[inline]
default() -> Self59843     fn default() -> Self {
59844         Self {
59845             s_type: Self::STRUCTURE_TYPE,
59846             p_next: ::std::ptr::null_mut(),
59847             flags: VideoEncodeH265CapabilityFlagsEXT::default(),
59848             ctb_sizes: VideoEncodeH265CtbSizeFlagsEXT::default(),
59849             transform_block_sizes: VideoEncodeH265TransformBlockSizeFlagsEXT::default(),
59850             max_p_picture_l0_reference_count: u32::default(),
59851             max_b_picture_l0_reference_count: u32::default(),
59852             max_l1_reference_count: u32::default(),
59853             max_sub_layers_count: u32::default(),
59854             min_log2_min_luma_coding_block_size_minus3: u32::default(),
59855             max_log2_min_luma_coding_block_size_minus3: u32::default(),
59856             min_log2_min_luma_transform_block_size_minus2: u32::default(),
59857             max_log2_min_luma_transform_block_size_minus2: u32::default(),
59858             min_max_transform_hierarchy_depth_inter: u32::default(),
59859             max_max_transform_hierarchy_depth_inter: u32::default(),
59860             min_max_transform_hierarchy_depth_intra: u32::default(),
59861             max_max_transform_hierarchy_depth_intra: u32::default(),
59862             max_diff_cu_qp_delta_depth: u32::default(),
59863             min_max_num_merge_cand: u32::default(),
59864             max_max_num_merge_cand: u32::default(),
59865         }
59866     }
59867 }
59868 unsafe impl TaggedStructure for VideoEncodeH265CapabilitiesEXT {
59869     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_CAPABILITIES_EXT;
59870 }
59871 impl VideoEncodeH265CapabilitiesEXT {
builder<'a>() -> VideoEncodeH265CapabilitiesEXTBuilder<'a>59872     pub fn builder<'a>() -> VideoEncodeH265CapabilitiesEXTBuilder<'a> {
59873         VideoEncodeH265CapabilitiesEXTBuilder {
59874             inner: Self::default(),
59875             marker: ::std::marker::PhantomData,
59876         }
59877     }
59878 }
59879 #[repr(transparent)]
59880 pub struct VideoEncodeH265CapabilitiesEXTBuilder<'a> {
59881     inner: VideoEncodeH265CapabilitiesEXT,
59882     marker: ::std::marker::PhantomData<&'a ()>,
59883 }
59884 unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeH265CapabilitiesEXTBuilder<'_> {}
59885 unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeH265CapabilitiesEXT {}
59886 impl<'a> ::std::ops::Deref for VideoEncodeH265CapabilitiesEXTBuilder<'a> {
59887     type Target = VideoEncodeH265CapabilitiesEXT;
deref(&self) -> &Self::Target59888     fn deref(&self) -> &Self::Target {
59889         &self.inner
59890     }
59891 }
59892 impl<'a> ::std::ops::DerefMut for VideoEncodeH265CapabilitiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target59893     fn deref_mut(&mut self) -> &mut Self::Target {
59894         &mut self.inner
59895     }
59896 }
59897 impl<'a> VideoEncodeH265CapabilitiesEXTBuilder<'a> {
59898     #[inline]
flags(mut self, flags: VideoEncodeH265CapabilityFlagsEXT) -> Self59899     pub fn flags(mut self, flags: VideoEncodeH265CapabilityFlagsEXT) -> Self {
59900         self.inner.flags = flags;
59901         self
59902     }
59903     #[inline]
ctb_sizes(mut self, ctb_sizes: VideoEncodeH265CtbSizeFlagsEXT) -> Self59904     pub fn ctb_sizes(mut self, ctb_sizes: VideoEncodeH265CtbSizeFlagsEXT) -> Self {
59905         self.inner.ctb_sizes = ctb_sizes;
59906         self
59907     }
59908     #[inline]
transform_block_sizes( mut self, transform_block_sizes: VideoEncodeH265TransformBlockSizeFlagsEXT, ) -> Self59909     pub fn transform_block_sizes(
59910         mut self,
59911         transform_block_sizes: VideoEncodeH265TransformBlockSizeFlagsEXT,
59912     ) -> Self {
59913         self.inner.transform_block_sizes = transform_block_sizes;
59914         self
59915     }
59916     #[inline]
max_p_picture_l0_reference_count( mut self, max_p_picture_l0_reference_count: u32, ) -> Self59917     pub fn max_p_picture_l0_reference_count(
59918         mut self,
59919         max_p_picture_l0_reference_count: u32,
59920     ) -> Self {
59921         self.inner.max_p_picture_l0_reference_count = max_p_picture_l0_reference_count;
59922         self
59923     }
59924     #[inline]
max_b_picture_l0_reference_count( mut self, max_b_picture_l0_reference_count: u32, ) -> Self59925     pub fn max_b_picture_l0_reference_count(
59926         mut self,
59927         max_b_picture_l0_reference_count: u32,
59928     ) -> Self {
59929         self.inner.max_b_picture_l0_reference_count = max_b_picture_l0_reference_count;
59930         self
59931     }
59932     #[inline]
max_l1_reference_count(mut self, max_l1_reference_count: u32) -> Self59933     pub fn max_l1_reference_count(mut self, max_l1_reference_count: u32) -> Self {
59934         self.inner.max_l1_reference_count = max_l1_reference_count;
59935         self
59936     }
59937     #[inline]
max_sub_layers_count(mut self, max_sub_layers_count: u32) -> Self59938     pub fn max_sub_layers_count(mut self, max_sub_layers_count: u32) -> Self {
59939         self.inner.max_sub_layers_count = max_sub_layers_count;
59940         self
59941     }
59942     #[inline]
min_log2_min_luma_coding_block_size_minus3( mut self, min_log2_min_luma_coding_block_size_minus3: u32, ) -> Self59943     pub fn min_log2_min_luma_coding_block_size_minus3(
59944         mut self,
59945         min_log2_min_luma_coding_block_size_minus3: u32,
59946     ) -> Self {
59947         self.inner.min_log2_min_luma_coding_block_size_minus3 =
59948             min_log2_min_luma_coding_block_size_minus3;
59949         self
59950     }
59951     #[inline]
max_log2_min_luma_coding_block_size_minus3( mut self, max_log2_min_luma_coding_block_size_minus3: u32, ) -> Self59952     pub fn max_log2_min_luma_coding_block_size_minus3(
59953         mut self,
59954         max_log2_min_luma_coding_block_size_minus3: u32,
59955     ) -> Self {
59956         self.inner.max_log2_min_luma_coding_block_size_minus3 =
59957             max_log2_min_luma_coding_block_size_minus3;
59958         self
59959     }
59960     #[inline]
min_log2_min_luma_transform_block_size_minus2( mut self, min_log2_min_luma_transform_block_size_minus2: u32, ) -> Self59961     pub fn min_log2_min_luma_transform_block_size_minus2(
59962         mut self,
59963         min_log2_min_luma_transform_block_size_minus2: u32,
59964     ) -> Self {
59965         self.inner.min_log2_min_luma_transform_block_size_minus2 =
59966             min_log2_min_luma_transform_block_size_minus2;
59967         self
59968     }
59969     #[inline]
max_log2_min_luma_transform_block_size_minus2( mut self, max_log2_min_luma_transform_block_size_minus2: u32, ) -> Self59970     pub fn max_log2_min_luma_transform_block_size_minus2(
59971         mut self,
59972         max_log2_min_luma_transform_block_size_minus2: u32,
59973     ) -> Self {
59974         self.inner.max_log2_min_luma_transform_block_size_minus2 =
59975             max_log2_min_luma_transform_block_size_minus2;
59976         self
59977     }
59978     #[inline]
min_max_transform_hierarchy_depth_inter( mut self, min_max_transform_hierarchy_depth_inter: u32, ) -> Self59979     pub fn min_max_transform_hierarchy_depth_inter(
59980         mut self,
59981         min_max_transform_hierarchy_depth_inter: u32,
59982     ) -> Self {
59983         self.inner.min_max_transform_hierarchy_depth_inter =
59984             min_max_transform_hierarchy_depth_inter;
59985         self
59986     }
59987     #[inline]
max_max_transform_hierarchy_depth_inter( mut self, max_max_transform_hierarchy_depth_inter: u32, ) -> Self59988     pub fn max_max_transform_hierarchy_depth_inter(
59989         mut self,
59990         max_max_transform_hierarchy_depth_inter: u32,
59991     ) -> Self {
59992         self.inner.max_max_transform_hierarchy_depth_inter =
59993             max_max_transform_hierarchy_depth_inter;
59994         self
59995     }
59996     #[inline]
min_max_transform_hierarchy_depth_intra( mut self, min_max_transform_hierarchy_depth_intra: u32, ) -> Self59997     pub fn min_max_transform_hierarchy_depth_intra(
59998         mut self,
59999         min_max_transform_hierarchy_depth_intra: u32,
60000     ) -> Self {
60001         self.inner.min_max_transform_hierarchy_depth_intra =
60002             min_max_transform_hierarchy_depth_intra;
60003         self
60004     }
60005     #[inline]
max_max_transform_hierarchy_depth_intra( mut self, max_max_transform_hierarchy_depth_intra: u32, ) -> Self60006     pub fn max_max_transform_hierarchy_depth_intra(
60007         mut self,
60008         max_max_transform_hierarchy_depth_intra: u32,
60009     ) -> Self {
60010         self.inner.max_max_transform_hierarchy_depth_intra =
60011             max_max_transform_hierarchy_depth_intra;
60012         self
60013     }
60014     #[inline]
max_diff_cu_qp_delta_depth(mut self, max_diff_cu_qp_delta_depth: u32) -> Self60015     pub fn max_diff_cu_qp_delta_depth(mut self, max_diff_cu_qp_delta_depth: u32) -> Self {
60016         self.inner.max_diff_cu_qp_delta_depth = max_diff_cu_qp_delta_depth;
60017         self
60018     }
60019     #[inline]
min_max_num_merge_cand(mut self, min_max_num_merge_cand: u32) -> Self60020     pub fn min_max_num_merge_cand(mut self, min_max_num_merge_cand: u32) -> Self {
60021         self.inner.min_max_num_merge_cand = min_max_num_merge_cand;
60022         self
60023     }
60024     #[inline]
max_max_num_merge_cand(mut self, max_max_num_merge_cand: u32) -> Self60025     pub fn max_max_num_merge_cand(mut self, max_max_num_merge_cand: u32) -> Self {
60026         self.inner.max_max_num_merge_cand = max_max_num_merge_cand;
60027         self
60028     }
60029     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
60030     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
60031     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoEncodeH265CapabilitiesEXT60032     pub fn build(self) -> VideoEncodeH265CapabilitiesEXT {
60033         self.inner
60034     }
60035 }
60036 #[repr(C)]
60037 #[cfg_attr(feature = "debug", derive(Debug))]
60038 #[derive(Copy, Clone)]
60039 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265SessionParametersAddInfoEXT.html>"]
60040 pub struct VideoEncodeH265SessionParametersAddInfoEXT {
60041     pub s_type: StructureType,
60042     pub p_next: *const c_void,
60043     pub std_vps_count: u32,
60044     pub p_std_vp_ss: *const StdVideoH265VideoParameterSet,
60045     pub std_sps_count: u32,
60046     pub p_std_sp_ss: *const StdVideoH265SequenceParameterSet,
60047     pub std_pps_count: u32,
60048     pub p_std_pp_ss: *const StdVideoH265PictureParameterSet,
60049 }
60050 impl ::std::default::Default for VideoEncodeH265SessionParametersAddInfoEXT {
60051     #[inline]
default() -> Self60052     fn default() -> Self {
60053         Self {
60054             s_type: Self::STRUCTURE_TYPE,
60055             p_next: ::std::ptr::null(),
60056             std_vps_count: u32::default(),
60057             p_std_vp_ss: ::std::ptr::null(),
60058             std_sps_count: u32::default(),
60059             p_std_sp_ss: ::std::ptr::null(),
60060             std_pps_count: u32::default(),
60061             p_std_pp_ss: ::std::ptr::null(),
60062         }
60063     }
60064 }
60065 unsafe impl TaggedStructure for VideoEncodeH265SessionParametersAddInfoEXT {
60066     const STRUCTURE_TYPE: StructureType =
60067         StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT;
60068 }
60069 impl VideoEncodeH265SessionParametersAddInfoEXT {
builder<'a>() -> VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a>60070     pub fn builder<'a>() -> VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> {
60071         VideoEncodeH265SessionParametersAddInfoEXTBuilder {
60072             inner: Self::default(),
60073             marker: ::std::marker::PhantomData,
60074         }
60075     }
60076 }
60077 #[repr(transparent)]
60078 pub struct VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> {
60079     inner: VideoEncodeH265SessionParametersAddInfoEXT,
60080     marker: ::std::marker::PhantomData<&'a ()>,
60081 }
60082 unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
60083     for VideoEncodeH265SessionParametersAddInfoEXTBuilder<'_>
60084 {
60085 }
60086 unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
60087     for VideoEncodeH265SessionParametersAddInfoEXT
60088 {
60089 }
60090 impl<'a> ::std::ops::Deref for VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> {
60091     type Target = VideoEncodeH265SessionParametersAddInfoEXT;
deref(&self) -> &Self::Target60092     fn deref(&self) -> &Self::Target {
60093         &self.inner
60094     }
60095 }
60096 impl<'a> ::std::ops::DerefMut for VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target60097     fn deref_mut(&mut self) -> &mut Self::Target {
60098         &mut self.inner
60099     }
60100 }
60101 impl<'a> VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> {
60102     #[inline]
std_vp_ss(mut self, std_vp_ss: &'a [StdVideoH265VideoParameterSet]) -> Self60103     pub fn std_vp_ss(mut self, std_vp_ss: &'a [StdVideoH265VideoParameterSet]) -> Self {
60104         self.inner.std_vps_count = std_vp_ss.len() as _;
60105         self.inner.p_std_vp_ss = std_vp_ss.as_ptr();
60106         self
60107     }
60108     #[inline]
std_sp_ss(mut self, std_sp_ss: &'a [StdVideoH265SequenceParameterSet]) -> Self60109     pub fn std_sp_ss(mut self, std_sp_ss: &'a [StdVideoH265SequenceParameterSet]) -> Self {
60110         self.inner.std_sps_count = std_sp_ss.len() as _;
60111         self.inner.p_std_sp_ss = std_sp_ss.as_ptr();
60112         self
60113     }
60114     #[inline]
std_pp_ss(mut self, std_pp_ss: &'a [StdVideoH265PictureParameterSet]) -> Self60115     pub fn std_pp_ss(mut self, std_pp_ss: &'a [StdVideoH265PictureParameterSet]) -> Self {
60116         self.inner.std_pps_count = std_pp_ss.len() as _;
60117         self.inner.p_std_pp_ss = std_pp_ss.as_ptr();
60118         self
60119     }
60120     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
60121     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
60122     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoEncodeH265SessionParametersAddInfoEXT60123     pub fn build(self) -> VideoEncodeH265SessionParametersAddInfoEXT {
60124         self.inner
60125     }
60126 }
60127 #[repr(C)]
60128 #[cfg_attr(feature = "debug", derive(Debug))]
60129 #[derive(Copy, Clone)]
60130 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265SessionParametersCreateInfoEXT.html>"]
60131 pub struct VideoEncodeH265SessionParametersCreateInfoEXT {
60132     pub s_type: StructureType,
60133     pub p_next: *const c_void,
60134     pub max_std_vps_count: u32,
60135     pub max_std_sps_count: u32,
60136     pub max_std_pps_count: u32,
60137     pub p_parameters_add_info: *const VideoEncodeH265SessionParametersAddInfoEXT,
60138 }
60139 impl ::std::default::Default for VideoEncodeH265SessionParametersCreateInfoEXT {
60140     #[inline]
default() -> Self60141     fn default() -> Self {
60142         Self {
60143             s_type: Self::STRUCTURE_TYPE,
60144             p_next: ::std::ptr::null(),
60145             max_std_vps_count: u32::default(),
60146             max_std_sps_count: u32::default(),
60147             max_std_pps_count: u32::default(),
60148             p_parameters_add_info: ::std::ptr::null(),
60149         }
60150     }
60151 }
60152 unsafe impl TaggedStructure for VideoEncodeH265SessionParametersCreateInfoEXT {
60153     const STRUCTURE_TYPE: StructureType =
60154         StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT;
60155 }
60156 impl VideoEncodeH265SessionParametersCreateInfoEXT {
builder<'a>() -> VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a>60157     pub fn builder<'a>() -> VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> {
60158         VideoEncodeH265SessionParametersCreateInfoEXTBuilder {
60159             inner: Self::default(),
60160             marker: ::std::marker::PhantomData,
60161         }
60162     }
60163 }
60164 #[repr(transparent)]
60165 pub struct VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> {
60166     inner: VideoEncodeH265SessionParametersCreateInfoEXT,
60167     marker: ::std::marker::PhantomData<&'a ()>,
60168 }
60169 unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
60170     for VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'_>
60171 {
60172 }
60173 unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
60174     for VideoEncodeH265SessionParametersCreateInfoEXT
60175 {
60176 }
60177 impl<'a> ::std::ops::Deref for VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> {
60178     type Target = VideoEncodeH265SessionParametersCreateInfoEXT;
deref(&self) -> &Self::Target60179     fn deref(&self) -> &Self::Target {
60180         &self.inner
60181     }
60182 }
60183 impl<'a> ::std::ops::DerefMut for VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target60184     fn deref_mut(&mut self) -> &mut Self::Target {
60185         &mut self.inner
60186     }
60187 }
60188 impl<'a> VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> {
60189     #[inline]
max_std_vps_count(mut self, max_std_vps_count: u32) -> Self60190     pub fn max_std_vps_count(mut self, max_std_vps_count: u32) -> Self {
60191         self.inner.max_std_vps_count = max_std_vps_count;
60192         self
60193     }
60194     #[inline]
max_std_sps_count(mut self, max_std_sps_count: u32) -> Self60195     pub fn max_std_sps_count(mut self, max_std_sps_count: u32) -> Self {
60196         self.inner.max_std_sps_count = max_std_sps_count;
60197         self
60198     }
60199     #[inline]
max_std_pps_count(mut self, max_std_pps_count: u32) -> Self60200     pub fn max_std_pps_count(mut self, max_std_pps_count: u32) -> Self {
60201         self.inner.max_std_pps_count = max_std_pps_count;
60202         self
60203     }
60204     #[inline]
parameters_add_info( mut self, parameters_add_info: &'a VideoEncodeH265SessionParametersAddInfoEXT, ) -> Self60205     pub fn parameters_add_info(
60206         mut self,
60207         parameters_add_info: &'a VideoEncodeH265SessionParametersAddInfoEXT,
60208     ) -> Self {
60209         self.inner.p_parameters_add_info = parameters_add_info;
60210         self
60211     }
60212     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
60213     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
60214     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoEncodeH265SessionParametersCreateInfoEXT60215     pub fn build(self) -> VideoEncodeH265SessionParametersCreateInfoEXT {
60216         self.inner
60217     }
60218 }
60219 #[repr(C)]
60220 #[cfg_attr(feature = "debug", derive(Debug))]
60221 #[derive(Copy, Clone)]
60222 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265VclFrameInfoEXT.html>"]
60223 pub struct VideoEncodeH265VclFrameInfoEXT {
60224     pub s_type: StructureType,
60225     pub p_next: *const c_void,
60226     pub p_std_reference_final_lists: *const StdVideoEncodeH265ReferenceListsInfo,
60227     pub nalu_slice_segment_entry_count: u32,
60228     pub p_nalu_slice_segment_entries: *const VideoEncodeH265NaluSliceSegmentInfoEXT,
60229     pub p_std_picture_info: *const StdVideoEncodeH265PictureInfo,
60230 }
60231 impl ::std::default::Default for VideoEncodeH265VclFrameInfoEXT {
60232     #[inline]
default() -> Self60233     fn default() -> Self {
60234         Self {
60235             s_type: Self::STRUCTURE_TYPE,
60236             p_next: ::std::ptr::null(),
60237             p_std_reference_final_lists: ::std::ptr::null(),
60238             nalu_slice_segment_entry_count: u32::default(),
60239             p_nalu_slice_segment_entries: ::std::ptr::null(),
60240             p_std_picture_info: ::std::ptr::null(),
60241         }
60242     }
60243 }
60244 unsafe impl TaggedStructure for VideoEncodeH265VclFrameInfoEXT {
60245     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT;
60246 }
60247 impl VideoEncodeH265VclFrameInfoEXT {
builder<'a>() -> VideoEncodeH265VclFrameInfoEXTBuilder<'a>60248     pub fn builder<'a>() -> VideoEncodeH265VclFrameInfoEXTBuilder<'a> {
60249         VideoEncodeH265VclFrameInfoEXTBuilder {
60250             inner: Self::default(),
60251             marker: ::std::marker::PhantomData,
60252         }
60253     }
60254 }
60255 #[repr(transparent)]
60256 pub struct VideoEncodeH265VclFrameInfoEXTBuilder<'a> {
60257     inner: VideoEncodeH265VclFrameInfoEXT,
60258     marker: ::std::marker::PhantomData<&'a ()>,
60259 }
60260 unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265VclFrameInfoEXTBuilder<'_> {}
60261 unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265VclFrameInfoEXT {}
60262 impl<'a> ::std::ops::Deref for VideoEncodeH265VclFrameInfoEXTBuilder<'a> {
60263     type Target = VideoEncodeH265VclFrameInfoEXT;
deref(&self) -> &Self::Target60264     fn deref(&self) -> &Self::Target {
60265         &self.inner
60266     }
60267 }
60268 impl<'a> ::std::ops::DerefMut for VideoEncodeH265VclFrameInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target60269     fn deref_mut(&mut self) -> &mut Self::Target {
60270         &mut self.inner
60271     }
60272 }
60273 impl<'a> VideoEncodeH265VclFrameInfoEXTBuilder<'a> {
60274     #[inline]
std_reference_final_lists( mut self, std_reference_final_lists: &'a StdVideoEncodeH265ReferenceListsInfo, ) -> Self60275     pub fn std_reference_final_lists(
60276         mut self,
60277         std_reference_final_lists: &'a StdVideoEncodeH265ReferenceListsInfo,
60278     ) -> Self {
60279         self.inner.p_std_reference_final_lists = std_reference_final_lists;
60280         self
60281     }
60282     #[inline]
nalu_slice_segment_entries( mut self, nalu_slice_segment_entries: &'a [VideoEncodeH265NaluSliceSegmentInfoEXT], ) -> Self60283     pub fn nalu_slice_segment_entries(
60284         mut self,
60285         nalu_slice_segment_entries: &'a [VideoEncodeH265NaluSliceSegmentInfoEXT],
60286     ) -> Self {
60287         self.inner.nalu_slice_segment_entry_count = nalu_slice_segment_entries.len() as _;
60288         self.inner.p_nalu_slice_segment_entries = nalu_slice_segment_entries.as_ptr();
60289         self
60290     }
60291     #[inline]
std_picture_info(mut self, std_picture_info: &'a StdVideoEncodeH265PictureInfo) -> Self60292     pub fn std_picture_info(mut self, std_picture_info: &'a StdVideoEncodeH265PictureInfo) -> Self {
60293         self.inner.p_std_picture_info = std_picture_info;
60294         self
60295     }
60296     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
60297     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
60298     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoEncodeH265VclFrameInfoEXT60299     pub fn build(self) -> VideoEncodeH265VclFrameInfoEXT {
60300         self.inner
60301     }
60302 }
60303 #[repr(C)]
60304 #[cfg_attr(feature = "debug", derive(Debug))]
60305 #[derive(Copy, Clone)]
60306 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265NaluSliceSegmentInfoEXT.html>"]
60307 pub struct VideoEncodeH265NaluSliceSegmentInfoEXT {
60308     pub s_type: StructureType,
60309     pub p_next: *const c_void,
60310     pub ctb_count: u32,
60311     pub p_std_reference_final_lists: *const StdVideoEncodeH265ReferenceListsInfo,
60312     pub p_std_slice_segment_header: *const StdVideoEncodeH265SliceSegmentHeader,
60313 }
60314 impl ::std::default::Default for VideoEncodeH265NaluSliceSegmentInfoEXT {
60315     #[inline]
default() -> Self60316     fn default() -> Self {
60317         Self {
60318             s_type: Self::STRUCTURE_TYPE,
60319             p_next: ::std::ptr::null(),
60320             ctb_count: u32::default(),
60321             p_std_reference_final_lists: ::std::ptr::null(),
60322             p_std_slice_segment_header: ::std::ptr::null(),
60323         }
60324     }
60325 }
60326 unsafe impl TaggedStructure for VideoEncodeH265NaluSliceSegmentInfoEXT {
60327     const STRUCTURE_TYPE: StructureType =
60328         StructureType::VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT;
60329 }
60330 impl VideoEncodeH265NaluSliceSegmentInfoEXT {
builder<'a>() -> VideoEncodeH265NaluSliceSegmentInfoEXTBuilder<'a>60331     pub fn builder<'a>() -> VideoEncodeH265NaluSliceSegmentInfoEXTBuilder<'a> {
60332         VideoEncodeH265NaluSliceSegmentInfoEXTBuilder {
60333             inner: Self::default(),
60334             marker: ::std::marker::PhantomData,
60335         }
60336     }
60337 }
60338 #[repr(transparent)]
60339 pub struct VideoEncodeH265NaluSliceSegmentInfoEXTBuilder<'a> {
60340     inner: VideoEncodeH265NaluSliceSegmentInfoEXT,
60341     marker: ::std::marker::PhantomData<&'a ()>,
60342 }
60343 impl<'a> ::std::ops::Deref for VideoEncodeH265NaluSliceSegmentInfoEXTBuilder<'a> {
60344     type Target = VideoEncodeH265NaluSliceSegmentInfoEXT;
deref(&self) -> &Self::Target60345     fn deref(&self) -> &Self::Target {
60346         &self.inner
60347     }
60348 }
60349 impl<'a> ::std::ops::DerefMut for VideoEncodeH265NaluSliceSegmentInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target60350     fn deref_mut(&mut self) -> &mut Self::Target {
60351         &mut self.inner
60352     }
60353 }
60354 impl<'a> VideoEncodeH265NaluSliceSegmentInfoEXTBuilder<'a> {
60355     #[inline]
ctb_count(mut self, ctb_count: u32) -> Self60356     pub fn ctb_count(mut self, ctb_count: u32) -> Self {
60357         self.inner.ctb_count = ctb_count;
60358         self
60359     }
60360     #[inline]
std_reference_final_lists( mut self, std_reference_final_lists: &'a StdVideoEncodeH265ReferenceListsInfo, ) -> Self60361     pub fn std_reference_final_lists(
60362         mut self,
60363         std_reference_final_lists: &'a StdVideoEncodeH265ReferenceListsInfo,
60364     ) -> Self {
60365         self.inner.p_std_reference_final_lists = std_reference_final_lists;
60366         self
60367     }
60368     #[inline]
std_slice_segment_header( mut self, std_slice_segment_header: &'a StdVideoEncodeH265SliceSegmentHeader, ) -> Self60369     pub fn std_slice_segment_header(
60370         mut self,
60371         std_slice_segment_header: &'a StdVideoEncodeH265SliceSegmentHeader,
60372     ) -> Self {
60373         self.inner.p_std_slice_segment_header = std_slice_segment_header;
60374         self
60375     }
60376     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
60377     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
60378     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoEncodeH265NaluSliceSegmentInfoEXT60379     pub fn build(self) -> VideoEncodeH265NaluSliceSegmentInfoEXT {
60380         self.inner
60381     }
60382 }
60383 #[repr(C)]
60384 #[cfg_attr(feature = "debug", derive(Debug))]
60385 #[derive(Copy, Clone)]
60386 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265RateControlInfoEXT.html>"]
60387 pub struct VideoEncodeH265RateControlInfoEXT {
60388     pub s_type: StructureType,
60389     pub p_next: *const c_void,
60390     pub gop_frame_count: u32,
60391     pub idr_period: u32,
60392     pub consecutive_b_frame_count: u32,
60393     pub rate_control_structure: VideoEncodeH265RateControlStructureEXT,
60394     pub sub_layer_count: u32,
60395 }
60396 impl ::std::default::Default for VideoEncodeH265RateControlInfoEXT {
60397     #[inline]
default() -> Self60398     fn default() -> Self {
60399         Self {
60400             s_type: Self::STRUCTURE_TYPE,
60401             p_next: ::std::ptr::null(),
60402             gop_frame_count: u32::default(),
60403             idr_period: u32::default(),
60404             consecutive_b_frame_count: u32::default(),
60405             rate_control_structure: VideoEncodeH265RateControlStructureEXT::default(),
60406             sub_layer_count: u32::default(),
60407         }
60408     }
60409 }
60410 unsafe impl TaggedStructure for VideoEncodeH265RateControlInfoEXT {
60411     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT;
60412 }
60413 impl VideoEncodeH265RateControlInfoEXT {
builder<'a>() -> VideoEncodeH265RateControlInfoEXTBuilder<'a>60414     pub fn builder<'a>() -> VideoEncodeH265RateControlInfoEXTBuilder<'a> {
60415         VideoEncodeH265RateControlInfoEXTBuilder {
60416             inner: Self::default(),
60417             marker: ::std::marker::PhantomData,
60418         }
60419     }
60420 }
60421 #[repr(transparent)]
60422 pub struct VideoEncodeH265RateControlInfoEXTBuilder<'a> {
60423     inner: VideoEncodeH265RateControlInfoEXT,
60424     marker: ::std::marker::PhantomData<&'a ()>,
60425 }
60426 unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH265RateControlInfoEXTBuilder<'_> {}
60427 unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH265RateControlInfoEXT {}
60428 impl<'a> ::std::ops::Deref for VideoEncodeH265RateControlInfoEXTBuilder<'a> {
60429     type Target = VideoEncodeH265RateControlInfoEXT;
deref(&self) -> &Self::Target60430     fn deref(&self) -> &Self::Target {
60431         &self.inner
60432     }
60433 }
60434 impl<'a> ::std::ops::DerefMut for VideoEncodeH265RateControlInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target60435     fn deref_mut(&mut self) -> &mut Self::Target {
60436         &mut self.inner
60437     }
60438 }
60439 impl<'a> VideoEncodeH265RateControlInfoEXTBuilder<'a> {
60440     #[inline]
gop_frame_count(mut self, gop_frame_count: u32) -> Self60441     pub fn gop_frame_count(mut self, gop_frame_count: u32) -> Self {
60442         self.inner.gop_frame_count = gop_frame_count;
60443         self
60444     }
60445     #[inline]
idr_period(mut self, idr_period: u32) -> Self60446     pub fn idr_period(mut self, idr_period: u32) -> Self {
60447         self.inner.idr_period = idr_period;
60448         self
60449     }
60450     #[inline]
consecutive_b_frame_count(mut self, consecutive_b_frame_count: u32) -> Self60451     pub fn consecutive_b_frame_count(mut self, consecutive_b_frame_count: u32) -> Self {
60452         self.inner.consecutive_b_frame_count = consecutive_b_frame_count;
60453         self
60454     }
60455     #[inline]
rate_control_structure( mut self, rate_control_structure: VideoEncodeH265RateControlStructureEXT, ) -> Self60456     pub fn rate_control_structure(
60457         mut self,
60458         rate_control_structure: VideoEncodeH265RateControlStructureEXT,
60459     ) -> Self {
60460         self.inner.rate_control_structure = rate_control_structure;
60461         self
60462     }
60463     #[inline]
sub_layer_count(mut self, sub_layer_count: u32) -> Self60464     pub fn sub_layer_count(mut self, sub_layer_count: u32) -> Self {
60465         self.inner.sub_layer_count = sub_layer_count;
60466         self
60467     }
60468     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
60469     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
60470     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoEncodeH265RateControlInfoEXT60471     pub fn build(self) -> VideoEncodeH265RateControlInfoEXT {
60472         self.inner
60473     }
60474 }
60475 #[repr(C)]
60476 #[cfg_attr(feature = "debug", derive(Debug))]
60477 #[derive(Copy, Clone, Default)]
60478 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265QpEXT.html>"]
60479 pub struct VideoEncodeH265QpEXT {
60480     pub qp_i: i32,
60481     pub qp_p: i32,
60482     pub qp_b: i32,
60483 }
60484 impl VideoEncodeH265QpEXT {
builder<'a>() -> VideoEncodeH265QpEXTBuilder<'a>60485     pub fn builder<'a>() -> VideoEncodeH265QpEXTBuilder<'a> {
60486         VideoEncodeH265QpEXTBuilder {
60487             inner: Self::default(),
60488             marker: ::std::marker::PhantomData,
60489         }
60490     }
60491 }
60492 #[repr(transparent)]
60493 pub struct VideoEncodeH265QpEXTBuilder<'a> {
60494     inner: VideoEncodeH265QpEXT,
60495     marker: ::std::marker::PhantomData<&'a ()>,
60496 }
60497 impl<'a> ::std::ops::Deref for VideoEncodeH265QpEXTBuilder<'a> {
60498     type Target = VideoEncodeH265QpEXT;
deref(&self) -> &Self::Target60499     fn deref(&self) -> &Self::Target {
60500         &self.inner
60501     }
60502 }
60503 impl<'a> ::std::ops::DerefMut for VideoEncodeH265QpEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target60504     fn deref_mut(&mut self) -> &mut Self::Target {
60505         &mut self.inner
60506     }
60507 }
60508 impl<'a> VideoEncodeH265QpEXTBuilder<'a> {
60509     #[inline]
qp_i(mut self, qp_i: i32) -> Self60510     pub fn qp_i(mut self, qp_i: i32) -> Self {
60511         self.inner.qp_i = qp_i;
60512         self
60513     }
60514     #[inline]
qp_p(mut self, qp_p: i32) -> Self60515     pub fn qp_p(mut self, qp_p: i32) -> Self {
60516         self.inner.qp_p = qp_p;
60517         self
60518     }
60519     #[inline]
qp_b(mut self, qp_b: i32) -> Self60520     pub fn qp_b(mut self, qp_b: i32) -> Self {
60521         self.inner.qp_b = qp_b;
60522         self
60523     }
60524     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
60525     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
60526     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoEncodeH265QpEXT60527     pub fn build(self) -> VideoEncodeH265QpEXT {
60528         self.inner
60529     }
60530 }
60531 #[repr(C)]
60532 #[cfg_attr(feature = "debug", derive(Debug))]
60533 #[derive(Copy, Clone, Default)]
60534 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265FrameSizeEXT.html>"]
60535 pub struct VideoEncodeH265FrameSizeEXT {
60536     pub frame_i_size: u32,
60537     pub frame_p_size: u32,
60538     pub frame_b_size: u32,
60539 }
60540 impl VideoEncodeH265FrameSizeEXT {
builder<'a>() -> VideoEncodeH265FrameSizeEXTBuilder<'a>60541     pub fn builder<'a>() -> VideoEncodeH265FrameSizeEXTBuilder<'a> {
60542         VideoEncodeH265FrameSizeEXTBuilder {
60543             inner: Self::default(),
60544             marker: ::std::marker::PhantomData,
60545         }
60546     }
60547 }
60548 #[repr(transparent)]
60549 pub struct VideoEncodeH265FrameSizeEXTBuilder<'a> {
60550     inner: VideoEncodeH265FrameSizeEXT,
60551     marker: ::std::marker::PhantomData<&'a ()>,
60552 }
60553 impl<'a> ::std::ops::Deref for VideoEncodeH265FrameSizeEXTBuilder<'a> {
60554     type Target = VideoEncodeH265FrameSizeEXT;
deref(&self) -> &Self::Target60555     fn deref(&self) -> &Self::Target {
60556         &self.inner
60557     }
60558 }
60559 impl<'a> ::std::ops::DerefMut for VideoEncodeH265FrameSizeEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target60560     fn deref_mut(&mut self) -> &mut Self::Target {
60561         &mut self.inner
60562     }
60563 }
60564 impl<'a> VideoEncodeH265FrameSizeEXTBuilder<'a> {
60565     #[inline]
frame_i_size(mut self, frame_i_size: u32) -> Self60566     pub fn frame_i_size(mut self, frame_i_size: u32) -> Self {
60567         self.inner.frame_i_size = frame_i_size;
60568         self
60569     }
60570     #[inline]
frame_p_size(mut self, frame_p_size: u32) -> Self60571     pub fn frame_p_size(mut self, frame_p_size: u32) -> Self {
60572         self.inner.frame_p_size = frame_p_size;
60573         self
60574     }
60575     #[inline]
frame_b_size(mut self, frame_b_size: u32) -> Self60576     pub fn frame_b_size(mut self, frame_b_size: u32) -> Self {
60577         self.inner.frame_b_size = frame_b_size;
60578         self
60579     }
60580     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
60581     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
60582     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoEncodeH265FrameSizeEXT60583     pub fn build(self) -> VideoEncodeH265FrameSizeEXT {
60584         self.inner
60585     }
60586 }
60587 #[repr(C)]
60588 #[cfg_attr(feature = "debug", derive(Debug))]
60589 #[derive(Copy, Clone)]
60590 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265RateControlLayerInfoEXT.html>"]
60591 pub struct VideoEncodeH265RateControlLayerInfoEXT {
60592     pub s_type: StructureType,
60593     pub p_next: *const c_void,
60594     pub temporal_id: u32,
60595     pub use_initial_rc_qp: Bool32,
60596     pub initial_rc_qp: VideoEncodeH265QpEXT,
60597     pub use_min_qp: Bool32,
60598     pub min_qp: VideoEncodeH265QpEXT,
60599     pub use_max_qp: Bool32,
60600     pub max_qp: VideoEncodeH265QpEXT,
60601     pub use_max_frame_size: Bool32,
60602     pub max_frame_size: VideoEncodeH265FrameSizeEXT,
60603 }
60604 impl ::std::default::Default for VideoEncodeH265RateControlLayerInfoEXT {
60605     #[inline]
default() -> Self60606     fn default() -> Self {
60607         Self {
60608             s_type: Self::STRUCTURE_TYPE,
60609             p_next: ::std::ptr::null(),
60610             temporal_id: u32::default(),
60611             use_initial_rc_qp: Bool32::default(),
60612             initial_rc_qp: VideoEncodeH265QpEXT::default(),
60613             use_min_qp: Bool32::default(),
60614             min_qp: VideoEncodeH265QpEXT::default(),
60615             use_max_qp: Bool32::default(),
60616             max_qp: VideoEncodeH265QpEXT::default(),
60617             use_max_frame_size: Bool32::default(),
60618             max_frame_size: VideoEncodeH265FrameSizeEXT::default(),
60619         }
60620     }
60621 }
60622 unsafe impl TaggedStructure for VideoEncodeH265RateControlLayerInfoEXT {
60623     const STRUCTURE_TYPE: StructureType =
60624         StructureType::VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT;
60625 }
60626 impl VideoEncodeH265RateControlLayerInfoEXT {
builder<'a>() -> VideoEncodeH265RateControlLayerInfoEXTBuilder<'a>60627     pub fn builder<'a>() -> VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> {
60628         VideoEncodeH265RateControlLayerInfoEXTBuilder {
60629             inner: Self::default(),
60630             marker: ::std::marker::PhantomData,
60631         }
60632     }
60633 }
60634 #[repr(transparent)]
60635 pub struct VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> {
60636     inner: VideoEncodeH265RateControlLayerInfoEXT,
60637     marker: ::std::marker::PhantomData<&'a ()>,
60638 }
60639 unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH265RateControlLayerInfoEXTBuilder<'_> {}
60640 unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH265RateControlLayerInfoEXT {}
60641 unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR
60642     for VideoEncodeH265RateControlLayerInfoEXTBuilder<'_>
60643 {
60644 }
60645 unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR for VideoEncodeH265RateControlLayerInfoEXT {}
60646 impl<'a> ::std::ops::Deref for VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> {
60647     type Target = VideoEncodeH265RateControlLayerInfoEXT;
deref(&self) -> &Self::Target60648     fn deref(&self) -> &Self::Target {
60649         &self.inner
60650     }
60651 }
60652 impl<'a> ::std::ops::DerefMut for VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target60653     fn deref_mut(&mut self) -> &mut Self::Target {
60654         &mut self.inner
60655     }
60656 }
60657 impl<'a> VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> {
60658     #[inline]
temporal_id(mut self, temporal_id: u32) -> Self60659     pub fn temporal_id(mut self, temporal_id: u32) -> Self {
60660         self.inner.temporal_id = temporal_id;
60661         self
60662     }
60663     #[inline]
use_initial_rc_qp(mut self, use_initial_rc_qp: bool) -> Self60664     pub fn use_initial_rc_qp(mut self, use_initial_rc_qp: bool) -> Self {
60665         self.inner.use_initial_rc_qp = use_initial_rc_qp.into();
60666         self
60667     }
60668     #[inline]
initial_rc_qp(mut self, initial_rc_qp: VideoEncodeH265QpEXT) -> Self60669     pub fn initial_rc_qp(mut self, initial_rc_qp: VideoEncodeH265QpEXT) -> Self {
60670         self.inner.initial_rc_qp = initial_rc_qp;
60671         self
60672     }
60673     #[inline]
use_min_qp(mut self, use_min_qp: bool) -> Self60674     pub fn use_min_qp(mut self, use_min_qp: bool) -> Self {
60675         self.inner.use_min_qp = use_min_qp.into();
60676         self
60677     }
60678     #[inline]
min_qp(mut self, min_qp: VideoEncodeH265QpEXT) -> Self60679     pub fn min_qp(mut self, min_qp: VideoEncodeH265QpEXT) -> Self {
60680         self.inner.min_qp = min_qp;
60681         self
60682     }
60683     #[inline]
use_max_qp(mut self, use_max_qp: bool) -> Self60684     pub fn use_max_qp(mut self, use_max_qp: bool) -> Self {
60685         self.inner.use_max_qp = use_max_qp.into();
60686         self
60687     }
60688     #[inline]
max_qp(mut self, max_qp: VideoEncodeH265QpEXT) -> Self60689     pub fn max_qp(mut self, max_qp: VideoEncodeH265QpEXT) -> Self {
60690         self.inner.max_qp = max_qp;
60691         self
60692     }
60693     #[inline]
use_max_frame_size(mut self, use_max_frame_size: bool) -> Self60694     pub fn use_max_frame_size(mut self, use_max_frame_size: bool) -> Self {
60695         self.inner.use_max_frame_size = use_max_frame_size.into();
60696         self
60697     }
60698     #[inline]
max_frame_size(mut self, max_frame_size: VideoEncodeH265FrameSizeEXT) -> Self60699     pub fn max_frame_size(mut self, max_frame_size: VideoEncodeH265FrameSizeEXT) -> Self {
60700         self.inner.max_frame_size = max_frame_size;
60701         self
60702     }
60703     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
60704     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
60705     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoEncodeH265RateControlLayerInfoEXT60706     pub fn build(self) -> VideoEncodeH265RateControlLayerInfoEXT {
60707         self.inner
60708     }
60709 }
60710 #[repr(C)]
60711 #[cfg_attr(feature = "debug", derive(Debug))]
60712 #[derive(Copy, Clone)]
60713 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265ProfileInfoEXT.html>"]
60714 pub struct VideoEncodeH265ProfileInfoEXT {
60715     pub s_type: StructureType,
60716     pub p_next: *const c_void,
60717     pub std_profile_idc: StdVideoH265ProfileIdc,
60718 }
60719 impl ::std::default::Default for VideoEncodeH265ProfileInfoEXT {
60720     #[inline]
default() -> Self60721     fn default() -> Self {
60722         Self {
60723             s_type: Self::STRUCTURE_TYPE,
60724             p_next: ::std::ptr::null(),
60725             std_profile_idc: StdVideoH265ProfileIdc::default(),
60726         }
60727     }
60728 }
60729 unsafe impl TaggedStructure for VideoEncodeH265ProfileInfoEXT {
60730     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_PROFILE_INFO_EXT;
60731 }
60732 impl VideoEncodeH265ProfileInfoEXT {
builder<'a>() -> VideoEncodeH265ProfileInfoEXTBuilder<'a>60733     pub fn builder<'a>() -> VideoEncodeH265ProfileInfoEXTBuilder<'a> {
60734         VideoEncodeH265ProfileInfoEXTBuilder {
60735             inner: Self::default(),
60736             marker: ::std::marker::PhantomData,
60737         }
60738     }
60739 }
60740 #[repr(transparent)]
60741 pub struct VideoEncodeH265ProfileInfoEXTBuilder<'a> {
60742     inner: VideoEncodeH265ProfileInfoEXT,
60743     marker: ::std::marker::PhantomData<&'a ()>,
60744 }
60745 unsafe impl ExtendsVideoProfileInfoKHR for VideoEncodeH265ProfileInfoEXTBuilder<'_> {}
60746 unsafe impl ExtendsVideoProfileInfoKHR for VideoEncodeH265ProfileInfoEXT {}
60747 unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH265ProfileInfoEXTBuilder<'_> {}
60748 unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH265ProfileInfoEXT {}
60749 impl<'a> ::std::ops::Deref for VideoEncodeH265ProfileInfoEXTBuilder<'a> {
60750     type Target = VideoEncodeH265ProfileInfoEXT;
deref(&self) -> &Self::Target60751     fn deref(&self) -> &Self::Target {
60752         &self.inner
60753     }
60754 }
60755 impl<'a> ::std::ops::DerefMut for VideoEncodeH265ProfileInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target60756     fn deref_mut(&mut self) -> &mut Self::Target {
60757         &mut self.inner
60758     }
60759 }
60760 impl<'a> VideoEncodeH265ProfileInfoEXTBuilder<'a> {
60761     #[inline]
std_profile_idc(mut self, std_profile_idc: StdVideoH265ProfileIdc) -> Self60762     pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH265ProfileIdc) -> Self {
60763         self.inner.std_profile_idc = std_profile_idc;
60764         self
60765     }
60766     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
60767     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
60768     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoEncodeH265ProfileInfoEXT60769     pub fn build(self) -> VideoEncodeH265ProfileInfoEXT {
60770         self.inner
60771     }
60772 }
60773 #[repr(C)]
60774 #[cfg_attr(feature = "debug", derive(Debug))]
60775 #[derive(Copy, Clone)]
60776 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265DpbSlotInfoEXT.html>"]
60777 pub struct VideoEncodeH265DpbSlotInfoEXT {
60778     pub s_type: StructureType,
60779     pub p_next: *const c_void,
60780     pub p_std_reference_info: *const StdVideoEncodeH265ReferenceInfo,
60781 }
60782 impl ::std::default::Default for VideoEncodeH265DpbSlotInfoEXT {
60783     #[inline]
default() -> Self60784     fn default() -> Self {
60785         Self {
60786             s_type: Self::STRUCTURE_TYPE,
60787             p_next: ::std::ptr::null(),
60788             p_std_reference_info: ::std::ptr::null(),
60789         }
60790     }
60791 }
60792 unsafe impl TaggedStructure for VideoEncodeH265DpbSlotInfoEXT {
60793     const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT;
60794 }
60795 impl VideoEncodeH265DpbSlotInfoEXT {
builder<'a>() -> VideoEncodeH265DpbSlotInfoEXTBuilder<'a>60796     pub fn builder<'a>() -> VideoEncodeH265DpbSlotInfoEXTBuilder<'a> {
60797         VideoEncodeH265DpbSlotInfoEXTBuilder {
60798             inner: Self::default(),
60799             marker: ::std::marker::PhantomData,
60800         }
60801     }
60802 }
60803 #[repr(transparent)]
60804 pub struct VideoEncodeH265DpbSlotInfoEXTBuilder<'a> {
60805     inner: VideoEncodeH265DpbSlotInfoEXT,
60806     marker: ::std::marker::PhantomData<&'a ()>,
60807 }
60808 unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoEncodeH265DpbSlotInfoEXTBuilder<'_> {}
60809 unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoEncodeH265DpbSlotInfoEXT {}
60810 impl<'a> ::std::ops::Deref for VideoEncodeH265DpbSlotInfoEXTBuilder<'a> {
60811     type Target = VideoEncodeH265DpbSlotInfoEXT;
deref(&self) -> &Self::Target60812     fn deref(&self) -> &Self::Target {
60813         &self.inner
60814     }
60815 }
60816 impl<'a> ::std::ops::DerefMut for VideoEncodeH265DpbSlotInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target60817     fn deref_mut(&mut self) -> &mut Self::Target {
60818         &mut self.inner
60819     }
60820 }
60821 impl<'a> VideoEncodeH265DpbSlotInfoEXTBuilder<'a> {
60822     #[inline]
std_reference_info( mut self, std_reference_info: &'a StdVideoEncodeH265ReferenceInfo, ) -> Self60823     pub fn std_reference_info(
60824         mut self,
60825         std_reference_info: &'a StdVideoEncodeH265ReferenceInfo,
60826     ) -> Self {
60827         self.inner.p_std_reference_info = std_reference_info;
60828         self
60829     }
60830     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
60831     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
60832     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VideoEncodeH265DpbSlotInfoEXT60833     pub fn build(self) -> VideoEncodeH265DpbSlotInfoEXT {
60834         self.inner
60835     }
60836 }
60837 #[repr(C)]
60838 #[cfg_attr(feature = "debug", derive(Debug))]
60839 #[derive(Copy, Clone)]
60840 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceInheritedViewportScissorFeaturesNV.html>"]
60841 pub struct PhysicalDeviceInheritedViewportScissorFeaturesNV {
60842     pub s_type: StructureType,
60843     pub p_next: *mut c_void,
60844     pub inherited_viewport_scissor2_d: Bool32,
60845 }
60846 impl ::std::default::Default for PhysicalDeviceInheritedViewportScissorFeaturesNV {
60847     #[inline]
default() -> Self60848     fn default() -> Self {
60849         Self {
60850             s_type: Self::STRUCTURE_TYPE,
60851             p_next: ::std::ptr::null_mut(),
60852             inherited_viewport_scissor2_d: Bool32::default(),
60853         }
60854     }
60855 }
60856 unsafe impl TaggedStructure for PhysicalDeviceInheritedViewportScissorFeaturesNV {
60857     const STRUCTURE_TYPE: StructureType =
60858         StructureType::PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
60859 }
60860 impl PhysicalDeviceInheritedViewportScissorFeaturesNV {
builder<'a>() -> PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a>60861     pub fn builder<'a>() -> PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> {
60862         PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder {
60863             inner: Self::default(),
60864             marker: ::std::marker::PhantomData,
60865         }
60866     }
60867 }
60868 #[repr(transparent)]
60869 pub struct PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> {
60870     inner: PhysicalDeviceInheritedViewportScissorFeaturesNV,
60871     marker: ::std::marker::PhantomData<&'a ()>,
60872 }
60873 unsafe impl ExtendsPhysicalDeviceFeatures2
60874     for PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'_>
60875 {
60876 }
60877 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInheritedViewportScissorFeaturesNV {}
60878 unsafe impl ExtendsDeviceCreateInfo
60879     for PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'_>
60880 {
60881 }
60882 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInheritedViewportScissorFeaturesNV {}
60883 impl<'a> ::std::ops::Deref for PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> {
60884     type Target = PhysicalDeviceInheritedViewportScissorFeaturesNV;
deref(&self) -> &Self::Target60885     fn deref(&self) -> &Self::Target {
60886         &self.inner
60887     }
60888 }
60889 impl<'a> ::std::ops::DerefMut for PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target60890     fn deref_mut(&mut self) -> &mut Self::Target {
60891         &mut self.inner
60892     }
60893 }
60894 impl<'a> PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> {
60895     #[inline]
inherited_viewport_scissor2_d(mut self, inherited_viewport_scissor2_d: bool) -> Self60896     pub fn inherited_viewport_scissor2_d(mut self, inherited_viewport_scissor2_d: bool) -> Self {
60897         self.inner.inherited_viewport_scissor2_d = inherited_viewport_scissor2_d.into();
60898         self
60899     }
60900     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
60901     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
60902     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceInheritedViewportScissorFeaturesNV60903     pub fn build(self) -> PhysicalDeviceInheritedViewportScissorFeaturesNV {
60904         self.inner
60905     }
60906 }
60907 #[repr(C)]
60908 #[cfg_attr(feature = "debug", derive(Debug))]
60909 #[derive(Copy, Clone)]
60910 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferInheritanceViewportScissorInfoNV.html>"]
60911 pub struct CommandBufferInheritanceViewportScissorInfoNV {
60912     pub s_type: StructureType,
60913     pub p_next: *const c_void,
60914     pub viewport_scissor2_d: Bool32,
60915     pub viewport_depth_count: u32,
60916     pub p_viewport_depths: *const Viewport,
60917 }
60918 impl ::std::default::Default for CommandBufferInheritanceViewportScissorInfoNV {
60919     #[inline]
default() -> Self60920     fn default() -> Self {
60921         Self {
60922             s_type: Self::STRUCTURE_TYPE,
60923             p_next: ::std::ptr::null(),
60924             viewport_scissor2_d: Bool32::default(),
60925             viewport_depth_count: u32::default(),
60926             p_viewport_depths: ::std::ptr::null(),
60927         }
60928     }
60929 }
60930 unsafe impl TaggedStructure for CommandBufferInheritanceViewportScissorInfoNV {
60931     const STRUCTURE_TYPE: StructureType =
60932         StructureType::COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV;
60933 }
60934 impl CommandBufferInheritanceViewportScissorInfoNV {
builder<'a>() -> CommandBufferInheritanceViewportScissorInfoNVBuilder<'a>60935     pub fn builder<'a>() -> CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> {
60936         CommandBufferInheritanceViewportScissorInfoNVBuilder {
60937             inner: Self::default(),
60938             marker: ::std::marker::PhantomData,
60939         }
60940     }
60941 }
60942 #[repr(transparent)]
60943 pub struct CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> {
60944     inner: CommandBufferInheritanceViewportScissorInfoNV,
60945     marker: ::std::marker::PhantomData<&'a ()>,
60946 }
60947 unsafe impl ExtendsCommandBufferInheritanceInfo
60948     for CommandBufferInheritanceViewportScissorInfoNVBuilder<'_>
60949 {
60950 }
60951 unsafe impl ExtendsCommandBufferInheritanceInfo for CommandBufferInheritanceViewportScissorInfoNV {}
60952 impl<'a> ::std::ops::Deref for CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> {
60953     type Target = CommandBufferInheritanceViewportScissorInfoNV;
deref(&self) -> &Self::Target60954     fn deref(&self) -> &Self::Target {
60955         &self.inner
60956     }
60957 }
60958 impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target60959     fn deref_mut(&mut self) -> &mut Self::Target {
60960         &mut self.inner
60961     }
60962 }
60963 impl<'a> CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> {
60964     #[inline]
viewport_scissor2_d(mut self, viewport_scissor2_d: bool) -> Self60965     pub fn viewport_scissor2_d(mut self, viewport_scissor2_d: bool) -> Self {
60966         self.inner.viewport_scissor2_d = viewport_scissor2_d.into();
60967         self
60968     }
60969     #[inline]
viewport_depth_count(mut self, viewport_depth_count: u32) -> Self60970     pub fn viewport_depth_count(mut self, viewport_depth_count: u32) -> Self {
60971         self.inner.viewport_depth_count = viewport_depth_count;
60972         self
60973     }
60974     #[inline]
viewport_depths(mut self, viewport_depths: &'a Viewport) -> Self60975     pub fn viewport_depths(mut self, viewport_depths: &'a Viewport) -> Self {
60976         self.inner.p_viewport_depths = viewport_depths;
60977         self
60978     }
60979     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
60980     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
60981     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CommandBufferInheritanceViewportScissorInfoNV60982     pub fn build(self) -> CommandBufferInheritanceViewportScissorInfoNV {
60983         self.inner
60984     }
60985 }
60986 #[repr(C)]
60987 #[cfg_attr(feature = "debug", derive(Debug))]
60988 #[derive(Copy, Clone)]
60989 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT.html>"]
60990 pub struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
60991     pub s_type: StructureType,
60992     pub p_next: *mut c_void,
60993     pub ycbcr2plane444_formats: Bool32,
60994 }
60995 impl ::std::default::Default for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
60996     #[inline]
default() -> Self60997     fn default() -> Self {
60998         Self {
60999             s_type: Self::STRUCTURE_TYPE,
61000             p_next: ::std::ptr::null_mut(),
61001             ycbcr2plane444_formats: Bool32::default(),
61002         }
61003     }
61004 }
61005 unsafe impl TaggedStructure for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
61006     const STRUCTURE_TYPE: StructureType =
61007         StructureType::PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
61008 }
61009 impl PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
builder<'a>() -> PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a>61010     pub fn builder<'a>() -> PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> {
61011         PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder {
61012             inner: Self::default(),
61013             marker: ::std::marker::PhantomData,
61014         }
61015     }
61016 }
61017 #[repr(transparent)]
61018 pub struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> {
61019     inner: PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT,
61020     marker: ::std::marker::PhantomData<&'a ()>,
61021 }
61022 unsafe impl ExtendsPhysicalDeviceFeatures2
61023     for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'_>
61024 {
61025 }
61026 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {}
61027 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'_> {}
61028 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {}
61029 impl<'a> ::std::ops::Deref for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> {
61030     type Target = PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
deref(&self) -> &Self::Target61031     fn deref(&self) -> &Self::Target {
61032         &self.inner
61033     }
61034 }
61035 impl<'a> ::std::ops::DerefMut for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target61036     fn deref_mut(&mut self) -> &mut Self::Target {
61037         &mut self.inner
61038     }
61039 }
61040 impl<'a> PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> {
61041     #[inline]
ycbcr2plane444_formats(mut self, ycbcr2plane444_formats: bool) -> Self61042     pub fn ycbcr2plane444_formats(mut self, ycbcr2plane444_formats: bool) -> Self {
61043         self.inner.ycbcr2plane444_formats = ycbcr2plane444_formats.into();
61044         self
61045     }
61046     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
61047     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
61048     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT61049     pub fn build(self) -> PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
61050         self.inner
61051     }
61052 }
61053 #[repr(C)]
61054 #[cfg_attr(feature = "debug", derive(Debug))]
61055 #[derive(Copy, Clone)]
61056 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProvokingVertexFeaturesEXT.html>"]
61057 pub struct PhysicalDeviceProvokingVertexFeaturesEXT {
61058     pub s_type: StructureType,
61059     pub p_next: *mut c_void,
61060     pub provoking_vertex_last: Bool32,
61061     pub transform_feedback_preserves_provoking_vertex: Bool32,
61062 }
61063 impl ::std::default::Default for PhysicalDeviceProvokingVertexFeaturesEXT {
61064     #[inline]
default() -> Self61065     fn default() -> Self {
61066         Self {
61067             s_type: Self::STRUCTURE_TYPE,
61068             p_next: ::std::ptr::null_mut(),
61069             provoking_vertex_last: Bool32::default(),
61070             transform_feedback_preserves_provoking_vertex: Bool32::default(),
61071         }
61072     }
61073 }
61074 unsafe impl TaggedStructure for PhysicalDeviceProvokingVertexFeaturesEXT {
61075     const STRUCTURE_TYPE: StructureType =
61076         StructureType::PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
61077 }
61078 impl PhysicalDeviceProvokingVertexFeaturesEXT {
builder<'a>() -> PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a>61079     pub fn builder<'a>() -> PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> {
61080         PhysicalDeviceProvokingVertexFeaturesEXTBuilder {
61081             inner: Self::default(),
61082             marker: ::std::marker::PhantomData,
61083         }
61084     }
61085 }
61086 #[repr(transparent)]
61087 pub struct PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> {
61088     inner: PhysicalDeviceProvokingVertexFeaturesEXT,
61089     marker: ::std::marker::PhantomData<&'a ()>,
61090 }
61091 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'_> {}
61092 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProvokingVertexFeaturesEXT {}
61093 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'_> {}
61094 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProvokingVertexFeaturesEXT {}
61095 impl<'a> ::std::ops::Deref for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> {
61096     type Target = PhysicalDeviceProvokingVertexFeaturesEXT;
deref(&self) -> &Self::Target61097     fn deref(&self) -> &Self::Target {
61098         &self.inner
61099     }
61100 }
61101 impl<'a> ::std::ops::DerefMut for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target61102     fn deref_mut(&mut self) -> &mut Self::Target {
61103         &mut self.inner
61104     }
61105 }
61106 impl<'a> PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> {
61107     #[inline]
provoking_vertex_last(mut self, provoking_vertex_last: bool) -> Self61108     pub fn provoking_vertex_last(mut self, provoking_vertex_last: bool) -> Self {
61109         self.inner.provoking_vertex_last = provoking_vertex_last.into();
61110         self
61111     }
61112     #[inline]
transform_feedback_preserves_provoking_vertex( mut self, transform_feedback_preserves_provoking_vertex: bool, ) -> Self61113     pub fn transform_feedback_preserves_provoking_vertex(
61114         mut self,
61115         transform_feedback_preserves_provoking_vertex: bool,
61116     ) -> Self {
61117         self.inner.transform_feedback_preserves_provoking_vertex =
61118             transform_feedback_preserves_provoking_vertex.into();
61119         self
61120     }
61121     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
61122     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
61123     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceProvokingVertexFeaturesEXT61124     pub fn build(self) -> PhysicalDeviceProvokingVertexFeaturesEXT {
61125         self.inner
61126     }
61127 }
61128 #[repr(C)]
61129 #[cfg_attr(feature = "debug", derive(Debug))]
61130 #[derive(Copy, Clone)]
61131 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProvokingVertexPropertiesEXT.html>"]
61132 pub struct PhysicalDeviceProvokingVertexPropertiesEXT {
61133     pub s_type: StructureType,
61134     pub p_next: *mut c_void,
61135     pub provoking_vertex_mode_per_pipeline: Bool32,
61136     pub transform_feedback_preserves_triangle_fan_provoking_vertex: Bool32,
61137 }
61138 impl ::std::default::Default for PhysicalDeviceProvokingVertexPropertiesEXT {
61139     #[inline]
default() -> Self61140     fn default() -> Self {
61141         Self {
61142             s_type: Self::STRUCTURE_TYPE,
61143             p_next: ::std::ptr::null_mut(),
61144             provoking_vertex_mode_per_pipeline: Bool32::default(),
61145             transform_feedback_preserves_triangle_fan_provoking_vertex: Bool32::default(),
61146         }
61147     }
61148 }
61149 unsafe impl TaggedStructure for PhysicalDeviceProvokingVertexPropertiesEXT {
61150     const STRUCTURE_TYPE: StructureType =
61151         StructureType::PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT;
61152 }
61153 impl PhysicalDeviceProvokingVertexPropertiesEXT {
builder<'a>() -> PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a>61154     pub fn builder<'a>() -> PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> {
61155         PhysicalDeviceProvokingVertexPropertiesEXTBuilder {
61156             inner: Self::default(),
61157             marker: ::std::marker::PhantomData,
61158         }
61159     }
61160 }
61161 #[repr(transparent)]
61162 pub struct PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> {
61163     inner: PhysicalDeviceProvokingVertexPropertiesEXT,
61164     marker: ::std::marker::PhantomData<&'a ()>,
61165 }
61166 unsafe impl ExtendsPhysicalDeviceProperties2
61167     for PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'_>
61168 {
61169 }
61170 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceProvokingVertexPropertiesEXT {}
61171 impl<'a> ::std::ops::Deref for PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> {
61172     type Target = PhysicalDeviceProvokingVertexPropertiesEXT;
deref(&self) -> &Self::Target61173     fn deref(&self) -> &Self::Target {
61174         &self.inner
61175     }
61176 }
61177 impl<'a> ::std::ops::DerefMut for PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target61178     fn deref_mut(&mut self) -> &mut Self::Target {
61179         &mut self.inner
61180     }
61181 }
61182 impl<'a> PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> {
61183     #[inline]
provoking_vertex_mode_per_pipeline( mut self, provoking_vertex_mode_per_pipeline: bool, ) -> Self61184     pub fn provoking_vertex_mode_per_pipeline(
61185         mut self,
61186         provoking_vertex_mode_per_pipeline: bool,
61187     ) -> Self {
61188         self.inner.provoking_vertex_mode_per_pipeline = provoking_vertex_mode_per_pipeline.into();
61189         self
61190     }
61191     #[inline]
transform_feedback_preserves_triangle_fan_provoking_vertex( mut self, transform_feedback_preserves_triangle_fan_provoking_vertex: bool, ) -> Self61192     pub fn transform_feedback_preserves_triangle_fan_provoking_vertex(
61193         mut self,
61194         transform_feedback_preserves_triangle_fan_provoking_vertex: bool,
61195     ) -> Self {
61196         self.inner
61197             .transform_feedback_preserves_triangle_fan_provoking_vertex =
61198             transform_feedback_preserves_triangle_fan_provoking_vertex.into();
61199         self
61200     }
61201     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
61202     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
61203     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceProvokingVertexPropertiesEXT61204     pub fn build(self) -> PhysicalDeviceProvokingVertexPropertiesEXT {
61205         self.inner
61206     }
61207 }
61208 #[repr(C)]
61209 #[cfg_attr(feature = "debug", derive(Debug))]
61210 #[derive(Copy, Clone)]
61211 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationProvokingVertexStateCreateInfoEXT.html>"]
61212 pub struct PipelineRasterizationProvokingVertexStateCreateInfoEXT {
61213     pub s_type: StructureType,
61214     pub p_next: *const c_void,
61215     pub provoking_vertex_mode: ProvokingVertexModeEXT,
61216 }
61217 impl ::std::default::Default for PipelineRasterizationProvokingVertexStateCreateInfoEXT {
61218     #[inline]
default() -> Self61219     fn default() -> Self {
61220         Self {
61221             s_type: Self::STRUCTURE_TYPE,
61222             p_next: ::std::ptr::null(),
61223             provoking_vertex_mode: ProvokingVertexModeEXT::default(),
61224         }
61225     }
61226 }
61227 unsafe impl TaggedStructure for PipelineRasterizationProvokingVertexStateCreateInfoEXT {
61228     const STRUCTURE_TYPE: StructureType =
61229         StructureType::PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT;
61230 }
61231 impl PipelineRasterizationProvokingVertexStateCreateInfoEXT {
builder<'a>() -> PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a>61232     pub fn builder<'a>() -> PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> {
61233         PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder {
61234             inner: Self::default(),
61235             marker: ::std::marker::PhantomData,
61236         }
61237     }
61238 }
61239 #[repr(transparent)]
61240 pub struct PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> {
61241     inner: PipelineRasterizationProvokingVertexStateCreateInfoEXT,
61242     marker: ::std::marker::PhantomData<&'a ()>,
61243 }
61244 unsafe impl ExtendsPipelineRasterizationStateCreateInfo
61245     for PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'_>
61246 {
61247 }
61248 unsafe impl ExtendsPipelineRasterizationStateCreateInfo
61249     for PipelineRasterizationProvokingVertexStateCreateInfoEXT
61250 {
61251 }
61252 impl<'a> ::std::ops::Deref for PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> {
61253     type Target = PipelineRasterizationProvokingVertexStateCreateInfoEXT;
deref(&self) -> &Self::Target61254     fn deref(&self) -> &Self::Target {
61255         &self.inner
61256     }
61257 }
61258 impl<'a> ::std::ops::DerefMut
61259     for PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a>
61260 {
deref_mut(&mut self) -> &mut Self::Target61261     fn deref_mut(&mut self) -> &mut Self::Target {
61262         &mut self.inner
61263     }
61264 }
61265 impl<'a> PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> {
61266     #[inline]
provoking_vertex_mode(mut self, provoking_vertex_mode: ProvokingVertexModeEXT) -> Self61267     pub fn provoking_vertex_mode(mut self, provoking_vertex_mode: ProvokingVertexModeEXT) -> Self {
61268         self.inner.provoking_vertex_mode = provoking_vertex_mode;
61269         self
61270     }
61271     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
61272     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
61273     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineRasterizationProvokingVertexStateCreateInfoEXT61274     pub fn build(self) -> PipelineRasterizationProvokingVertexStateCreateInfoEXT {
61275         self.inner
61276     }
61277 }
61278 #[repr(C)]
61279 #[cfg_attr(feature = "debug", derive(Debug))]
61280 #[derive(Copy, Clone)]
61281 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCuModuleCreateInfoNVX.html>"]
61282 pub struct CuModuleCreateInfoNVX {
61283     pub s_type: StructureType,
61284     pub p_next: *const c_void,
61285     pub data_size: usize,
61286     pub p_data: *const c_void,
61287 }
61288 impl ::std::default::Default for CuModuleCreateInfoNVX {
61289     #[inline]
default() -> Self61290     fn default() -> Self {
61291         Self {
61292             s_type: Self::STRUCTURE_TYPE,
61293             p_next: ::std::ptr::null(),
61294             data_size: usize::default(),
61295             p_data: ::std::ptr::null(),
61296         }
61297     }
61298 }
61299 unsafe impl TaggedStructure for CuModuleCreateInfoNVX {
61300     const STRUCTURE_TYPE: StructureType = StructureType::CU_MODULE_CREATE_INFO_NVX;
61301 }
61302 impl CuModuleCreateInfoNVX {
builder<'a>() -> CuModuleCreateInfoNVXBuilder<'a>61303     pub fn builder<'a>() -> CuModuleCreateInfoNVXBuilder<'a> {
61304         CuModuleCreateInfoNVXBuilder {
61305             inner: Self::default(),
61306             marker: ::std::marker::PhantomData,
61307         }
61308     }
61309 }
61310 #[repr(transparent)]
61311 pub struct CuModuleCreateInfoNVXBuilder<'a> {
61312     inner: CuModuleCreateInfoNVX,
61313     marker: ::std::marker::PhantomData<&'a ()>,
61314 }
61315 impl<'a> ::std::ops::Deref for CuModuleCreateInfoNVXBuilder<'a> {
61316     type Target = CuModuleCreateInfoNVX;
deref(&self) -> &Self::Target61317     fn deref(&self) -> &Self::Target {
61318         &self.inner
61319     }
61320 }
61321 impl<'a> ::std::ops::DerefMut for CuModuleCreateInfoNVXBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target61322     fn deref_mut(&mut self) -> &mut Self::Target {
61323         &mut self.inner
61324     }
61325 }
61326 impl<'a> CuModuleCreateInfoNVXBuilder<'a> {
61327     #[inline]
data(mut self, data: &'a [u8]) -> Self61328     pub fn data(mut self, data: &'a [u8]) -> Self {
61329         self.inner.data_size = data.len();
61330         self.inner.p_data = data.as_ptr().cast();
61331         self
61332     }
61333     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
61334     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
61335     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CuModuleCreateInfoNVX61336     pub fn build(self) -> CuModuleCreateInfoNVX {
61337         self.inner
61338     }
61339 }
61340 #[repr(C)]
61341 #[cfg_attr(feature = "debug", derive(Debug))]
61342 #[derive(Copy, Clone)]
61343 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCuFunctionCreateInfoNVX.html>"]
61344 pub struct CuFunctionCreateInfoNVX {
61345     pub s_type: StructureType,
61346     pub p_next: *const c_void,
61347     pub module: CuModuleNVX,
61348     pub p_name: *const c_char,
61349 }
61350 impl ::std::default::Default for CuFunctionCreateInfoNVX {
61351     #[inline]
default() -> Self61352     fn default() -> Self {
61353         Self {
61354             s_type: Self::STRUCTURE_TYPE,
61355             p_next: ::std::ptr::null(),
61356             module: CuModuleNVX::default(),
61357             p_name: ::std::ptr::null(),
61358         }
61359     }
61360 }
61361 unsafe impl TaggedStructure for CuFunctionCreateInfoNVX {
61362     const STRUCTURE_TYPE: StructureType = StructureType::CU_FUNCTION_CREATE_INFO_NVX;
61363 }
61364 impl CuFunctionCreateInfoNVX {
builder<'a>() -> CuFunctionCreateInfoNVXBuilder<'a>61365     pub fn builder<'a>() -> CuFunctionCreateInfoNVXBuilder<'a> {
61366         CuFunctionCreateInfoNVXBuilder {
61367             inner: Self::default(),
61368             marker: ::std::marker::PhantomData,
61369         }
61370     }
61371 }
61372 #[repr(transparent)]
61373 pub struct CuFunctionCreateInfoNVXBuilder<'a> {
61374     inner: CuFunctionCreateInfoNVX,
61375     marker: ::std::marker::PhantomData<&'a ()>,
61376 }
61377 impl<'a> ::std::ops::Deref for CuFunctionCreateInfoNVXBuilder<'a> {
61378     type Target = CuFunctionCreateInfoNVX;
deref(&self) -> &Self::Target61379     fn deref(&self) -> &Self::Target {
61380         &self.inner
61381     }
61382 }
61383 impl<'a> ::std::ops::DerefMut for CuFunctionCreateInfoNVXBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target61384     fn deref_mut(&mut self) -> &mut Self::Target {
61385         &mut self.inner
61386     }
61387 }
61388 impl<'a> CuFunctionCreateInfoNVXBuilder<'a> {
61389     #[inline]
module(mut self, module: CuModuleNVX) -> Self61390     pub fn module(mut self, module: CuModuleNVX) -> Self {
61391         self.inner.module = module;
61392         self
61393     }
61394     #[inline]
name(mut self, name: &'a ::std::ffi::CStr) -> Self61395     pub fn name(mut self, name: &'a ::std::ffi::CStr) -> Self {
61396         self.inner.p_name = name.as_ptr();
61397         self
61398     }
61399     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
61400     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
61401     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CuFunctionCreateInfoNVX61402     pub fn build(self) -> CuFunctionCreateInfoNVX {
61403         self.inner
61404     }
61405 }
61406 #[repr(C)]
61407 #[cfg_attr(feature = "debug", derive(Debug))]
61408 #[derive(Copy, Clone)]
61409 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCuLaunchInfoNVX.html>"]
61410 pub struct CuLaunchInfoNVX {
61411     pub s_type: StructureType,
61412     pub p_next: *const c_void,
61413     pub function: CuFunctionNVX,
61414     pub grid_dim_x: u32,
61415     pub grid_dim_y: u32,
61416     pub grid_dim_z: u32,
61417     pub block_dim_x: u32,
61418     pub block_dim_y: u32,
61419     pub block_dim_z: u32,
61420     pub shared_mem_bytes: u32,
61421     pub param_count: usize,
61422     pub p_params: *const *const c_void,
61423     pub extra_count: usize,
61424     pub p_extras: *const *const c_void,
61425 }
61426 impl ::std::default::Default for CuLaunchInfoNVX {
61427     #[inline]
default() -> Self61428     fn default() -> Self {
61429         Self {
61430             s_type: Self::STRUCTURE_TYPE,
61431             p_next: ::std::ptr::null(),
61432             function: CuFunctionNVX::default(),
61433             grid_dim_x: u32::default(),
61434             grid_dim_y: u32::default(),
61435             grid_dim_z: u32::default(),
61436             block_dim_x: u32::default(),
61437             block_dim_y: u32::default(),
61438             block_dim_z: u32::default(),
61439             shared_mem_bytes: u32::default(),
61440             param_count: usize::default(),
61441             p_params: ::std::ptr::null(),
61442             extra_count: usize::default(),
61443             p_extras: ::std::ptr::null(),
61444         }
61445     }
61446 }
61447 unsafe impl TaggedStructure for CuLaunchInfoNVX {
61448     const STRUCTURE_TYPE: StructureType = StructureType::CU_LAUNCH_INFO_NVX;
61449 }
61450 impl CuLaunchInfoNVX {
builder<'a>() -> CuLaunchInfoNVXBuilder<'a>61451     pub fn builder<'a>() -> CuLaunchInfoNVXBuilder<'a> {
61452         CuLaunchInfoNVXBuilder {
61453             inner: Self::default(),
61454             marker: ::std::marker::PhantomData,
61455         }
61456     }
61457 }
61458 #[repr(transparent)]
61459 pub struct CuLaunchInfoNVXBuilder<'a> {
61460     inner: CuLaunchInfoNVX,
61461     marker: ::std::marker::PhantomData<&'a ()>,
61462 }
61463 impl<'a> ::std::ops::Deref for CuLaunchInfoNVXBuilder<'a> {
61464     type Target = CuLaunchInfoNVX;
deref(&self) -> &Self::Target61465     fn deref(&self) -> &Self::Target {
61466         &self.inner
61467     }
61468 }
61469 impl<'a> ::std::ops::DerefMut for CuLaunchInfoNVXBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target61470     fn deref_mut(&mut self) -> &mut Self::Target {
61471         &mut self.inner
61472     }
61473 }
61474 impl<'a> CuLaunchInfoNVXBuilder<'a> {
61475     #[inline]
function(mut self, function: CuFunctionNVX) -> Self61476     pub fn function(mut self, function: CuFunctionNVX) -> Self {
61477         self.inner.function = function;
61478         self
61479     }
61480     #[inline]
grid_dim_x(mut self, grid_dim_x: u32) -> Self61481     pub fn grid_dim_x(mut self, grid_dim_x: u32) -> Self {
61482         self.inner.grid_dim_x = grid_dim_x;
61483         self
61484     }
61485     #[inline]
grid_dim_y(mut self, grid_dim_y: u32) -> Self61486     pub fn grid_dim_y(mut self, grid_dim_y: u32) -> Self {
61487         self.inner.grid_dim_y = grid_dim_y;
61488         self
61489     }
61490     #[inline]
grid_dim_z(mut self, grid_dim_z: u32) -> Self61491     pub fn grid_dim_z(mut self, grid_dim_z: u32) -> Self {
61492         self.inner.grid_dim_z = grid_dim_z;
61493         self
61494     }
61495     #[inline]
block_dim_x(mut self, block_dim_x: u32) -> Self61496     pub fn block_dim_x(mut self, block_dim_x: u32) -> Self {
61497         self.inner.block_dim_x = block_dim_x;
61498         self
61499     }
61500     #[inline]
block_dim_y(mut self, block_dim_y: u32) -> Self61501     pub fn block_dim_y(mut self, block_dim_y: u32) -> Self {
61502         self.inner.block_dim_y = block_dim_y;
61503         self
61504     }
61505     #[inline]
block_dim_z(mut self, block_dim_z: u32) -> Self61506     pub fn block_dim_z(mut self, block_dim_z: u32) -> Self {
61507         self.inner.block_dim_z = block_dim_z;
61508         self
61509     }
61510     #[inline]
shared_mem_bytes(mut self, shared_mem_bytes: u32) -> Self61511     pub fn shared_mem_bytes(mut self, shared_mem_bytes: u32) -> Self {
61512         self.inner.shared_mem_bytes = shared_mem_bytes;
61513         self
61514     }
61515     #[inline]
params(mut self, params: &'a [*const c_void]) -> Self61516     pub fn params(mut self, params: &'a [*const c_void]) -> Self {
61517         self.inner.param_count = params.len();
61518         self.inner.p_params = params.as_ptr();
61519         self
61520     }
61521     #[inline]
extras(mut self, extras: &'a [*const c_void]) -> Self61522     pub fn extras(mut self, extras: &'a [*const c_void]) -> Self {
61523         self.inner.extra_count = extras.len();
61524         self.inner.p_extras = extras.as_ptr();
61525         self
61526     }
61527     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
61528     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
61529     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CuLaunchInfoNVX61530     pub fn build(self) -> CuLaunchInfoNVX {
61531         self.inner
61532     }
61533 }
61534 #[repr(C)]
61535 #[cfg_attr(feature = "debug", derive(Debug))]
61536 #[derive(Copy, Clone)]
61537 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDescriptorBufferFeaturesEXT.html>"]
61538 pub struct PhysicalDeviceDescriptorBufferFeaturesEXT {
61539     pub s_type: StructureType,
61540     pub p_next: *mut c_void,
61541     pub descriptor_buffer: Bool32,
61542     pub descriptor_buffer_capture_replay: Bool32,
61543     pub descriptor_buffer_image_layout_ignored: Bool32,
61544     pub descriptor_buffer_push_descriptors: Bool32,
61545 }
61546 impl ::std::default::Default for PhysicalDeviceDescriptorBufferFeaturesEXT {
61547     #[inline]
default() -> Self61548     fn default() -> Self {
61549         Self {
61550             s_type: Self::STRUCTURE_TYPE,
61551             p_next: ::std::ptr::null_mut(),
61552             descriptor_buffer: Bool32::default(),
61553             descriptor_buffer_capture_replay: Bool32::default(),
61554             descriptor_buffer_image_layout_ignored: Bool32::default(),
61555             descriptor_buffer_push_descriptors: Bool32::default(),
61556         }
61557     }
61558 }
61559 unsafe impl TaggedStructure for PhysicalDeviceDescriptorBufferFeaturesEXT {
61560     const STRUCTURE_TYPE: StructureType =
61561         StructureType::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
61562 }
61563 impl PhysicalDeviceDescriptorBufferFeaturesEXT {
builder<'a>() -> PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'a>61564     pub fn builder<'a>() -> PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'a> {
61565         PhysicalDeviceDescriptorBufferFeaturesEXTBuilder {
61566             inner: Self::default(),
61567             marker: ::std::marker::PhantomData,
61568         }
61569     }
61570 }
61571 #[repr(transparent)]
61572 pub struct PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'a> {
61573     inner: PhysicalDeviceDescriptorBufferFeaturesEXT,
61574     marker: ::std::marker::PhantomData<&'a ()>,
61575 }
61576 unsafe impl ExtendsPhysicalDeviceFeatures2
61577     for PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'_>
61578 {
61579 }
61580 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorBufferFeaturesEXT {}
61581 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'_> {}
61582 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorBufferFeaturesEXT {}
61583 impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'a> {
61584     type Target = PhysicalDeviceDescriptorBufferFeaturesEXT;
deref(&self) -> &Self::Target61585     fn deref(&self) -> &Self::Target {
61586         &self.inner
61587     }
61588 }
61589 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target61590     fn deref_mut(&mut self) -> &mut Self::Target {
61591         &mut self.inner
61592     }
61593 }
61594 impl<'a> PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'a> {
61595     #[inline]
descriptor_buffer(mut self, descriptor_buffer: bool) -> Self61596     pub fn descriptor_buffer(mut self, descriptor_buffer: bool) -> Self {
61597         self.inner.descriptor_buffer = descriptor_buffer.into();
61598         self
61599     }
61600     #[inline]
descriptor_buffer_capture_replay( mut self, descriptor_buffer_capture_replay: bool, ) -> Self61601     pub fn descriptor_buffer_capture_replay(
61602         mut self,
61603         descriptor_buffer_capture_replay: bool,
61604     ) -> Self {
61605         self.inner.descriptor_buffer_capture_replay = descriptor_buffer_capture_replay.into();
61606         self
61607     }
61608     #[inline]
descriptor_buffer_image_layout_ignored( mut self, descriptor_buffer_image_layout_ignored: bool, ) -> Self61609     pub fn descriptor_buffer_image_layout_ignored(
61610         mut self,
61611         descriptor_buffer_image_layout_ignored: bool,
61612     ) -> Self {
61613         self.inner.descriptor_buffer_image_layout_ignored =
61614             descriptor_buffer_image_layout_ignored.into();
61615         self
61616     }
61617     #[inline]
descriptor_buffer_push_descriptors( mut self, descriptor_buffer_push_descriptors: bool, ) -> Self61618     pub fn descriptor_buffer_push_descriptors(
61619         mut self,
61620         descriptor_buffer_push_descriptors: bool,
61621     ) -> Self {
61622         self.inner.descriptor_buffer_push_descriptors = descriptor_buffer_push_descriptors.into();
61623         self
61624     }
61625     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
61626     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
61627     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDescriptorBufferFeaturesEXT61628     pub fn build(self) -> PhysicalDeviceDescriptorBufferFeaturesEXT {
61629         self.inner
61630     }
61631 }
61632 #[repr(C)]
61633 #[cfg_attr(feature = "debug", derive(Debug))]
61634 #[derive(Copy, Clone)]
61635 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDescriptorBufferPropertiesEXT.html>"]
61636 pub struct PhysicalDeviceDescriptorBufferPropertiesEXT {
61637     pub s_type: StructureType,
61638     pub p_next: *mut c_void,
61639     pub combined_image_sampler_descriptor_single_array: Bool32,
61640     pub bufferless_push_descriptors: Bool32,
61641     pub allow_sampler_image_view_post_submit_creation: Bool32,
61642     pub descriptor_buffer_offset_alignment: DeviceSize,
61643     pub max_descriptor_buffer_bindings: u32,
61644     pub max_resource_descriptor_buffer_bindings: u32,
61645     pub max_sampler_descriptor_buffer_bindings: u32,
61646     pub max_embedded_immutable_sampler_bindings: u32,
61647     pub max_embedded_immutable_samplers: u32,
61648     pub buffer_capture_replay_descriptor_data_size: usize,
61649     pub image_capture_replay_descriptor_data_size: usize,
61650     pub image_view_capture_replay_descriptor_data_size: usize,
61651     pub sampler_capture_replay_descriptor_data_size: usize,
61652     pub acceleration_structure_capture_replay_descriptor_data_size: usize,
61653     pub sampler_descriptor_size: usize,
61654     pub combined_image_sampler_descriptor_size: usize,
61655     pub sampled_image_descriptor_size: usize,
61656     pub storage_image_descriptor_size: usize,
61657     pub uniform_texel_buffer_descriptor_size: usize,
61658     pub robust_uniform_texel_buffer_descriptor_size: usize,
61659     pub storage_texel_buffer_descriptor_size: usize,
61660     pub robust_storage_texel_buffer_descriptor_size: usize,
61661     pub uniform_buffer_descriptor_size: usize,
61662     pub robust_uniform_buffer_descriptor_size: usize,
61663     pub storage_buffer_descriptor_size: usize,
61664     pub robust_storage_buffer_descriptor_size: usize,
61665     pub input_attachment_descriptor_size: usize,
61666     pub acceleration_structure_descriptor_size: usize,
61667     pub max_sampler_descriptor_buffer_range: DeviceSize,
61668     pub max_resource_descriptor_buffer_range: DeviceSize,
61669     pub sampler_descriptor_buffer_address_space_size: DeviceSize,
61670     pub resource_descriptor_buffer_address_space_size: DeviceSize,
61671     pub descriptor_buffer_address_space_size: DeviceSize,
61672 }
61673 impl ::std::default::Default for PhysicalDeviceDescriptorBufferPropertiesEXT {
61674     #[inline]
default() -> Self61675     fn default() -> Self {
61676         Self {
61677             s_type: Self::STRUCTURE_TYPE,
61678             p_next: ::std::ptr::null_mut(),
61679             combined_image_sampler_descriptor_single_array: Bool32::default(),
61680             bufferless_push_descriptors: Bool32::default(),
61681             allow_sampler_image_view_post_submit_creation: Bool32::default(),
61682             descriptor_buffer_offset_alignment: DeviceSize::default(),
61683             max_descriptor_buffer_bindings: u32::default(),
61684             max_resource_descriptor_buffer_bindings: u32::default(),
61685             max_sampler_descriptor_buffer_bindings: u32::default(),
61686             max_embedded_immutable_sampler_bindings: u32::default(),
61687             max_embedded_immutable_samplers: u32::default(),
61688             buffer_capture_replay_descriptor_data_size: usize::default(),
61689             image_capture_replay_descriptor_data_size: usize::default(),
61690             image_view_capture_replay_descriptor_data_size: usize::default(),
61691             sampler_capture_replay_descriptor_data_size: usize::default(),
61692             acceleration_structure_capture_replay_descriptor_data_size: usize::default(),
61693             sampler_descriptor_size: usize::default(),
61694             combined_image_sampler_descriptor_size: usize::default(),
61695             sampled_image_descriptor_size: usize::default(),
61696             storage_image_descriptor_size: usize::default(),
61697             uniform_texel_buffer_descriptor_size: usize::default(),
61698             robust_uniform_texel_buffer_descriptor_size: usize::default(),
61699             storage_texel_buffer_descriptor_size: usize::default(),
61700             robust_storage_texel_buffer_descriptor_size: usize::default(),
61701             uniform_buffer_descriptor_size: usize::default(),
61702             robust_uniform_buffer_descriptor_size: usize::default(),
61703             storage_buffer_descriptor_size: usize::default(),
61704             robust_storage_buffer_descriptor_size: usize::default(),
61705             input_attachment_descriptor_size: usize::default(),
61706             acceleration_structure_descriptor_size: usize::default(),
61707             max_sampler_descriptor_buffer_range: DeviceSize::default(),
61708             max_resource_descriptor_buffer_range: DeviceSize::default(),
61709             sampler_descriptor_buffer_address_space_size: DeviceSize::default(),
61710             resource_descriptor_buffer_address_space_size: DeviceSize::default(),
61711             descriptor_buffer_address_space_size: DeviceSize::default(),
61712         }
61713     }
61714 }
61715 unsafe impl TaggedStructure for PhysicalDeviceDescriptorBufferPropertiesEXT {
61716     const STRUCTURE_TYPE: StructureType =
61717         StructureType::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT;
61718 }
61719 impl PhysicalDeviceDescriptorBufferPropertiesEXT {
builder<'a>() -> PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'a>61720     pub fn builder<'a>() -> PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'a> {
61721         PhysicalDeviceDescriptorBufferPropertiesEXTBuilder {
61722             inner: Self::default(),
61723             marker: ::std::marker::PhantomData,
61724         }
61725     }
61726 }
61727 #[repr(transparent)]
61728 pub struct PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'a> {
61729     inner: PhysicalDeviceDescriptorBufferPropertiesEXT,
61730     marker: ::std::marker::PhantomData<&'a ()>,
61731 }
61732 unsafe impl ExtendsPhysicalDeviceProperties2
61733     for PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'_>
61734 {
61735 }
61736 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDescriptorBufferPropertiesEXT {}
61737 impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'a> {
61738     type Target = PhysicalDeviceDescriptorBufferPropertiesEXT;
deref(&self) -> &Self::Target61739     fn deref(&self) -> &Self::Target {
61740         &self.inner
61741     }
61742 }
61743 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target61744     fn deref_mut(&mut self) -> &mut Self::Target {
61745         &mut self.inner
61746     }
61747 }
61748 impl<'a> PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'a> {
61749     #[inline]
combined_image_sampler_descriptor_single_array( mut self, combined_image_sampler_descriptor_single_array: bool, ) -> Self61750     pub fn combined_image_sampler_descriptor_single_array(
61751         mut self,
61752         combined_image_sampler_descriptor_single_array: bool,
61753     ) -> Self {
61754         self.inner.combined_image_sampler_descriptor_single_array =
61755             combined_image_sampler_descriptor_single_array.into();
61756         self
61757     }
61758     #[inline]
bufferless_push_descriptors(mut self, bufferless_push_descriptors: bool) -> Self61759     pub fn bufferless_push_descriptors(mut self, bufferless_push_descriptors: bool) -> Self {
61760         self.inner.bufferless_push_descriptors = bufferless_push_descriptors.into();
61761         self
61762     }
61763     #[inline]
allow_sampler_image_view_post_submit_creation( mut self, allow_sampler_image_view_post_submit_creation: bool, ) -> Self61764     pub fn allow_sampler_image_view_post_submit_creation(
61765         mut self,
61766         allow_sampler_image_view_post_submit_creation: bool,
61767     ) -> Self {
61768         self.inner.allow_sampler_image_view_post_submit_creation =
61769             allow_sampler_image_view_post_submit_creation.into();
61770         self
61771     }
61772     #[inline]
descriptor_buffer_offset_alignment( mut self, descriptor_buffer_offset_alignment: DeviceSize, ) -> Self61773     pub fn descriptor_buffer_offset_alignment(
61774         mut self,
61775         descriptor_buffer_offset_alignment: DeviceSize,
61776     ) -> Self {
61777         self.inner.descriptor_buffer_offset_alignment = descriptor_buffer_offset_alignment;
61778         self
61779     }
61780     #[inline]
max_descriptor_buffer_bindings(mut self, max_descriptor_buffer_bindings: u32) -> Self61781     pub fn max_descriptor_buffer_bindings(mut self, max_descriptor_buffer_bindings: u32) -> Self {
61782         self.inner.max_descriptor_buffer_bindings = max_descriptor_buffer_bindings;
61783         self
61784     }
61785     #[inline]
max_resource_descriptor_buffer_bindings( mut self, max_resource_descriptor_buffer_bindings: u32, ) -> Self61786     pub fn max_resource_descriptor_buffer_bindings(
61787         mut self,
61788         max_resource_descriptor_buffer_bindings: u32,
61789     ) -> Self {
61790         self.inner.max_resource_descriptor_buffer_bindings =
61791             max_resource_descriptor_buffer_bindings;
61792         self
61793     }
61794     #[inline]
max_sampler_descriptor_buffer_bindings( mut self, max_sampler_descriptor_buffer_bindings: u32, ) -> Self61795     pub fn max_sampler_descriptor_buffer_bindings(
61796         mut self,
61797         max_sampler_descriptor_buffer_bindings: u32,
61798     ) -> Self {
61799         self.inner.max_sampler_descriptor_buffer_bindings = max_sampler_descriptor_buffer_bindings;
61800         self
61801     }
61802     #[inline]
max_embedded_immutable_sampler_bindings( mut self, max_embedded_immutable_sampler_bindings: u32, ) -> Self61803     pub fn max_embedded_immutable_sampler_bindings(
61804         mut self,
61805         max_embedded_immutable_sampler_bindings: u32,
61806     ) -> Self {
61807         self.inner.max_embedded_immutable_sampler_bindings =
61808             max_embedded_immutable_sampler_bindings;
61809         self
61810     }
61811     #[inline]
max_embedded_immutable_samplers(mut self, max_embedded_immutable_samplers: u32) -> Self61812     pub fn max_embedded_immutable_samplers(mut self, max_embedded_immutable_samplers: u32) -> Self {
61813         self.inner.max_embedded_immutable_samplers = max_embedded_immutable_samplers;
61814         self
61815     }
61816     #[inline]
buffer_capture_replay_descriptor_data_size( mut self, buffer_capture_replay_descriptor_data_size: usize, ) -> Self61817     pub fn buffer_capture_replay_descriptor_data_size(
61818         mut self,
61819         buffer_capture_replay_descriptor_data_size: usize,
61820     ) -> Self {
61821         self.inner.buffer_capture_replay_descriptor_data_size =
61822             buffer_capture_replay_descriptor_data_size;
61823         self
61824     }
61825     #[inline]
image_capture_replay_descriptor_data_size( mut self, image_capture_replay_descriptor_data_size: usize, ) -> Self61826     pub fn image_capture_replay_descriptor_data_size(
61827         mut self,
61828         image_capture_replay_descriptor_data_size: usize,
61829     ) -> Self {
61830         self.inner.image_capture_replay_descriptor_data_size =
61831             image_capture_replay_descriptor_data_size;
61832         self
61833     }
61834     #[inline]
image_view_capture_replay_descriptor_data_size( mut self, image_view_capture_replay_descriptor_data_size: usize, ) -> Self61835     pub fn image_view_capture_replay_descriptor_data_size(
61836         mut self,
61837         image_view_capture_replay_descriptor_data_size: usize,
61838     ) -> Self {
61839         self.inner.image_view_capture_replay_descriptor_data_size =
61840             image_view_capture_replay_descriptor_data_size;
61841         self
61842     }
61843     #[inline]
sampler_capture_replay_descriptor_data_size( mut self, sampler_capture_replay_descriptor_data_size: usize, ) -> Self61844     pub fn sampler_capture_replay_descriptor_data_size(
61845         mut self,
61846         sampler_capture_replay_descriptor_data_size: usize,
61847     ) -> Self {
61848         self.inner.sampler_capture_replay_descriptor_data_size =
61849             sampler_capture_replay_descriptor_data_size;
61850         self
61851     }
61852     #[inline]
acceleration_structure_capture_replay_descriptor_data_size( mut self, acceleration_structure_capture_replay_descriptor_data_size: usize, ) -> Self61853     pub fn acceleration_structure_capture_replay_descriptor_data_size(
61854         mut self,
61855         acceleration_structure_capture_replay_descriptor_data_size: usize,
61856     ) -> Self {
61857         self.inner
61858             .acceleration_structure_capture_replay_descriptor_data_size =
61859             acceleration_structure_capture_replay_descriptor_data_size;
61860         self
61861     }
61862     #[inline]
sampler_descriptor_size(mut self, sampler_descriptor_size: usize) -> Self61863     pub fn sampler_descriptor_size(mut self, sampler_descriptor_size: usize) -> Self {
61864         self.inner.sampler_descriptor_size = sampler_descriptor_size;
61865         self
61866     }
61867     #[inline]
combined_image_sampler_descriptor_size( mut self, combined_image_sampler_descriptor_size: usize, ) -> Self61868     pub fn combined_image_sampler_descriptor_size(
61869         mut self,
61870         combined_image_sampler_descriptor_size: usize,
61871     ) -> Self {
61872         self.inner.combined_image_sampler_descriptor_size = combined_image_sampler_descriptor_size;
61873         self
61874     }
61875     #[inline]
sampled_image_descriptor_size(mut self, sampled_image_descriptor_size: usize) -> Self61876     pub fn sampled_image_descriptor_size(mut self, sampled_image_descriptor_size: usize) -> Self {
61877         self.inner.sampled_image_descriptor_size = sampled_image_descriptor_size;
61878         self
61879     }
61880     #[inline]
storage_image_descriptor_size(mut self, storage_image_descriptor_size: usize) -> Self61881     pub fn storage_image_descriptor_size(mut self, storage_image_descriptor_size: usize) -> Self {
61882         self.inner.storage_image_descriptor_size = storage_image_descriptor_size;
61883         self
61884     }
61885     #[inline]
uniform_texel_buffer_descriptor_size( mut self, uniform_texel_buffer_descriptor_size: usize, ) -> Self61886     pub fn uniform_texel_buffer_descriptor_size(
61887         mut self,
61888         uniform_texel_buffer_descriptor_size: usize,
61889     ) -> Self {
61890         self.inner.uniform_texel_buffer_descriptor_size = uniform_texel_buffer_descriptor_size;
61891         self
61892     }
61893     #[inline]
robust_uniform_texel_buffer_descriptor_size( mut self, robust_uniform_texel_buffer_descriptor_size: usize, ) -> Self61894     pub fn robust_uniform_texel_buffer_descriptor_size(
61895         mut self,
61896         robust_uniform_texel_buffer_descriptor_size: usize,
61897     ) -> Self {
61898         self.inner.robust_uniform_texel_buffer_descriptor_size =
61899             robust_uniform_texel_buffer_descriptor_size;
61900         self
61901     }
61902     #[inline]
storage_texel_buffer_descriptor_size( mut self, storage_texel_buffer_descriptor_size: usize, ) -> Self61903     pub fn storage_texel_buffer_descriptor_size(
61904         mut self,
61905         storage_texel_buffer_descriptor_size: usize,
61906     ) -> Self {
61907         self.inner.storage_texel_buffer_descriptor_size = storage_texel_buffer_descriptor_size;
61908         self
61909     }
61910     #[inline]
robust_storage_texel_buffer_descriptor_size( mut self, robust_storage_texel_buffer_descriptor_size: usize, ) -> Self61911     pub fn robust_storage_texel_buffer_descriptor_size(
61912         mut self,
61913         robust_storage_texel_buffer_descriptor_size: usize,
61914     ) -> Self {
61915         self.inner.robust_storage_texel_buffer_descriptor_size =
61916             robust_storage_texel_buffer_descriptor_size;
61917         self
61918     }
61919     #[inline]
uniform_buffer_descriptor_size(mut self, uniform_buffer_descriptor_size: usize) -> Self61920     pub fn uniform_buffer_descriptor_size(mut self, uniform_buffer_descriptor_size: usize) -> Self {
61921         self.inner.uniform_buffer_descriptor_size = uniform_buffer_descriptor_size;
61922         self
61923     }
61924     #[inline]
robust_uniform_buffer_descriptor_size( mut self, robust_uniform_buffer_descriptor_size: usize, ) -> Self61925     pub fn robust_uniform_buffer_descriptor_size(
61926         mut self,
61927         robust_uniform_buffer_descriptor_size: usize,
61928     ) -> Self {
61929         self.inner.robust_uniform_buffer_descriptor_size = robust_uniform_buffer_descriptor_size;
61930         self
61931     }
61932     #[inline]
storage_buffer_descriptor_size(mut self, storage_buffer_descriptor_size: usize) -> Self61933     pub fn storage_buffer_descriptor_size(mut self, storage_buffer_descriptor_size: usize) -> Self {
61934         self.inner.storage_buffer_descriptor_size = storage_buffer_descriptor_size;
61935         self
61936     }
61937     #[inline]
robust_storage_buffer_descriptor_size( mut self, robust_storage_buffer_descriptor_size: usize, ) -> Self61938     pub fn robust_storage_buffer_descriptor_size(
61939         mut self,
61940         robust_storage_buffer_descriptor_size: usize,
61941     ) -> Self {
61942         self.inner.robust_storage_buffer_descriptor_size = robust_storage_buffer_descriptor_size;
61943         self
61944     }
61945     #[inline]
input_attachment_descriptor_size( mut self, input_attachment_descriptor_size: usize, ) -> Self61946     pub fn input_attachment_descriptor_size(
61947         mut self,
61948         input_attachment_descriptor_size: usize,
61949     ) -> Self {
61950         self.inner.input_attachment_descriptor_size = input_attachment_descriptor_size;
61951         self
61952     }
61953     #[inline]
acceleration_structure_descriptor_size( mut self, acceleration_structure_descriptor_size: usize, ) -> Self61954     pub fn acceleration_structure_descriptor_size(
61955         mut self,
61956         acceleration_structure_descriptor_size: usize,
61957     ) -> Self {
61958         self.inner.acceleration_structure_descriptor_size = acceleration_structure_descriptor_size;
61959         self
61960     }
61961     #[inline]
max_sampler_descriptor_buffer_range( mut self, max_sampler_descriptor_buffer_range: DeviceSize, ) -> Self61962     pub fn max_sampler_descriptor_buffer_range(
61963         mut self,
61964         max_sampler_descriptor_buffer_range: DeviceSize,
61965     ) -> Self {
61966         self.inner.max_sampler_descriptor_buffer_range = max_sampler_descriptor_buffer_range;
61967         self
61968     }
61969     #[inline]
max_resource_descriptor_buffer_range( mut self, max_resource_descriptor_buffer_range: DeviceSize, ) -> Self61970     pub fn max_resource_descriptor_buffer_range(
61971         mut self,
61972         max_resource_descriptor_buffer_range: DeviceSize,
61973     ) -> Self {
61974         self.inner.max_resource_descriptor_buffer_range = max_resource_descriptor_buffer_range;
61975         self
61976     }
61977     #[inline]
sampler_descriptor_buffer_address_space_size( mut self, sampler_descriptor_buffer_address_space_size: DeviceSize, ) -> Self61978     pub fn sampler_descriptor_buffer_address_space_size(
61979         mut self,
61980         sampler_descriptor_buffer_address_space_size: DeviceSize,
61981     ) -> Self {
61982         self.inner.sampler_descriptor_buffer_address_space_size =
61983             sampler_descriptor_buffer_address_space_size;
61984         self
61985     }
61986     #[inline]
resource_descriptor_buffer_address_space_size( mut self, resource_descriptor_buffer_address_space_size: DeviceSize, ) -> Self61987     pub fn resource_descriptor_buffer_address_space_size(
61988         mut self,
61989         resource_descriptor_buffer_address_space_size: DeviceSize,
61990     ) -> Self {
61991         self.inner.resource_descriptor_buffer_address_space_size =
61992             resource_descriptor_buffer_address_space_size;
61993         self
61994     }
61995     #[inline]
descriptor_buffer_address_space_size( mut self, descriptor_buffer_address_space_size: DeviceSize, ) -> Self61996     pub fn descriptor_buffer_address_space_size(
61997         mut self,
61998         descriptor_buffer_address_space_size: DeviceSize,
61999     ) -> Self {
62000         self.inner.descriptor_buffer_address_space_size = descriptor_buffer_address_space_size;
62001         self
62002     }
62003     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
62004     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
62005     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDescriptorBufferPropertiesEXT62006     pub fn build(self) -> PhysicalDeviceDescriptorBufferPropertiesEXT {
62007         self.inner
62008     }
62009 }
62010 #[repr(C)]
62011 #[cfg_attr(feature = "debug", derive(Debug))]
62012 #[derive(Copy, Clone)]
62013 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT.html>"]
62014 pub struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT {
62015     pub s_type: StructureType,
62016     pub p_next: *mut c_void,
62017     pub combined_image_sampler_density_map_descriptor_size: usize,
62018 }
62019 impl ::std::default::Default for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT {
62020     #[inline]
default() -> Self62021     fn default() -> Self {
62022         Self {
62023             s_type: Self::STRUCTURE_TYPE,
62024             p_next: ::std::ptr::null_mut(),
62025             combined_image_sampler_density_map_descriptor_size: usize::default(),
62026         }
62027     }
62028 }
62029 unsafe impl TaggedStructure for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT {
62030     const STRUCTURE_TYPE: StructureType =
62031         StructureType::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT;
62032 }
62033 impl PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT {
builder<'a>() -> PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<'a>62034     pub fn builder<'a>() -> PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<'a> {
62035         PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder {
62036             inner: Self::default(),
62037             marker: ::std::marker::PhantomData,
62038         }
62039     }
62040 }
62041 #[repr(transparent)]
62042 pub struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<'a> {
62043     inner: PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT,
62044     marker: ::std::marker::PhantomData<&'a ()>,
62045 }
62046 unsafe impl ExtendsPhysicalDeviceProperties2
62047     for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<'_>
62048 {
62049 }
62050 unsafe impl ExtendsPhysicalDeviceProperties2
62051     for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT
62052 {
62053 }
62054 impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<'a> {
62055     type Target = PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT;
deref(&self) -> &Self::Target62056     fn deref(&self) -> &Self::Target {
62057         &self.inner
62058     }
62059 }
62060 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target62061     fn deref_mut(&mut self) -> &mut Self::Target {
62062         &mut self.inner
62063     }
62064 }
62065 impl<'a> PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<'a> {
62066     #[inline]
combined_image_sampler_density_map_descriptor_size( mut self, combined_image_sampler_density_map_descriptor_size: usize, ) -> Self62067     pub fn combined_image_sampler_density_map_descriptor_size(
62068         mut self,
62069         combined_image_sampler_density_map_descriptor_size: usize,
62070     ) -> Self {
62071         self.inner
62072             .combined_image_sampler_density_map_descriptor_size =
62073             combined_image_sampler_density_map_descriptor_size;
62074         self
62075     }
62076     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
62077     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
62078     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT62079     pub fn build(self) -> PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT {
62080         self.inner
62081     }
62082 }
62083 #[repr(C)]
62084 #[cfg_attr(feature = "debug", derive(Debug))]
62085 #[derive(Copy, Clone)]
62086 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorAddressInfoEXT.html>"]
62087 pub struct DescriptorAddressInfoEXT {
62088     pub s_type: StructureType,
62089     pub p_next: *mut c_void,
62090     pub address: DeviceAddress,
62091     pub range: DeviceSize,
62092     pub format: Format,
62093 }
62094 impl ::std::default::Default for DescriptorAddressInfoEXT {
62095     #[inline]
default() -> Self62096     fn default() -> Self {
62097         Self {
62098             s_type: Self::STRUCTURE_TYPE,
62099             p_next: ::std::ptr::null_mut(),
62100             address: DeviceAddress::default(),
62101             range: DeviceSize::default(),
62102             format: Format::default(),
62103         }
62104     }
62105 }
62106 unsafe impl TaggedStructure for DescriptorAddressInfoEXT {
62107     const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_ADDRESS_INFO_EXT;
62108 }
62109 impl DescriptorAddressInfoEXT {
builder<'a>() -> DescriptorAddressInfoEXTBuilder<'a>62110     pub fn builder<'a>() -> DescriptorAddressInfoEXTBuilder<'a> {
62111         DescriptorAddressInfoEXTBuilder {
62112             inner: Self::default(),
62113             marker: ::std::marker::PhantomData,
62114         }
62115     }
62116 }
62117 #[repr(transparent)]
62118 pub struct DescriptorAddressInfoEXTBuilder<'a> {
62119     inner: DescriptorAddressInfoEXT,
62120     marker: ::std::marker::PhantomData<&'a ()>,
62121 }
62122 impl<'a> ::std::ops::Deref for DescriptorAddressInfoEXTBuilder<'a> {
62123     type Target = DescriptorAddressInfoEXT;
deref(&self) -> &Self::Target62124     fn deref(&self) -> &Self::Target {
62125         &self.inner
62126     }
62127 }
62128 impl<'a> ::std::ops::DerefMut for DescriptorAddressInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target62129     fn deref_mut(&mut self) -> &mut Self::Target {
62130         &mut self.inner
62131     }
62132 }
62133 impl<'a> DescriptorAddressInfoEXTBuilder<'a> {
62134     #[inline]
address(mut self, address: DeviceAddress) -> Self62135     pub fn address(mut self, address: DeviceAddress) -> Self {
62136         self.inner.address = address;
62137         self
62138     }
62139     #[inline]
range(mut self, range: DeviceSize) -> Self62140     pub fn range(mut self, range: DeviceSize) -> Self {
62141         self.inner.range = range;
62142         self
62143     }
62144     #[inline]
format(mut self, format: Format) -> Self62145     pub fn format(mut self, format: Format) -> Self {
62146         self.inner.format = format;
62147         self
62148     }
62149     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
62150     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
62151     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorAddressInfoEXT62152     pub fn build(self) -> DescriptorAddressInfoEXT {
62153         self.inner
62154     }
62155 }
62156 #[repr(C)]
62157 #[cfg_attr(feature = "debug", derive(Debug))]
62158 #[derive(Copy, Clone)]
62159 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorBufferBindingInfoEXT.html>"]
62160 pub struct DescriptorBufferBindingInfoEXT {
62161     pub s_type: StructureType,
62162     pub p_next: *mut c_void,
62163     pub address: DeviceAddress,
62164     pub usage: BufferUsageFlags,
62165 }
62166 impl ::std::default::Default for DescriptorBufferBindingInfoEXT {
62167     #[inline]
default() -> Self62168     fn default() -> Self {
62169         Self {
62170             s_type: Self::STRUCTURE_TYPE,
62171             p_next: ::std::ptr::null_mut(),
62172             address: DeviceAddress::default(),
62173             usage: BufferUsageFlags::default(),
62174         }
62175     }
62176 }
62177 unsafe impl TaggedStructure for DescriptorBufferBindingInfoEXT {
62178     const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_BUFFER_BINDING_INFO_EXT;
62179 }
62180 impl DescriptorBufferBindingInfoEXT {
builder<'a>() -> DescriptorBufferBindingInfoEXTBuilder<'a>62181     pub fn builder<'a>() -> DescriptorBufferBindingInfoEXTBuilder<'a> {
62182         DescriptorBufferBindingInfoEXTBuilder {
62183             inner: Self::default(),
62184             marker: ::std::marker::PhantomData,
62185         }
62186     }
62187 }
62188 #[repr(transparent)]
62189 pub struct DescriptorBufferBindingInfoEXTBuilder<'a> {
62190     inner: DescriptorBufferBindingInfoEXT,
62191     marker: ::std::marker::PhantomData<&'a ()>,
62192 }
62193 pub unsafe trait ExtendsDescriptorBufferBindingInfoEXT {}
62194 impl<'a> ::std::ops::Deref for DescriptorBufferBindingInfoEXTBuilder<'a> {
62195     type Target = DescriptorBufferBindingInfoEXT;
deref(&self) -> &Self::Target62196     fn deref(&self) -> &Self::Target {
62197         &self.inner
62198     }
62199 }
62200 impl<'a> ::std::ops::DerefMut for DescriptorBufferBindingInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target62201     fn deref_mut(&mut self) -> &mut Self::Target {
62202         &mut self.inner
62203     }
62204 }
62205 impl<'a> DescriptorBufferBindingInfoEXTBuilder<'a> {
62206     #[inline]
address(mut self, address: DeviceAddress) -> Self62207     pub fn address(mut self, address: DeviceAddress) -> Self {
62208         self.inner.address = address;
62209         self
62210     }
62211     #[inline]
usage(mut self, usage: BufferUsageFlags) -> Self62212     pub fn usage(mut self, usage: BufferUsageFlags) -> Self {
62213         self.inner.usage = usage;
62214         self
62215     }
62216     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
62217     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
62218     #[doc = r" valid extension structs can be pushed into the chain."]
62219     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
62220     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDescriptorBufferBindingInfoEXT>(mut self, next: &'a mut T) -> Self62221     pub fn push_next<T: ExtendsDescriptorBufferBindingInfoEXT>(mut self, next: &'a mut T) -> Self {
62222         unsafe {
62223             let next_ptr = <*mut T>::cast(next);
62224             let last_next = ptr_chain_iter(next).last().unwrap();
62225             (*last_next).p_next = self.inner.p_next as _;
62226             self.inner.p_next = next_ptr;
62227         }
62228         self
62229     }
62230     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
62231     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
62232     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorBufferBindingInfoEXT62233     pub fn build(self) -> DescriptorBufferBindingInfoEXT {
62234         self.inner
62235     }
62236 }
62237 #[repr(C)]
62238 #[cfg_attr(feature = "debug", derive(Debug))]
62239 #[derive(Copy, Clone)]
62240 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorBufferBindingPushDescriptorBufferHandleEXT.html>"]
62241 pub struct DescriptorBufferBindingPushDescriptorBufferHandleEXT {
62242     pub s_type: StructureType,
62243     pub p_next: *mut c_void,
62244     pub buffer: Buffer,
62245 }
62246 impl ::std::default::Default for DescriptorBufferBindingPushDescriptorBufferHandleEXT {
62247     #[inline]
default() -> Self62248     fn default() -> Self {
62249         Self {
62250             s_type: Self::STRUCTURE_TYPE,
62251             p_next: ::std::ptr::null_mut(),
62252             buffer: Buffer::default(),
62253         }
62254     }
62255 }
62256 unsafe impl TaggedStructure for DescriptorBufferBindingPushDescriptorBufferHandleEXT {
62257     const STRUCTURE_TYPE: StructureType =
62258         StructureType::DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT;
62259 }
62260 impl DescriptorBufferBindingPushDescriptorBufferHandleEXT {
builder<'a>() -> DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<'a>62261     pub fn builder<'a>() -> DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<'a> {
62262         DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder {
62263             inner: Self::default(),
62264             marker: ::std::marker::PhantomData,
62265         }
62266     }
62267 }
62268 #[repr(transparent)]
62269 pub struct DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<'a> {
62270     inner: DescriptorBufferBindingPushDescriptorBufferHandleEXT,
62271     marker: ::std::marker::PhantomData<&'a ()>,
62272 }
62273 unsafe impl ExtendsDescriptorBufferBindingInfoEXT
62274     for DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<'_>
62275 {
62276 }
62277 unsafe impl ExtendsDescriptorBufferBindingInfoEXT
62278     for DescriptorBufferBindingPushDescriptorBufferHandleEXT
62279 {
62280 }
62281 impl<'a> ::std::ops::Deref for DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<'a> {
62282     type Target = DescriptorBufferBindingPushDescriptorBufferHandleEXT;
deref(&self) -> &Self::Target62283     fn deref(&self) -> &Self::Target {
62284         &self.inner
62285     }
62286 }
62287 impl<'a> ::std::ops::DerefMut for DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target62288     fn deref_mut(&mut self) -> &mut Self::Target {
62289         &mut self.inner
62290     }
62291 }
62292 impl<'a> DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<'a> {
62293     #[inline]
buffer(mut self, buffer: Buffer) -> Self62294     pub fn buffer(mut self, buffer: Buffer) -> Self {
62295         self.inner.buffer = buffer;
62296         self
62297     }
62298     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
62299     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
62300     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorBufferBindingPushDescriptorBufferHandleEXT62301     pub fn build(self) -> DescriptorBufferBindingPushDescriptorBufferHandleEXT {
62302         self.inner
62303     }
62304 }
62305 #[repr(C)]
62306 #[derive(Copy, Clone)]
62307 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorDataEXT.html>"]
62308 pub union DescriptorDataEXT {
62309     pub p_sampler: *const Sampler,
62310     pub p_combined_image_sampler: *const DescriptorImageInfo,
62311     pub p_input_attachment_image: *const DescriptorImageInfo,
62312     pub p_sampled_image: *const DescriptorImageInfo,
62313     pub p_storage_image: *const DescriptorImageInfo,
62314     pub p_uniform_texel_buffer: *const DescriptorAddressInfoEXT,
62315     pub p_storage_texel_buffer: *const DescriptorAddressInfoEXT,
62316     pub p_uniform_buffer: *const DescriptorAddressInfoEXT,
62317     pub p_storage_buffer: *const DescriptorAddressInfoEXT,
62318     pub acceleration_structure: DeviceAddress,
62319 }
62320 impl ::std::default::Default for DescriptorDataEXT {
62321     #[inline]
default() -> Self62322     fn default() -> Self {
62323         unsafe { ::std::mem::zeroed() }
62324     }
62325 }
62326 #[repr(C)]
62327 #[derive(Copy, Clone)]
62328 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorGetInfoEXT.html>"]
62329 pub struct DescriptorGetInfoEXT {
62330     pub s_type: StructureType,
62331     pub p_next: *const c_void,
62332     pub ty: DescriptorType,
62333     pub data: DescriptorDataEXT,
62334 }
62335 #[cfg(feature = "debug")]
62336 impl fmt::Debug for DescriptorGetInfoEXT {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result62337     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
62338         fmt.debug_struct("DescriptorGetInfoEXT")
62339             .field("s_type", &self.s_type)
62340             .field("p_next", &self.p_next)
62341             .field("ty", &self.ty)
62342             .field("data", &"union")
62343             .finish()
62344     }
62345 }
62346 impl ::std::default::Default for DescriptorGetInfoEXT {
62347     #[inline]
default() -> Self62348     fn default() -> Self {
62349         Self {
62350             s_type: Self::STRUCTURE_TYPE,
62351             p_next: ::std::ptr::null(),
62352             ty: DescriptorType::default(),
62353             data: DescriptorDataEXT::default(),
62354         }
62355     }
62356 }
62357 unsafe impl TaggedStructure for DescriptorGetInfoEXT {
62358     const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_GET_INFO_EXT;
62359 }
62360 impl DescriptorGetInfoEXT {
builder<'a>() -> DescriptorGetInfoEXTBuilder<'a>62361     pub fn builder<'a>() -> DescriptorGetInfoEXTBuilder<'a> {
62362         DescriptorGetInfoEXTBuilder {
62363             inner: Self::default(),
62364             marker: ::std::marker::PhantomData,
62365         }
62366     }
62367 }
62368 #[repr(transparent)]
62369 pub struct DescriptorGetInfoEXTBuilder<'a> {
62370     inner: DescriptorGetInfoEXT,
62371     marker: ::std::marker::PhantomData<&'a ()>,
62372 }
62373 impl<'a> ::std::ops::Deref for DescriptorGetInfoEXTBuilder<'a> {
62374     type Target = DescriptorGetInfoEXT;
deref(&self) -> &Self::Target62375     fn deref(&self) -> &Self::Target {
62376         &self.inner
62377     }
62378 }
62379 impl<'a> ::std::ops::DerefMut for DescriptorGetInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target62380     fn deref_mut(&mut self) -> &mut Self::Target {
62381         &mut self.inner
62382     }
62383 }
62384 impl<'a> DescriptorGetInfoEXTBuilder<'a> {
62385     #[inline]
ty(mut self, ty: DescriptorType) -> Self62386     pub fn ty(mut self, ty: DescriptorType) -> Self {
62387         self.inner.ty = ty;
62388         self
62389     }
62390     #[inline]
data(mut self, data: DescriptorDataEXT) -> Self62391     pub fn data(mut self, data: DescriptorDataEXT) -> Self {
62392         self.inner.data = data;
62393         self
62394     }
62395     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
62396     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
62397     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorGetInfoEXT62398     pub fn build(self) -> DescriptorGetInfoEXT {
62399         self.inner
62400     }
62401 }
62402 #[repr(C)]
62403 #[cfg_attr(feature = "debug", derive(Debug))]
62404 #[derive(Copy, Clone)]
62405 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCaptureDescriptorDataInfoEXT.html>"]
62406 pub struct BufferCaptureDescriptorDataInfoEXT {
62407     pub s_type: StructureType,
62408     pub p_next: *const c_void,
62409     pub buffer: Buffer,
62410 }
62411 impl ::std::default::Default for BufferCaptureDescriptorDataInfoEXT {
62412     #[inline]
default() -> Self62413     fn default() -> Self {
62414         Self {
62415             s_type: Self::STRUCTURE_TYPE,
62416             p_next: ::std::ptr::null(),
62417             buffer: Buffer::default(),
62418         }
62419     }
62420 }
62421 unsafe impl TaggedStructure for BufferCaptureDescriptorDataInfoEXT {
62422     const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT;
62423 }
62424 impl BufferCaptureDescriptorDataInfoEXT {
builder<'a>() -> BufferCaptureDescriptorDataInfoEXTBuilder<'a>62425     pub fn builder<'a>() -> BufferCaptureDescriptorDataInfoEXTBuilder<'a> {
62426         BufferCaptureDescriptorDataInfoEXTBuilder {
62427             inner: Self::default(),
62428             marker: ::std::marker::PhantomData,
62429         }
62430     }
62431 }
62432 #[repr(transparent)]
62433 pub struct BufferCaptureDescriptorDataInfoEXTBuilder<'a> {
62434     inner: BufferCaptureDescriptorDataInfoEXT,
62435     marker: ::std::marker::PhantomData<&'a ()>,
62436 }
62437 impl<'a> ::std::ops::Deref for BufferCaptureDescriptorDataInfoEXTBuilder<'a> {
62438     type Target = BufferCaptureDescriptorDataInfoEXT;
deref(&self) -> &Self::Target62439     fn deref(&self) -> &Self::Target {
62440         &self.inner
62441     }
62442 }
62443 impl<'a> ::std::ops::DerefMut for BufferCaptureDescriptorDataInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target62444     fn deref_mut(&mut self) -> &mut Self::Target {
62445         &mut self.inner
62446     }
62447 }
62448 impl<'a> BufferCaptureDescriptorDataInfoEXTBuilder<'a> {
62449     #[inline]
buffer(mut self, buffer: Buffer) -> Self62450     pub fn buffer(mut self, buffer: Buffer) -> Self {
62451         self.inner.buffer = buffer;
62452         self
62453     }
62454     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
62455     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
62456     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferCaptureDescriptorDataInfoEXT62457     pub fn build(self) -> BufferCaptureDescriptorDataInfoEXT {
62458         self.inner
62459     }
62460 }
62461 #[repr(C)]
62462 #[cfg_attr(feature = "debug", derive(Debug))]
62463 #[derive(Copy, Clone)]
62464 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCaptureDescriptorDataInfoEXT.html>"]
62465 pub struct ImageCaptureDescriptorDataInfoEXT {
62466     pub s_type: StructureType,
62467     pub p_next: *const c_void,
62468     pub image: Image,
62469 }
62470 impl ::std::default::Default for ImageCaptureDescriptorDataInfoEXT {
62471     #[inline]
default() -> Self62472     fn default() -> Self {
62473         Self {
62474             s_type: Self::STRUCTURE_TYPE,
62475             p_next: ::std::ptr::null(),
62476             image: Image::default(),
62477         }
62478     }
62479 }
62480 unsafe impl TaggedStructure for ImageCaptureDescriptorDataInfoEXT {
62481     const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT;
62482 }
62483 impl ImageCaptureDescriptorDataInfoEXT {
builder<'a>() -> ImageCaptureDescriptorDataInfoEXTBuilder<'a>62484     pub fn builder<'a>() -> ImageCaptureDescriptorDataInfoEXTBuilder<'a> {
62485         ImageCaptureDescriptorDataInfoEXTBuilder {
62486             inner: Self::default(),
62487             marker: ::std::marker::PhantomData,
62488         }
62489     }
62490 }
62491 #[repr(transparent)]
62492 pub struct ImageCaptureDescriptorDataInfoEXTBuilder<'a> {
62493     inner: ImageCaptureDescriptorDataInfoEXT,
62494     marker: ::std::marker::PhantomData<&'a ()>,
62495 }
62496 impl<'a> ::std::ops::Deref for ImageCaptureDescriptorDataInfoEXTBuilder<'a> {
62497     type Target = ImageCaptureDescriptorDataInfoEXT;
deref(&self) -> &Self::Target62498     fn deref(&self) -> &Self::Target {
62499         &self.inner
62500     }
62501 }
62502 impl<'a> ::std::ops::DerefMut for ImageCaptureDescriptorDataInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target62503     fn deref_mut(&mut self) -> &mut Self::Target {
62504         &mut self.inner
62505     }
62506 }
62507 impl<'a> ImageCaptureDescriptorDataInfoEXTBuilder<'a> {
62508     #[inline]
image(mut self, image: Image) -> Self62509     pub fn image(mut self, image: Image) -> Self {
62510         self.inner.image = image;
62511         self
62512     }
62513     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
62514     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
62515     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageCaptureDescriptorDataInfoEXT62516     pub fn build(self) -> ImageCaptureDescriptorDataInfoEXT {
62517         self.inner
62518     }
62519 }
62520 #[repr(C)]
62521 #[cfg_attr(feature = "debug", derive(Debug))]
62522 #[derive(Copy, Clone)]
62523 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewCaptureDescriptorDataInfoEXT.html>"]
62524 pub struct ImageViewCaptureDescriptorDataInfoEXT {
62525     pub s_type: StructureType,
62526     pub p_next: *const c_void,
62527     pub image_view: ImageView,
62528 }
62529 impl ::std::default::Default for ImageViewCaptureDescriptorDataInfoEXT {
62530     #[inline]
default() -> Self62531     fn default() -> Self {
62532         Self {
62533             s_type: Self::STRUCTURE_TYPE,
62534             p_next: ::std::ptr::null(),
62535             image_view: ImageView::default(),
62536         }
62537     }
62538 }
62539 unsafe impl TaggedStructure for ImageViewCaptureDescriptorDataInfoEXT {
62540     const STRUCTURE_TYPE: StructureType =
62541         StructureType::IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT;
62542 }
62543 impl ImageViewCaptureDescriptorDataInfoEXT {
builder<'a>() -> ImageViewCaptureDescriptorDataInfoEXTBuilder<'a>62544     pub fn builder<'a>() -> ImageViewCaptureDescriptorDataInfoEXTBuilder<'a> {
62545         ImageViewCaptureDescriptorDataInfoEXTBuilder {
62546             inner: Self::default(),
62547             marker: ::std::marker::PhantomData,
62548         }
62549     }
62550 }
62551 #[repr(transparent)]
62552 pub struct ImageViewCaptureDescriptorDataInfoEXTBuilder<'a> {
62553     inner: ImageViewCaptureDescriptorDataInfoEXT,
62554     marker: ::std::marker::PhantomData<&'a ()>,
62555 }
62556 impl<'a> ::std::ops::Deref for ImageViewCaptureDescriptorDataInfoEXTBuilder<'a> {
62557     type Target = ImageViewCaptureDescriptorDataInfoEXT;
deref(&self) -> &Self::Target62558     fn deref(&self) -> &Self::Target {
62559         &self.inner
62560     }
62561 }
62562 impl<'a> ::std::ops::DerefMut for ImageViewCaptureDescriptorDataInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target62563     fn deref_mut(&mut self) -> &mut Self::Target {
62564         &mut self.inner
62565     }
62566 }
62567 impl<'a> ImageViewCaptureDescriptorDataInfoEXTBuilder<'a> {
62568     #[inline]
image_view(mut self, image_view: ImageView) -> Self62569     pub fn image_view(mut self, image_view: ImageView) -> Self {
62570         self.inner.image_view = image_view;
62571         self
62572     }
62573     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
62574     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
62575     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageViewCaptureDescriptorDataInfoEXT62576     pub fn build(self) -> ImageViewCaptureDescriptorDataInfoEXT {
62577         self.inner
62578     }
62579 }
62580 #[repr(C)]
62581 #[cfg_attr(feature = "debug", derive(Debug))]
62582 #[derive(Copy, Clone)]
62583 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerCaptureDescriptorDataInfoEXT.html>"]
62584 pub struct SamplerCaptureDescriptorDataInfoEXT {
62585     pub s_type: StructureType,
62586     pub p_next: *const c_void,
62587     pub sampler: Sampler,
62588 }
62589 impl ::std::default::Default for SamplerCaptureDescriptorDataInfoEXT {
62590     #[inline]
default() -> Self62591     fn default() -> Self {
62592         Self {
62593             s_type: Self::STRUCTURE_TYPE,
62594             p_next: ::std::ptr::null(),
62595             sampler: Sampler::default(),
62596         }
62597     }
62598 }
62599 unsafe impl TaggedStructure for SamplerCaptureDescriptorDataInfoEXT {
62600     const STRUCTURE_TYPE: StructureType = StructureType::SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT;
62601 }
62602 impl SamplerCaptureDescriptorDataInfoEXT {
builder<'a>() -> SamplerCaptureDescriptorDataInfoEXTBuilder<'a>62603     pub fn builder<'a>() -> SamplerCaptureDescriptorDataInfoEXTBuilder<'a> {
62604         SamplerCaptureDescriptorDataInfoEXTBuilder {
62605             inner: Self::default(),
62606             marker: ::std::marker::PhantomData,
62607         }
62608     }
62609 }
62610 #[repr(transparent)]
62611 pub struct SamplerCaptureDescriptorDataInfoEXTBuilder<'a> {
62612     inner: SamplerCaptureDescriptorDataInfoEXT,
62613     marker: ::std::marker::PhantomData<&'a ()>,
62614 }
62615 impl<'a> ::std::ops::Deref for SamplerCaptureDescriptorDataInfoEXTBuilder<'a> {
62616     type Target = SamplerCaptureDescriptorDataInfoEXT;
deref(&self) -> &Self::Target62617     fn deref(&self) -> &Self::Target {
62618         &self.inner
62619     }
62620 }
62621 impl<'a> ::std::ops::DerefMut for SamplerCaptureDescriptorDataInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target62622     fn deref_mut(&mut self) -> &mut Self::Target {
62623         &mut self.inner
62624     }
62625 }
62626 impl<'a> SamplerCaptureDescriptorDataInfoEXTBuilder<'a> {
62627     #[inline]
sampler(mut self, sampler: Sampler) -> Self62628     pub fn sampler(mut self, sampler: Sampler) -> Self {
62629         self.inner.sampler = sampler;
62630         self
62631     }
62632     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
62633     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
62634     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SamplerCaptureDescriptorDataInfoEXT62635     pub fn build(self) -> SamplerCaptureDescriptorDataInfoEXT {
62636         self.inner
62637     }
62638 }
62639 #[repr(C)]
62640 #[cfg_attr(feature = "debug", derive(Debug))]
62641 #[derive(Copy, Clone)]
62642 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureCaptureDescriptorDataInfoEXT.html>"]
62643 pub struct AccelerationStructureCaptureDescriptorDataInfoEXT {
62644     pub s_type: StructureType,
62645     pub p_next: *const c_void,
62646     pub acceleration_structure: AccelerationStructureKHR,
62647     pub acceleration_structure_nv: AccelerationStructureNV,
62648 }
62649 impl ::std::default::Default for AccelerationStructureCaptureDescriptorDataInfoEXT {
62650     #[inline]
default() -> Self62651     fn default() -> Self {
62652         Self {
62653             s_type: Self::STRUCTURE_TYPE,
62654             p_next: ::std::ptr::null(),
62655             acceleration_structure: AccelerationStructureKHR::default(),
62656             acceleration_structure_nv: AccelerationStructureNV::default(),
62657         }
62658     }
62659 }
62660 unsafe impl TaggedStructure for AccelerationStructureCaptureDescriptorDataInfoEXT {
62661     const STRUCTURE_TYPE: StructureType =
62662         StructureType::ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT;
62663 }
62664 impl AccelerationStructureCaptureDescriptorDataInfoEXT {
builder<'a>() -> AccelerationStructureCaptureDescriptorDataInfoEXTBuilder<'a>62665     pub fn builder<'a>() -> AccelerationStructureCaptureDescriptorDataInfoEXTBuilder<'a> {
62666         AccelerationStructureCaptureDescriptorDataInfoEXTBuilder {
62667             inner: Self::default(),
62668             marker: ::std::marker::PhantomData,
62669         }
62670     }
62671 }
62672 #[repr(transparent)]
62673 pub struct AccelerationStructureCaptureDescriptorDataInfoEXTBuilder<'a> {
62674     inner: AccelerationStructureCaptureDescriptorDataInfoEXT,
62675     marker: ::std::marker::PhantomData<&'a ()>,
62676 }
62677 impl<'a> ::std::ops::Deref for AccelerationStructureCaptureDescriptorDataInfoEXTBuilder<'a> {
62678     type Target = AccelerationStructureCaptureDescriptorDataInfoEXT;
deref(&self) -> &Self::Target62679     fn deref(&self) -> &Self::Target {
62680         &self.inner
62681     }
62682 }
62683 impl<'a> ::std::ops::DerefMut for AccelerationStructureCaptureDescriptorDataInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target62684     fn deref_mut(&mut self) -> &mut Self::Target {
62685         &mut self.inner
62686     }
62687 }
62688 impl<'a> AccelerationStructureCaptureDescriptorDataInfoEXTBuilder<'a> {
62689     #[inline]
acceleration_structure( mut self, acceleration_structure: AccelerationStructureKHR, ) -> Self62690     pub fn acceleration_structure(
62691         mut self,
62692         acceleration_structure: AccelerationStructureKHR,
62693     ) -> Self {
62694         self.inner.acceleration_structure = acceleration_structure;
62695         self
62696     }
62697     #[inline]
acceleration_structure_nv( mut self, acceleration_structure_nv: AccelerationStructureNV, ) -> Self62698     pub fn acceleration_structure_nv(
62699         mut self,
62700         acceleration_structure_nv: AccelerationStructureNV,
62701     ) -> Self {
62702         self.inner.acceleration_structure_nv = acceleration_structure_nv;
62703         self
62704     }
62705     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
62706     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
62707     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureCaptureDescriptorDataInfoEXT62708     pub fn build(self) -> AccelerationStructureCaptureDescriptorDataInfoEXT {
62709         self.inner
62710     }
62711 }
62712 #[repr(C)]
62713 #[cfg_attr(feature = "debug", derive(Debug))]
62714 #[derive(Copy, Clone)]
62715 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpaqueCaptureDescriptorDataCreateInfoEXT.html>"]
62716 pub struct OpaqueCaptureDescriptorDataCreateInfoEXT {
62717     pub s_type: StructureType,
62718     pub p_next: *const c_void,
62719     pub opaque_capture_descriptor_data: *const c_void,
62720 }
62721 impl ::std::default::Default for OpaqueCaptureDescriptorDataCreateInfoEXT {
62722     #[inline]
default() -> Self62723     fn default() -> Self {
62724         Self {
62725             s_type: Self::STRUCTURE_TYPE,
62726             p_next: ::std::ptr::null(),
62727             opaque_capture_descriptor_data: ::std::ptr::null(),
62728         }
62729     }
62730 }
62731 unsafe impl TaggedStructure for OpaqueCaptureDescriptorDataCreateInfoEXT {
62732     const STRUCTURE_TYPE: StructureType =
62733         StructureType::OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
62734 }
62735 impl OpaqueCaptureDescriptorDataCreateInfoEXT {
builder<'a>() -> OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'a>62736     pub fn builder<'a>() -> OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'a> {
62737         OpaqueCaptureDescriptorDataCreateInfoEXTBuilder {
62738             inner: Self::default(),
62739             marker: ::std::marker::PhantomData,
62740         }
62741     }
62742 }
62743 #[repr(transparent)]
62744 pub struct OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'a> {
62745     inner: OpaqueCaptureDescriptorDataCreateInfoEXT,
62746     marker: ::std::marker::PhantomData<&'a ()>,
62747 }
62748 unsafe impl ExtendsBufferCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'_> {}
62749 unsafe impl ExtendsBufferCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXT {}
62750 unsafe impl ExtendsImageCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'_> {}
62751 unsafe impl ExtendsImageCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXT {}
62752 unsafe impl ExtendsImageViewCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'_> {}
62753 unsafe impl ExtendsImageViewCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXT {}
62754 unsafe impl ExtendsSamplerCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'_> {}
62755 unsafe impl ExtendsSamplerCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXT {}
62756 unsafe impl ExtendsAccelerationStructureCreateInfoKHR
62757     for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'_>
62758 {
62759 }
62760 unsafe impl ExtendsAccelerationStructureCreateInfoKHR for OpaqueCaptureDescriptorDataCreateInfoEXT {}
62761 unsafe impl ExtendsAccelerationStructureCreateInfoNV
62762     for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'_>
62763 {
62764 }
62765 unsafe impl ExtendsAccelerationStructureCreateInfoNV for OpaqueCaptureDescriptorDataCreateInfoEXT {}
62766 impl<'a> ::std::ops::Deref for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'a> {
62767     type Target = OpaqueCaptureDescriptorDataCreateInfoEXT;
deref(&self) -> &Self::Target62768     fn deref(&self) -> &Self::Target {
62769         &self.inner
62770     }
62771 }
62772 impl<'a> ::std::ops::DerefMut for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target62773     fn deref_mut(&mut self) -> &mut Self::Target {
62774         &mut self.inner
62775     }
62776 }
62777 impl<'a> OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'a> {
62778     #[inline]
opaque_capture_descriptor_data( mut self, opaque_capture_descriptor_data: *const c_void, ) -> Self62779     pub fn opaque_capture_descriptor_data(
62780         mut self,
62781         opaque_capture_descriptor_data: *const c_void,
62782     ) -> Self {
62783         self.inner.opaque_capture_descriptor_data = opaque_capture_descriptor_data;
62784         self
62785     }
62786     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
62787     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
62788     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> OpaqueCaptureDescriptorDataCreateInfoEXT62789     pub fn build(self) -> OpaqueCaptureDescriptorDataCreateInfoEXT {
62790         self.inner
62791     }
62792 }
62793 #[repr(C)]
62794 #[cfg_attr(feature = "debug", derive(Debug))]
62795 #[derive(Copy, Clone)]
62796 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderIntegerDotProductFeatures.html>"]
62797 pub struct PhysicalDeviceShaderIntegerDotProductFeatures {
62798     pub s_type: StructureType,
62799     pub p_next: *mut c_void,
62800     pub shader_integer_dot_product: Bool32,
62801 }
62802 impl ::std::default::Default for PhysicalDeviceShaderIntegerDotProductFeatures {
62803     #[inline]
default() -> Self62804     fn default() -> Self {
62805         Self {
62806             s_type: Self::STRUCTURE_TYPE,
62807             p_next: ::std::ptr::null_mut(),
62808             shader_integer_dot_product: Bool32::default(),
62809         }
62810     }
62811 }
62812 unsafe impl TaggedStructure for PhysicalDeviceShaderIntegerDotProductFeatures {
62813     const STRUCTURE_TYPE: StructureType =
62814         StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
62815 }
62816 impl PhysicalDeviceShaderIntegerDotProductFeatures {
builder<'a>() -> PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a>62817     pub fn builder<'a>() -> PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> {
62818         PhysicalDeviceShaderIntegerDotProductFeaturesBuilder {
62819             inner: Self::default(),
62820             marker: ::std::marker::PhantomData,
62821         }
62822     }
62823 }
62824 #[repr(transparent)]
62825 pub struct PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> {
62826     inner: PhysicalDeviceShaderIntegerDotProductFeatures,
62827     marker: ::std::marker::PhantomData<&'a ()>,
62828 }
62829 unsafe impl ExtendsPhysicalDeviceFeatures2
62830     for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'_>
62831 {
62832 }
62833 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderIntegerDotProductFeatures {}
62834 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'_> {}
62835 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerDotProductFeatures {}
62836 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> {
62837     type Target = PhysicalDeviceShaderIntegerDotProductFeatures;
deref(&self) -> &Self::Target62838     fn deref(&self) -> &Self::Target {
62839         &self.inner
62840     }
62841 }
62842 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target62843     fn deref_mut(&mut self) -> &mut Self::Target {
62844         &mut self.inner
62845     }
62846 }
62847 impl<'a> PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> {
62848     #[inline]
shader_integer_dot_product(mut self, shader_integer_dot_product: bool) -> Self62849     pub fn shader_integer_dot_product(mut self, shader_integer_dot_product: bool) -> Self {
62850         self.inner.shader_integer_dot_product = shader_integer_dot_product.into();
62851         self
62852     }
62853     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
62854     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
62855     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderIntegerDotProductFeatures62856     pub fn build(self) -> PhysicalDeviceShaderIntegerDotProductFeatures {
62857         self.inner
62858     }
62859 }
62860 #[repr(C)]
62861 #[cfg_attr(feature = "debug", derive(Debug))]
62862 #[derive(Copy, Clone)]
62863 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderIntegerDotProductProperties.html>"]
62864 pub struct PhysicalDeviceShaderIntegerDotProductProperties {
62865     pub s_type: StructureType,
62866     pub p_next: *mut c_void,
62867     pub integer_dot_product8_bit_unsigned_accelerated: Bool32,
62868     pub integer_dot_product8_bit_signed_accelerated: Bool32,
62869     pub integer_dot_product8_bit_mixed_signedness_accelerated: Bool32,
62870     pub integer_dot_product4x8_bit_packed_unsigned_accelerated: Bool32,
62871     pub integer_dot_product4x8_bit_packed_signed_accelerated: Bool32,
62872     pub integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: Bool32,
62873     pub integer_dot_product16_bit_unsigned_accelerated: Bool32,
62874     pub integer_dot_product16_bit_signed_accelerated: Bool32,
62875     pub integer_dot_product16_bit_mixed_signedness_accelerated: Bool32,
62876     pub integer_dot_product32_bit_unsigned_accelerated: Bool32,
62877     pub integer_dot_product32_bit_signed_accelerated: Bool32,
62878     pub integer_dot_product32_bit_mixed_signedness_accelerated: Bool32,
62879     pub integer_dot_product64_bit_unsigned_accelerated: Bool32,
62880     pub integer_dot_product64_bit_signed_accelerated: Bool32,
62881     pub integer_dot_product64_bit_mixed_signedness_accelerated: Bool32,
62882     pub integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: Bool32,
62883     pub integer_dot_product_accumulating_saturating8_bit_signed_accelerated: Bool32,
62884     pub integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: Bool32,
62885     pub integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: Bool32,
62886     pub integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: Bool32,
62887     pub integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated:
62888         Bool32,
62889     pub integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: Bool32,
62890     pub integer_dot_product_accumulating_saturating16_bit_signed_accelerated: Bool32,
62891     pub integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: Bool32,
62892     pub integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: Bool32,
62893     pub integer_dot_product_accumulating_saturating32_bit_signed_accelerated: Bool32,
62894     pub integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: Bool32,
62895     pub integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: Bool32,
62896     pub integer_dot_product_accumulating_saturating64_bit_signed_accelerated: Bool32,
62897     pub integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: Bool32,
62898 }
62899 impl ::std::default::Default for PhysicalDeviceShaderIntegerDotProductProperties {
62900     #[inline]
default() -> Self62901     fn default() -> Self {
62902         Self { s_type : Self :: STRUCTURE_TYPE , p_next : :: std :: ptr :: null_mut () , integer_dot_product8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product64_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated : Bool32 :: default () }
62903     }
62904 }
62905 unsafe impl TaggedStructure for PhysicalDeviceShaderIntegerDotProductProperties {
62906     const STRUCTURE_TYPE: StructureType =
62907         StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES;
62908 }
62909 impl PhysicalDeviceShaderIntegerDotProductProperties {
builder<'a>() -> PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a>62910     pub fn builder<'a>() -> PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> {
62911         PhysicalDeviceShaderIntegerDotProductPropertiesBuilder {
62912             inner: Self::default(),
62913             marker: ::std::marker::PhantomData,
62914         }
62915     }
62916 }
62917 #[repr(transparent)]
62918 pub struct PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> {
62919     inner: PhysicalDeviceShaderIntegerDotProductProperties,
62920     marker: ::std::marker::PhantomData<&'a ()>,
62921 }
62922 unsafe impl ExtendsPhysicalDeviceProperties2
62923     for PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'_>
62924 {
62925 }
62926 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderIntegerDotProductProperties {}
62927 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> {
62928     type Target = PhysicalDeviceShaderIntegerDotProductProperties;
deref(&self) -> &Self::Target62929     fn deref(&self) -> &Self::Target {
62930         &self.inner
62931     }
62932 }
62933 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target62934     fn deref_mut(&mut self) -> &mut Self::Target {
62935         &mut self.inner
62936     }
62937 }
62938 impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> {
62939     #[inline]
integer_dot_product8_bit_unsigned_accelerated( mut self, integer_dot_product8_bit_unsigned_accelerated: bool, ) -> Self62940     pub fn integer_dot_product8_bit_unsigned_accelerated(
62941         mut self,
62942         integer_dot_product8_bit_unsigned_accelerated: bool,
62943     ) -> Self {
62944         self.inner.integer_dot_product8_bit_unsigned_accelerated =
62945             integer_dot_product8_bit_unsigned_accelerated.into();
62946         self
62947     }
62948     #[inline]
integer_dot_product8_bit_signed_accelerated( mut self, integer_dot_product8_bit_signed_accelerated: bool, ) -> Self62949     pub fn integer_dot_product8_bit_signed_accelerated(
62950         mut self,
62951         integer_dot_product8_bit_signed_accelerated: bool,
62952     ) -> Self {
62953         self.inner.integer_dot_product8_bit_signed_accelerated =
62954             integer_dot_product8_bit_signed_accelerated.into();
62955         self
62956     }
62957     #[inline]
integer_dot_product8_bit_mixed_signedness_accelerated( mut self, integer_dot_product8_bit_mixed_signedness_accelerated: bool, ) -> Self62958     pub fn integer_dot_product8_bit_mixed_signedness_accelerated(
62959         mut self,
62960         integer_dot_product8_bit_mixed_signedness_accelerated: bool,
62961     ) -> Self {
62962         self.inner
62963             .integer_dot_product8_bit_mixed_signedness_accelerated =
62964             integer_dot_product8_bit_mixed_signedness_accelerated.into();
62965         self
62966     }
62967     #[inline]
integer_dot_product4x8_bit_packed_unsigned_accelerated( mut self, integer_dot_product4x8_bit_packed_unsigned_accelerated: bool, ) -> Self62968     pub fn integer_dot_product4x8_bit_packed_unsigned_accelerated(
62969         mut self,
62970         integer_dot_product4x8_bit_packed_unsigned_accelerated: bool,
62971     ) -> Self {
62972         self.inner
62973             .integer_dot_product4x8_bit_packed_unsigned_accelerated =
62974             integer_dot_product4x8_bit_packed_unsigned_accelerated.into();
62975         self
62976     }
62977     #[inline]
integer_dot_product4x8_bit_packed_signed_accelerated( mut self, integer_dot_product4x8_bit_packed_signed_accelerated: bool, ) -> Self62978     pub fn integer_dot_product4x8_bit_packed_signed_accelerated(
62979         mut self,
62980         integer_dot_product4x8_bit_packed_signed_accelerated: bool,
62981     ) -> Self {
62982         self.inner
62983             .integer_dot_product4x8_bit_packed_signed_accelerated =
62984             integer_dot_product4x8_bit_packed_signed_accelerated.into();
62985         self
62986     }
62987     #[inline]
integer_dot_product4x8_bit_packed_mixed_signedness_accelerated( mut self, integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: bool, ) -> Self62988     pub fn integer_dot_product4x8_bit_packed_mixed_signedness_accelerated(
62989         mut self,
62990         integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: bool,
62991     ) -> Self {
62992         self.inner
62993             .integer_dot_product4x8_bit_packed_mixed_signedness_accelerated =
62994             integer_dot_product4x8_bit_packed_mixed_signedness_accelerated.into();
62995         self
62996     }
62997     #[inline]
integer_dot_product16_bit_unsigned_accelerated( mut self, integer_dot_product16_bit_unsigned_accelerated: bool, ) -> Self62998     pub fn integer_dot_product16_bit_unsigned_accelerated(
62999         mut self,
63000         integer_dot_product16_bit_unsigned_accelerated: bool,
63001     ) -> Self {
63002         self.inner.integer_dot_product16_bit_unsigned_accelerated =
63003             integer_dot_product16_bit_unsigned_accelerated.into();
63004         self
63005     }
63006     #[inline]
integer_dot_product16_bit_signed_accelerated( mut self, integer_dot_product16_bit_signed_accelerated: bool, ) -> Self63007     pub fn integer_dot_product16_bit_signed_accelerated(
63008         mut self,
63009         integer_dot_product16_bit_signed_accelerated: bool,
63010     ) -> Self {
63011         self.inner.integer_dot_product16_bit_signed_accelerated =
63012             integer_dot_product16_bit_signed_accelerated.into();
63013         self
63014     }
63015     #[inline]
integer_dot_product16_bit_mixed_signedness_accelerated( mut self, integer_dot_product16_bit_mixed_signedness_accelerated: bool, ) -> Self63016     pub fn integer_dot_product16_bit_mixed_signedness_accelerated(
63017         mut self,
63018         integer_dot_product16_bit_mixed_signedness_accelerated: bool,
63019     ) -> Self {
63020         self.inner
63021             .integer_dot_product16_bit_mixed_signedness_accelerated =
63022             integer_dot_product16_bit_mixed_signedness_accelerated.into();
63023         self
63024     }
63025     #[inline]
integer_dot_product32_bit_unsigned_accelerated( mut self, integer_dot_product32_bit_unsigned_accelerated: bool, ) -> Self63026     pub fn integer_dot_product32_bit_unsigned_accelerated(
63027         mut self,
63028         integer_dot_product32_bit_unsigned_accelerated: bool,
63029     ) -> Self {
63030         self.inner.integer_dot_product32_bit_unsigned_accelerated =
63031             integer_dot_product32_bit_unsigned_accelerated.into();
63032         self
63033     }
63034     #[inline]
integer_dot_product32_bit_signed_accelerated( mut self, integer_dot_product32_bit_signed_accelerated: bool, ) -> Self63035     pub fn integer_dot_product32_bit_signed_accelerated(
63036         mut self,
63037         integer_dot_product32_bit_signed_accelerated: bool,
63038     ) -> Self {
63039         self.inner.integer_dot_product32_bit_signed_accelerated =
63040             integer_dot_product32_bit_signed_accelerated.into();
63041         self
63042     }
63043     #[inline]
integer_dot_product32_bit_mixed_signedness_accelerated( mut self, integer_dot_product32_bit_mixed_signedness_accelerated: bool, ) -> Self63044     pub fn integer_dot_product32_bit_mixed_signedness_accelerated(
63045         mut self,
63046         integer_dot_product32_bit_mixed_signedness_accelerated: bool,
63047     ) -> Self {
63048         self.inner
63049             .integer_dot_product32_bit_mixed_signedness_accelerated =
63050             integer_dot_product32_bit_mixed_signedness_accelerated.into();
63051         self
63052     }
63053     #[inline]
integer_dot_product64_bit_unsigned_accelerated( mut self, integer_dot_product64_bit_unsigned_accelerated: bool, ) -> Self63054     pub fn integer_dot_product64_bit_unsigned_accelerated(
63055         mut self,
63056         integer_dot_product64_bit_unsigned_accelerated: bool,
63057     ) -> Self {
63058         self.inner.integer_dot_product64_bit_unsigned_accelerated =
63059             integer_dot_product64_bit_unsigned_accelerated.into();
63060         self
63061     }
63062     #[inline]
integer_dot_product64_bit_signed_accelerated( mut self, integer_dot_product64_bit_signed_accelerated: bool, ) -> Self63063     pub fn integer_dot_product64_bit_signed_accelerated(
63064         mut self,
63065         integer_dot_product64_bit_signed_accelerated: bool,
63066     ) -> Self {
63067         self.inner.integer_dot_product64_bit_signed_accelerated =
63068             integer_dot_product64_bit_signed_accelerated.into();
63069         self
63070     }
63071     #[inline]
integer_dot_product64_bit_mixed_signedness_accelerated( mut self, integer_dot_product64_bit_mixed_signedness_accelerated: bool, ) -> Self63072     pub fn integer_dot_product64_bit_mixed_signedness_accelerated(
63073         mut self,
63074         integer_dot_product64_bit_mixed_signedness_accelerated: bool,
63075     ) -> Self {
63076         self.inner
63077             .integer_dot_product64_bit_mixed_signedness_accelerated =
63078             integer_dot_product64_bit_mixed_signedness_accelerated.into();
63079         self
63080     }
63081     #[inline]
integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated( mut self, integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: bool, ) -> Self63082     pub fn integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated(
63083         mut self,
63084         integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: bool,
63085     ) -> Self {
63086         self.inner
63087             .integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated =
63088             integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated.into();
63089         self
63090     }
63091     #[inline]
integer_dot_product_accumulating_saturating8_bit_signed_accelerated( mut self, integer_dot_product_accumulating_saturating8_bit_signed_accelerated: bool, ) -> Self63092     pub fn integer_dot_product_accumulating_saturating8_bit_signed_accelerated(
63093         mut self,
63094         integer_dot_product_accumulating_saturating8_bit_signed_accelerated: bool,
63095     ) -> Self {
63096         self.inner
63097             .integer_dot_product_accumulating_saturating8_bit_signed_accelerated =
63098             integer_dot_product_accumulating_saturating8_bit_signed_accelerated.into();
63099         self
63100     }
63101     #[inline]
integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated( mut self, integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: bool, ) -> Self63102     pub fn integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated(
63103         mut self,
63104         integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: bool,
63105     ) -> Self {
63106         self.inner
63107             .integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated =
63108             integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated.into();
63109         self
63110     }
63111     #[inline]
integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated( mut self, integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: bool, ) -> Self63112     pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated(
63113         mut self,
63114         integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: bool,
63115     ) -> Self {
63116         self.inner
63117             .integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated =
63118             integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated.into();
63119         self
63120     }
63121     #[inline]
integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated( mut self, integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: bool, ) -> Self63122     pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated(
63123         mut self,
63124         integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: bool,
63125     ) -> Self {
63126         self.inner
63127             .integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated =
63128             integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated.into();
63129         self
63130     }
63131     #[inline]
integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated( mut self, integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : bool, ) -> Self63132     pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated(
63133         mut self,
63134         integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : bool,
63135     ) -> Self {
63136         self . inner . integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated . into () ;
63137         self
63138     }
63139     #[inline]
integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated( mut self, integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: bool, ) -> Self63140     pub fn integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated(
63141         mut self,
63142         integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: bool,
63143     ) -> Self {
63144         self.inner
63145             .integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated =
63146             integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated.into();
63147         self
63148     }
63149     #[inline]
integer_dot_product_accumulating_saturating16_bit_signed_accelerated( mut self, integer_dot_product_accumulating_saturating16_bit_signed_accelerated: bool, ) -> Self63150     pub fn integer_dot_product_accumulating_saturating16_bit_signed_accelerated(
63151         mut self,
63152         integer_dot_product_accumulating_saturating16_bit_signed_accelerated: bool,
63153     ) -> Self {
63154         self.inner
63155             .integer_dot_product_accumulating_saturating16_bit_signed_accelerated =
63156             integer_dot_product_accumulating_saturating16_bit_signed_accelerated.into();
63157         self
63158     }
63159     #[inline]
integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated( mut self, integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: bool, ) -> Self63160     pub fn integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated(
63161         mut self,
63162         integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: bool,
63163     ) -> Self {
63164         self.inner
63165             .integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated =
63166             integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated.into();
63167         self
63168     }
63169     #[inline]
integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated( mut self, integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: bool, ) -> Self63170     pub fn integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated(
63171         mut self,
63172         integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: bool,
63173     ) -> Self {
63174         self.inner
63175             .integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated =
63176             integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated.into();
63177         self
63178     }
63179     #[inline]
integer_dot_product_accumulating_saturating32_bit_signed_accelerated( mut self, integer_dot_product_accumulating_saturating32_bit_signed_accelerated: bool, ) -> Self63180     pub fn integer_dot_product_accumulating_saturating32_bit_signed_accelerated(
63181         mut self,
63182         integer_dot_product_accumulating_saturating32_bit_signed_accelerated: bool,
63183     ) -> Self {
63184         self.inner
63185             .integer_dot_product_accumulating_saturating32_bit_signed_accelerated =
63186             integer_dot_product_accumulating_saturating32_bit_signed_accelerated.into();
63187         self
63188     }
63189     #[inline]
integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated( mut self, integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: bool, ) -> Self63190     pub fn integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated(
63191         mut self,
63192         integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: bool,
63193     ) -> Self {
63194         self.inner
63195             .integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated =
63196             integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated.into();
63197         self
63198     }
63199     #[inline]
integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated( mut self, integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: bool, ) -> Self63200     pub fn integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated(
63201         mut self,
63202         integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: bool,
63203     ) -> Self {
63204         self.inner
63205             .integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated =
63206             integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated.into();
63207         self
63208     }
63209     #[inline]
integer_dot_product_accumulating_saturating64_bit_signed_accelerated( mut self, integer_dot_product_accumulating_saturating64_bit_signed_accelerated: bool, ) -> Self63210     pub fn integer_dot_product_accumulating_saturating64_bit_signed_accelerated(
63211         mut self,
63212         integer_dot_product_accumulating_saturating64_bit_signed_accelerated: bool,
63213     ) -> Self {
63214         self.inner
63215             .integer_dot_product_accumulating_saturating64_bit_signed_accelerated =
63216             integer_dot_product_accumulating_saturating64_bit_signed_accelerated.into();
63217         self
63218     }
63219     #[inline]
integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated( mut self, integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: bool, ) -> Self63220     pub fn integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated(
63221         mut self,
63222         integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: bool,
63223     ) -> Self {
63224         self.inner
63225             .integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated =
63226             integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated.into();
63227         self
63228     }
63229     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
63230     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
63231     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderIntegerDotProductProperties63232     pub fn build(self) -> PhysicalDeviceShaderIntegerDotProductProperties {
63233         self.inner
63234     }
63235 }
63236 #[repr(C)]
63237 #[cfg_attr(feature = "debug", derive(Debug))]
63238 #[derive(Copy, Clone)]
63239 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDrmPropertiesEXT.html>"]
63240 pub struct PhysicalDeviceDrmPropertiesEXT {
63241     pub s_type: StructureType,
63242     pub p_next: *mut c_void,
63243     pub has_primary: Bool32,
63244     pub has_render: Bool32,
63245     pub primary_major: i64,
63246     pub primary_minor: i64,
63247     pub render_major: i64,
63248     pub render_minor: i64,
63249 }
63250 impl ::std::default::Default for PhysicalDeviceDrmPropertiesEXT {
63251     #[inline]
default() -> Self63252     fn default() -> Self {
63253         Self {
63254             s_type: Self::STRUCTURE_TYPE,
63255             p_next: ::std::ptr::null_mut(),
63256             has_primary: Bool32::default(),
63257             has_render: Bool32::default(),
63258             primary_major: i64::default(),
63259             primary_minor: i64::default(),
63260             render_major: i64::default(),
63261             render_minor: i64::default(),
63262         }
63263     }
63264 }
63265 unsafe impl TaggedStructure for PhysicalDeviceDrmPropertiesEXT {
63266     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_DRM_PROPERTIES_EXT;
63267 }
63268 impl PhysicalDeviceDrmPropertiesEXT {
builder<'a>() -> PhysicalDeviceDrmPropertiesEXTBuilder<'a>63269     pub fn builder<'a>() -> PhysicalDeviceDrmPropertiesEXTBuilder<'a> {
63270         PhysicalDeviceDrmPropertiesEXTBuilder {
63271             inner: Self::default(),
63272             marker: ::std::marker::PhantomData,
63273         }
63274     }
63275 }
63276 #[repr(transparent)]
63277 pub struct PhysicalDeviceDrmPropertiesEXTBuilder<'a> {
63278     inner: PhysicalDeviceDrmPropertiesEXT,
63279     marker: ::std::marker::PhantomData<&'a ()>,
63280 }
63281 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDrmPropertiesEXTBuilder<'_> {}
63282 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDrmPropertiesEXT {}
63283 impl<'a> ::std::ops::Deref for PhysicalDeviceDrmPropertiesEXTBuilder<'a> {
63284     type Target = PhysicalDeviceDrmPropertiesEXT;
deref(&self) -> &Self::Target63285     fn deref(&self) -> &Self::Target {
63286         &self.inner
63287     }
63288 }
63289 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDrmPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target63290     fn deref_mut(&mut self) -> &mut Self::Target {
63291         &mut self.inner
63292     }
63293 }
63294 impl<'a> PhysicalDeviceDrmPropertiesEXTBuilder<'a> {
63295     #[inline]
has_primary(mut self, has_primary: bool) -> Self63296     pub fn has_primary(mut self, has_primary: bool) -> Self {
63297         self.inner.has_primary = has_primary.into();
63298         self
63299     }
63300     #[inline]
has_render(mut self, has_render: bool) -> Self63301     pub fn has_render(mut self, has_render: bool) -> Self {
63302         self.inner.has_render = has_render.into();
63303         self
63304     }
63305     #[inline]
primary_major(mut self, primary_major: i64) -> Self63306     pub fn primary_major(mut self, primary_major: i64) -> Self {
63307         self.inner.primary_major = primary_major;
63308         self
63309     }
63310     #[inline]
primary_minor(mut self, primary_minor: i64) -> Self63311     pub fn primary_minor(mut self, primary_minor: i64) -> Self {
63312         self.inner.primary_minor = primary_minor;
63313         self
63314     }
63315     #[inline]
render_major(mut self, render_major: i64) -> Self63316     pub fn render_major(mut self, render_major: i64) -> Self {
63317         self.inner.render_major = render_major;
63318         self
63319     }
63320     #[inline]
render_minor(mut self, render_minor: i64) -> Self63321     pub fn render_minor(mut self, render_minor: i64) -> Self {
63322         self.inner.render_minor = render_minor;
63323         self
63324     }
63325     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
63326     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
63327     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDrmPropertiesEXT63328     pub fn build(self) -> PhysicalDeviceDrmPropertiesEXT {
63329         self.inner
63330     }
63331 }
63332 #[repr(C)]
63333 #[cfg_attr(feature = "debug", derive(Debug))]
63334 #[derive(Copy, Clone)]
63335 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR.html>"]
63336 pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesKHR {
63337     pub s_type: StructureType,
63338     pub p_next: *mut c_void,
63339     pub fragment_shader_barycentric: Bool32,
63340 }
63341 impl ::std::default::Default for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR {
63342     #[inline]
default() -> Self63343     fn default() -> Self {
63344         Self {
63345             s_type: Self::STRUCTURE_TYPE,
63346             p_next: ::std::ptr::null_mut(),
63347             fragment_shader_barycentric: Bool32::default(),
63348         }
63349     }
63350 }
63351 unsafe impl TaggedStructure for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR {
63352     const STRUCTURE_TYPE: StructureType =
63353         StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
63354 }
63355 impl PhysicalDeviceFragmentShaderBarycentricFeaturesKHR {
builder<'a>() -> PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a>63356     pub fn builder<'a>() -> PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a> {
63357         PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder {
63358             inner: Self::default(),
63359             marker: ::std::marker::PhantomData,
63360         }
63361     }
63362 }
63363 #[repr(transparent)]
63364 pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a> {
63365     inner: PhysicalDeviceFragmentShaderBarycentricFeaturesKHR,
63366     marker: ::std::marker::PhantomData<&'a ()>,
63367 }
63368 unsafe impl ExtendsPhysicalDeviceFeatures2
63369     for PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'_>
63370 {
63371 }
63372 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR {}
63373 unsafe impl ExtendsDeviceCreateInfo
63374     for PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'_>
63375 {
63376 }
63377 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR {}
63378 impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a> {
63379     type Target = PhysicalDeviceFragmentShaderBarycentricFeaturesKHR;
deref(&self) -> &Self::Target63380     fn deref(&self) -> &Self::Target {
63381         &self.inner
63382     }
63383 }
63384 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target63385     fn deref_mut(&mut self) -> &mut Self::Target {
63386         &mut self.inner
63387     }
63388 }
63389 impl<'a> PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a> {
63390     #[inline]
fragment_shader_barycentric(mut self, fragment_shader_barycentric: bool) -> Self63391     pub fn fragment_shader_barycentric(mut self, fragment_shader_barycentric: bool) -> Self {
63392         self.inner.fragment_shader_barycentric = fragment_shader_barycentric.into();
63393         self
63394     }
63395     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
63396     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
63397     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFragmentShaderBarycentricFeaturesKHR63398     pub fn build(self) -> PhysicalDeviceFragmentShaderBarycentricFeaturesKHR {
63399         self.inner
63400     }
63401 }
63402 #[repr(C)]
63403 #[cfg_attr(feature = "debug", derive(Debug))]
63404 #[derive(Copy, Clone)]
63405 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR.html>"]
63406 pub struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHR {
63407     pub s_type: StructureType,
63408     pub p_next: *mut c_void,
63409     pub tri_strip_vertex_order_independent_of_provoking_vertex: Bool32,
63410 }
63411 impl ::std::default::Default for PhysicalDeviceFragmentShaderBarycentricPropertiesKHR {
63412     #[inline]
default() -> Self63413     fn default() -> Self {
63414         Self {
63415             s_type: Self::STRUCTURE_TYPE,
63416             p_next: ::std::ptr::null_mut(),
63417             tri_strip_vertex_order_independent_of_provoking_vertex: Bool32::default(),
63418         }
63419     }
63420 }
63421 unsafe impl TaggedStructure for PhysicalDeviceFragmentShaderBarycentricPropertiesKHR {
63422     const STRUCTURE_TYPE: StructureType =
63423         StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR;
63424 }
63425 impl PhysicalDeviceFragmentShaderBarycentricPropertiesKHR {
builder<'a>() -> PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a>63426     pub fn builder<'a>() -> PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a> {
63427         PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder {
63428             inner: Self::default(),
63429             marker: ::std::marker::PhantomData,
63430         }
63431     }
63432 }
63433 #[repr(transparent)]
63434 pub struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a> {
63435     inner: PhysicalDeviceFragmentShaderBarycentricPropertiesKHR,
63436     marker: ::std::marker::PhantomData<&'a ()>,
63437 }
63438 unsafe impl ExtendsPhysicalDeviceProperties2
63439     for PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'_>
63440 {
63441 }
63442 unsafe impl ExtendsPhysicalDeviceProperties2
63443     for PhysicalDeviceFragmentShaderBarycentricPropertiesKHR
63444 {
63445 }
63446 impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a> {
63447     type Target = PhysicalDeviceFragmentShaderBarycentricPropertiesKHR;
deref(&self) -> &Self::Target63448     fn deref(&self) -> &Self::Target {
63449         &self.inner
63450     }
63451 }
63452 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target63453     fn deref_mut(&mut self) -> &mut Self::Target {
63454         &mut self.inner
63455     }
63456 }
63457 impl<'a> PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a> {
63458     #[inline]
tri_strip_vertex_order_independent_of_provoking_vertex( mut self, tri_strip_vertex_order_independent_of_provoking_vertex: bool, ) -> Self63459     pub fn tri_strip_vertex_order_independent_of_provoking_vertex(
63460         mut self,
63461         tri_strip_vertex_order_independent_of_provoking_vertex: bool,
63462     ) -> Self {
63463         self.inner
63464             .tri_strip_vertex_order_independent_of_provoking_vertex =
63465             tri_strip_vertex_order_independent_of_provoking_vertex.into();
63466         self
63467     }
63468     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
63469     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
63470     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFragmentShaderBarycentricPropertiesKHR63471     pub fn build(self) -> PhysicalDeviceFragmentShaderBarycentricPropertiesKHR {
63472         self.inner
63473     }
63474 }
63475 #[repr(C)]
63476 #[cfg_attr(feature = "debug", derive(Debug))]
63477 #[derive(Copy, Clone)]
63478 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingMotionBlurFeaturesNV.html>"]
63479 pub struct PhysicalDeviceRayTracingMotionBlurFeaturesNV {
63480     pub s_type: StructureType,
63481     pub p_next: *mut c_void,
63482     pub ray_tracing_motion_blur: Bool32,
63483     pub ray_tracing_motion_blur_pipeline_trace_rays_indirect: Bool32,
63484 }
63485 impl ::std::default::Default for PhysicalDeviceRayTracingMotionBlurFeaturesNV {
63486     #[inline]
default() -> Self63487     fn default() -> Self {
63488         Self {
63489             s_type: Self::STRUCTURE_TYPE,
63490             p_next: ::std::ptr::null_mut(),
63491             ray_tracing_motion_blur: Bool32::default(),
63492             ray_tracing_motion_blur_pipeline_trace_rays_indirect: Bool32::default(),
63493         }
63494     }
63495 }
63496 unsafe impl TaggedStructure for PhysicalDeviceRayTracingMotionBlurFeaturesNV {
63497     const STRUCTURE_TYPE: StructureType =
63498         StructureType::PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
63499 }
63500 impl PhysicalDeviceRayTracingMotionBlurFeaturesNV {
builder<'a>() -> PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a>63501     pub fn builder<'a>() -> PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> {
63502         PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder {
63503             inner: Self::default(),
63504             marker: ::std::marker::PhantomData,
63505         }
63506     }
63507 }
63508 #[repr(transparent)]
63509 pub struct PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> {
63510     inner: PhysicalDeviceRayTracingMotionBlurFeaturesNV,
63511     marker: ::std::marker::PhantomData<&'a ()>,
63512 }
63513 unsafe impl ExtendsPhysicalDeviceFeatures2
63514     for PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'_>
63515 {
63516 }
63517 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingMotionBlurFeaturesNV {}
63518 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'_> {}
63519 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingMotionBlurFeaturesNV {}
63520 impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> {
63521     type Target = PhysicalDeviceRayTracingMotionBlurFeaturesNV;
deref(&self) -> &Self::Target63522     fn deref(&self) -> &Self::Target {
63523         &self.inner
63524     }
63525 }
63526 impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target63527     fn deref_mut(&mut self) -> &mut Self::Target {
63528         &mut self.inner
63529     }
63530 }
63531 impl<'a> PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> {
63532     #[inline]
ray_tracing_motion_blur(mut self, ray_tracing_motion_blur: bool) -> Self63533     pub fn ray_tracing_motion_blur(mut self, ray_tracing_motion_blur: bool) -> Self {
63534         self.inner.ray_tracing_motion_blur = ray_tracing_motion_blur.into();
63535         self
63536     }
63537     #[inline]
ray_tracing_motion_blur_pipeline_trace_rays_indirect( mut self, ray_tracing_motion_blur_pipeline_trace_rays_indirect: bool, ) -> Self63538     pub fn ray_tracing_motion_blur_pipeline_trace_rays_indirect(
63539         mut self,
63540         ray_tracing_motion_blur_pipeline_trace_rays_indirect: bool,
63541     ) -> Self {
63542         self.inner
63543             .ray_tracing_motion_blur_pipeline_trace_rays_indirect =
63544             ray_tracing_motion_blur_pipeline_trace_rays_indirect.into();
63545         self
63546     }
63547     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
63548     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
63549     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceRayTracingMotionBlurFeaturesNV63550     pub fn build(self) -> PhysicalDeviceRayTracingMotionBlurFeaturesNV {
63551         self.inner
63552     }
63553 }
63554 #[repr(C)]
63555 #[derive(Copy, Clone)]
63556 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryMotionTrianglesDataNV.html>"]
63557 pub struct AccelerationStructureGeometryMotionTrianglesDataNV {
63558     pub s_type: StructureType,
63559     pub p_next: *const c_void,
63560     pub vertex_data: DeviceOrHostAddressConstKHR,
63561 }
63562 #[cfg(feature = "debug")]
63563 impl fmt::Debug for AccelerationStructureGeometryMotionTrianglesDataNV {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result63564     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
63565         fmt.debug_struct("AccelerationStructureGeometryMotionTrianglesDataNV")
63566             .field("s_type", &self.s_type)
63567             .field("p_next", &self.p_next)
63568             .field("vertex_data", &"union")
63569             .finish()
63570     }
63571 }
63572 impl ::std::default::Default for AccelerationStructureGeometryMotionTrianglesDataNV {
63573     #[inline]
default() -> Self63574     fn default() -> Self {
63575         Self {
63576             s_type: Self::STRUCTURE_TYPE,
63577             p_next: ::std::ptr::null(),
63578             vertex_data: DeviceOrHostAddressConstKHR::default(),
63579         }
63580     }
63581 }
63582 unsafe impl TaggedStructure for AccelerationStructureGeometryMotionTrianglesDataNV {
63583     const STRUCTURE_TYPE: StructureType =
63584         StructureType::ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV;
63585 }
63586 impl AccelerationStructureGeometryMotionTrianglesDataNV {
builder<'a>() -> AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a>63587     pub fn builder<'a>() -> AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> {
63588         AccelerationStructureGeometryMotionTrianglesDataNVBuilder {
63589             inner: Self::default(),
63590             marker: ::std::marker::PhantomData,
63591         }
63592     }
63593 }
63594 #[repr(transparent)]
63595 pub struct AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> {
63596     inner: AccelerationStructureGeometryMotionTrianglesDataNV,
63597     marker: ::std::marker::PhantomData<&'a ()>,
63598 }
63599 unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR
63600     for AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'_>
63601 {
63602 }
63603 unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR
63604     for AccelerationStructureGeometryMotionTrianglesDataNV
63605 {
63606 }
63607 impl<'a> ::std::ops::Deref for AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> {
63608     type Target = AccelerationStructureGeometryMotionTrianglesDataNV;
deref(&self) -> &Self::Target63609     fn deref(&self) -> &Self::Target {
63610         &self.inner
63611     }
63612 }
63613 impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target63614     fn deref_mut(&mut self) -> &mut Self::Target {
63615         &mut self.inner
63616     }
63617 }
63618 impl<'a> AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> {
63619     #[inline]
vertex_data(mut self, vertex_data: DeviceOrHostAddressConstKHR) -> Self63620     pub fn vertex_data(mut self, vertex_data: DeviceOrHostAddressConstKHR) -> Self {
63621         self.inner.vertex_data = vertex_data;
63622         self
63623     }
63624     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
63625     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
63626     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureGeometryMotionTrianglesDataNV63627     pub fn build(self) -> AccelerationStructureGeometryMotionTrianglesDataNV {
63628         self.inner
63629     }
63630 }
63631 #[repr(C)]
63632 #[cfg_attr(feature = "debug", derive(Debug))]
63633 #[derive(Copy, Clone)]
63634 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMotionInfoNV.html>"]
63635 pub struct AccelerationStructureMotionInfoNV {
63636     pub s_type: StructureType,
63637     pub p_next: *const c_void,
63638     pub max_instances: u32,
63639     pub flags: AccelerationStructureMotionInfoFlagsNV,
63640 }
63641 impl ::std::default::Default for AccelerationStructureMotionInfoNV {
63642     #[inline]
default() -> Self63643     fn default() -> Self {
63644         Self {
63645             s_type: Self::STRUCTURE_TYPE,
63646             p_next: ::std::ptr::null(),
63647             max_instances: u32::default(),
63648             flags: AccelerationStructureMotionInfoFlagsNV::default(),
63649         }
63650     }
63651 }
63652 unsafe impl TaggedStructure for AccelerationStructureMotionInfoNV {
63653     const STRUCTURE_TYPE: StructureType = StructureType::ACCELERATION_STRUCTURE_MOTION_INFO_NV;
63654 }
63655 impl AccelerationStructureMotionInfoNV {
builder<'a>() -> AccelerationStructureMotionInfoNVBuilder<'a>63656     pub fn builder<'a>() -> AccelerationStructureMotionInfoNVBuilder<'a> {
63657         AccelerationStructureMotionInfoNVBuilder {
63658             inner: Self::default(),
63659             marker: ::std::marker::PhantomData,
63660         }
63661     }
63662 }
63663 #[repr(transparent)]
63664 pub struct AccelerationStructureMotionInfoNVBuilder<'a> {
63665     inner: AccelerationStructureMotionInfoNV,
63666     marker: ::std::marker::PhantomData<&'a ()>,
63667 }
63668 unsafe impl ExtendsAccelerationStructureCreateInfoKHR
63669     for AccelerationStructureMotionInfoNVBuilder<'_>
63670 {
63671 }
63672 unsafe impl ExtendsAccelerationStructureCreateInfoKHR for AccelerationStructureMotionInfoNV {}
63673 impl<'a> ::std::ops::Deref for AccelerationStructureMotionInfoNVBuilder<'a> {
63674     type Target = AccelerationStructureMotionInfoNV;
deref(&self) -> &Self::Target63675     fn deref(&self) -> &Self::Target {
63676         &self.inner
63677     }
63678 }
63679 impl<'a> ::std::ops::DerefMut for AccelerationStructureMotionInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target63680     fn deref_mut(&mut self) -> &mut Self::Target {
63681         &mut self.inner
63682     }
63683 }
63684 impl<'a> AccelerationStructureMotionInfoNVBuilder<'a> {
63685     #[inline]
max_instances(mut self, max_instances: u32) -> Self63686     pub fn max_instances(mut self, max_instances: u32) -> Self {
63687         self.inner.max_instances = max_instances;
63688         self
63689     }
63690     #[inline]
flags(mut self, flags: AccelerationStructureMotionInfoFlagsNV) -> Self63691     pub fn flags(mut self, flags: AccelerationStructureMotionInfoFlagsNV) -> Self {
63692         self.inner.flags = flags;
63693         self
63694     }
63695     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
63696     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
63697     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureMotionInfoNV63698     pub fn build(self) -> AccelerationStructureMotionInfoNV {
63699         self.inner
63700     }
63701 }
63702 #[repr(C)]
63703 #[cfg_attr(feature = "debug", derive(Debug))]
63704 #[derive(Copy, Clone, Default)]
63705 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSRTDataNV.html>"]
63706 pub struct SRTDataNV {
63707     pub sx: f32,
63708     pub a: f32,
63709     pub b: f32,
63710     pub pvx: f32,
63711     pub sy: f32,
63712     pub c: f32,
63713     pub pvy: f32,
63714     pub sz: f32,
63715     pub pvz: f32,
63716     pub qx: f32,
63717     pub qy: f32,
63718     pub qz: f32,
63719     pub qw: f32,
63720     pub tx: f32,
63721     pub ty: f32,
63722     pub tz: f32,
63723 }
63724 impl SRTDataNV {
builder<'a>() -> SRTDataNVBuilder<'a>63725     pub fn builder<'a>() -> SRTDataNVBuilder<'a> {
63726         SRTDataNVBuilder {
63727             inner: Self::default(),
63728             marker: ::std::marker::PhantomData,
63729         }
63730     }
63731 }
63732 #[repr(transparent)]
63733 pub struct SRTDataNVBuilder<'a> {
63734     inner: SRTDataNV,
63735     marker: ::std::marker::PhantomData<&'a ()>,
63736 }
63737 impl<'a> ::std::ops::Deref for SRTDataNVBuilder<'a> {
63738     type Target = SRTDataNV;
deref(&self) -> &Self::Target63739     fn deref(&self) -> &Self::Target {
63740         &self.inner
63741     }
63742 }
63743 impl<'a> ::std::ops::DerefMut for SRTDataNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target63744     fn deref_mut(&mut self) -> &mut Self::Target {
63745         &mut self.inner
63746     }
63747 }
63748 impl<'a> SRTDataNVBuilder<'a> {
63749     #[inline]
sx(mut self, sx: f32) -> Self63750     pub fn sx(mut self, sx: f32) -> Self {
63751         self.inner.sx = sx;
63752         self
63753     }
63754     #[inline]
a(mut self, a: f32) -> Self63755     pub fn a(mut self, a: f32) -> Self {
63756         self.inner.a = a;
63757         self
63758     }
63759     #[inline]
b(mut self, b: f32) -> Self63760     pub fn b(mut self, b: f32) -> Self {
63761         self.inner.b = b;
63762         self
63763     }
63764     #[inline]
pvx(mut self, pvx: f32) -> Self63765     pub fn pvx(mut self, pvx: f32) -> Self {
63766         self.inner.pvx = pvx;
63767         self
63768     }
63769     #[inline]
sy(mut self, sy: f32) -> Self63770     pub fn sy(mut self, sy: f32) -> Self {
63771         self.inner.sy = sy;
63772         self
63773     }
63774     #[inline]
c(mut self, c: f32) -> Self63775     pub fn c(mut self, c: f32) -> Self {
63776         self.inner.c = c;
63777         self
63778     }
63779     #[inline]
pvy(mut self, pvy: f32) -> Self63780     pub fn pvy(mut self, pvy: f32) -> Self {
63781         self.inner.pvy = pvy;
63782         self
63783     }
63784     #[inline]
sz(mut self, sz: f32) -> Self63785     pub fn sz(mut self, sz: f32) -> Self {
63786         self.inner.sz = sz;
63787         self
63788     }
63789     #[inline]
pvz(mut self, pvz: f32) -> Self63790     pub fn pvz(mut self, pvz: f32) -> Self {
63791         self.inner.pvz = pvz;
63792         self
63793     }
63794     #[inline]
qx(mut self, qx: f32) -> Self63795     pub fn qx(mut self, qx: f32) -> Self {
63796         self.inner.qx = qx;
63797         self
63798     }
63799     #[inline]
qy(mut self, qy: f32) -> Self63800     pub fn qy(mut self, qy: f32) -> Self {
63801         self.inner.qy = qy;
63802         self
63803     }
63804     #[inline]
qz(mut self, qz: f32) -> Self63805     pub fn qz(mut self, qz: f32) -> Self {
63806         self.inner.qz = qz;
63807         self
63808     }
63809     #[inline]
qw(mut self, qw: f32) -> Self63810     pub fn qw(mut self, qw: f32) -> Self {
63811         self.inner.qw = qw;
63812         self
63813     }
63814     #[inline]
tx(mut self, tx: f32) -> Self63815     pub fn tx(mut self, tx: f32) -> Self {
63816         self.inner.tx = tx;
63817         self
63818     }
63819     #[inline]
ty(mut self, ty: f32) -> Self63820     pub fn ty(mut self, ty: f32) -> Self {
63821         self.inner.ty = ty;
63822         self
63823     }
63824     #[inline]
tz(mut self, tz: f32) -> Self63825     pub fn tz(mut self, tz: f32) -> Self {
63826         self.inner.tz = tz;
63827         self
63828     }
63829     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
63830     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
63831     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SRTDataNV63832     pub fn build(self) -> SRTDataNV {
63833         self.inner
63834     }
63835 }
63836 #[repr(C)]
63837 #[derive(Copy, Clone)]
63838 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureSRTMotionInstanceNV.html>"]
63839 pub struct AccelerationStructureSRTMotionInstanceNV {
63840     pub transform_t0: SRTDataNV,
63841     pub transform_t1: SRTDataNV,
63842     #[doc = r" Use [`Packed24_8::new(instance_custom_index, mask)`][Packed24_8::new()] to construct this field"]
63843     pub instance_custom_index_and_mask: Packed24_8,
63844     #[doc = r" Use [`Packed24_8::new(instance_shader_binding_table_record_offset, flags)`][Packed24_8::new()] to construct this field"]
63845     pub instance_shader_binding_table_record_offset_and_flags: Packed24_8,
63846     pub acceleration_structure_reference: AccelerationStructureReferenceKHR,
63847 }
63848 #[repr(C)]
63849 #[derive(Copy, Clone)]
63850 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/AccelerationStructureMatrixMotionInstanceNV.html>"]
63851 pub struct AccelerationStructureMatrixMotionInstanceNV {
63852     pub transform_t0: TransformMatrixKHR,
63853     pub transform_t1: TransformMatrixKHR,
63854     #[doc = r" Use [`Packed24_8::new(instance_custom_index, mask)`][Packed24_8::new()] to construct this field"]
63855     pub instance_custom_index_and_mask: Packed24_8,
63856     #[doc = r" Use [`Packed24_8::new(instance_shader_binding_table_record_offset, flags)`][Packed24_8::new()] to construct this field"]
63857     pub instance_shader_binding_table_record_offset_and_flags: Packed24_8,
63858     pub acceleration_structure_reference: AccelerationStructureReferenceKHR,
63859 }
63860 #[repr(C)]
63861 #[derive(Copy, Clone)]
63862 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMotionInstanceDataNV.html>"]
63863 pub union AccelerationStructureMotionInstanceDataNV {
63864     pub static_instance: AccelerationStructureInstanceKHR,
63865     pub matrix_motion_instance: AccelerationStructureMatrixMotionInstanceNV,
63866     pub srt_motion_instance: AccelerationStructureSRTMotionInstanceNV,
63867 }
63868 impl ::std::default::Default for AccelerationStructureMotionInstanceDataNV {
63869     #[inline]
default() -> Self63870     fn default() -> Self {
63871         unsafe { ::std::mem::zeroed() }
63872     }
63873 }
63874 #[repr(C)]
63875 #[derive(Copy, Clone, Default)]
63876 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMotionInstanceNV.html>"]
63877 pub struct AccelerationStructureMotionInstanceNV {
63878     pub ty: AccelerationStructureMotionInstanceTypeNV,
63879     pub flags: AccelerationStructureMotionInstanceFlagsNV,
63880     pub data: AccelerationStructureMotionInstanceDataNV,
63881 }
63882 #[cfg(feature = "debug")]
63883 impl fmt::Debug for AccelerationStructureMotionInstanceNV {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result63884     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
63885         fmt.debug_struct("AccelerationStructureMotionInstanceNV")
63886             .field("ty", &self.ty)
63887             .field("flags", &self.flags)
63888             .field("data", &"union")
63889             .finish()
63890     }
63891 }
63892 impl AccelerationStructureMotionInstanceNV {
builder<'a>() -> AccelerationStructureMotionInstanceNVBuilder<'a>63893     pub fn builder<'a>() -> AccelerationStructureMotionInstanceNVBuilder<'a> {
63894         AccelerationStructureMotionInstanceNVBuilder {
63895             inner: Self::default(),
63896             marker: ::std::marker::PhantomData,
63897         }
63898     }
63899 }
63900 #[repr(transparent)]
63901 pub struct AccelerationStructureMotionInstanceNVBuilder<'a> {
63902     inner: AccelerationStructureMotionInstanceNV,
63903     marker: ::std::marker::PhantomData<&'a ()>,
63904 }
63905 impl<'a> ::std::ops::Deref for AccelerationStructureMotionInstanceNVBuilder<'a> {
63906     type Target = AccelerationStructureMotionInstanceNV;
deref(&self) -> &Self::Target63907     fn deref(&self) -> &Self::Target {
63908         &self.inner
63909     }
63910 }
63911 impl<'a> ::std::ops::DerefMut for AccelerationStructureMotionInstanceNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target63912     fn deref_mut(&mut self) -> &mut Self::Target {
63913         &mut self.inner
63914     }
63915 }
63916 impl<'a> AccelerationStructureMotionInstanceNVBuilder<'a> {
63917     #[inline]
ty(mut self, ty: AccelerationStructureMotionInstanceTypeNV) -> Self63918     pub fn ty(mut self, ty: AccelerationStructureMotionInstanceTypeNV) -> Self {
63919         self.inner.ty = ty;
63920         self
63921     }
63922     #[inline]
flags(mut self, flags: AccelerationStructureMotionInstanceFlagsNV) -> Self63923     pub fn flags(mut self, flags: AccelerationStructureMotionInstanceFlagsNV) -> Self {
63924         self.inner.flags = flags;
63925         self
63926     }
63927     #[inline]
data(mut self, data: AccelerationStructureMotionInstanceDataNV) -> Self63928     pub fn data(mut self, data: AccelerationStructureMotionInstanceDataNV) -> Self {
63929         self.inner.data = data;
63930         self
63931     }
63932     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
63933     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
63934     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureMotionInstanceNV63935     pub fn build(self) -> AccelerationStructureMotionInstanceNV {
63936         self.inner
63937     }
63938 }
63939 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRemoteAddressNV.html>"]
63940 pub type RemoteAddressNV = c_void;
63941 #[repr(C)]
63942 #[cfg_attr(feature = "debug", derive(Debug))]
63943 #[derive(Copy, Clone)]
63944 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryGetRemoteAddressInfoNV.html>"]
63945 pub struct MemoryGetRemoteAddressInfoNV {
63946     pub s_type: StructureType,
63947     pub p_next: *const c_void,
63948     pub memory: DeviceMemory,
63949     pub handle_type: ExternalMemoryHandleTypeFlags,
63950 }
63951 impl ::std::default::Default for MemoryGetRemoteAddressInfoNV {
63952     #[inline]
default() -> Self63953     fn default() -> Self {
63954         Self {
63955             s_type: Self::STRUCTURE_TYPE,
63956             p_next: ::std::ptr::null(),
63957             memory: DeviceMemory::default(),
63958             handle_type: ExternalMemoryHandleTypeFlags::default(),
63959         }
63960     }
63961 }
63962 unsafe impl TaggedStructure for MemoryGetRemoteAddressInfoNV {
63963     const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_GET_REMOTE_ADDRESS_INFO_NV;
63964 }
63965 impl MemoryGetRemoteAddressInfoNV {
builder<'a>() -> MemoryGetRemoteAddressInfoNVBuilder<'a>63966     pub fn builder<'a>() -> MemoryGetRemoteAddressInfoNVBuilder<'a> {
63967         MemoryGetRemoteAddressInfoNVBuilder {
63968             inner: Self::default(),
63969             marker: ::std::marker::PhantomData,
63970         }
63971     }
63972 }
63973 #[repr(transparent)]
63974 pub struct MemoryGetRemoteAddressInfoNVBuilder<'a> {
63975     inner: MemoryGetRemoteAddressInfoNV,
63976     marker: ::std::marker::PhantomData<&'a ()>,
63977 }
63978 impl<'a> ::std::ops::Deref for MemoryGetRemoteAddressInfoNVBuilder<'a> {
63979     type Target = MemoryGetRemoteAddressInfoNV;
deref(&self) -> &Self::Target63980     fn deref(&self) -> &Self::Target {
63981         &self.inner
63982     }
63983 }
63984 impl<'a> ::std::ops::DerefMut for MemoryGetRemoteAddressInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target63985     fn deref_mut(&mut self) -> &mut Self::Target {
63986         &mut self.inner
63987     }
63988 }
63989 impl<'a> MemoryGetRemoteAddressInfoNVBuilder<'a> {
63990     #[inline]
memory(mut self, memory: DeviceMemory) -> Self63991     pub fn memory(mut self, memory: DeviceMemory) -> Self {
63992         self.inner.memory = memory;
63993         self
63994     }
63995     #[inline]
handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self63996     pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
63997         self.inner.handle_type = handle_type;
63998         self
63999     }
64000     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
64001     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
64002     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryGetRemoteAddressInfoNV64003     pub fn build(self) -> MemoryGetRemoteAddressInfoNV {
64004         self.inner
64005     }
64006 }
64007 #[repr(C)]
64008 #[cfg_attr(feature = "debug", derive(Debug))]
64009 #[derive(Copy, Clone)]
64010 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMemoryBufferCollectionFUCHSIA.html>"]
64011 pub struct ImportMemoryBufferCollectionFUCHSIA {
64012     pub s_type: StructureType,
64013     pub p_next: *const c_void,
64014     pub collection: BufferCollectionFUCHSIA,
64015     pub index: u32,
64016 }
64017 impl ::std::default::Default for ImportMemoryBufferCollectionFUCHSIA {
64018     #[inline]
default() -> Self64019     fn default() -> Self {
64020         Self {
64021             s_type: Self::STRUCTURE_TYPE,
64022             p_next: ::std::ptr::null(),
64023             collection: BufferCollectionFUCHSIA::default(),
64024             index: u32::default(),
64025         }
64026     }
64027 }
64028 unsafe impl TaggedStructure for ImportMemoryBufferCollectionFUCHSIA {
64029     const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA;
64030 }
64031 impl ImportMemoryBufferCollectionFUCHSIA {
builder<'a>() -> ImportMemoryBufferCollectionFUCHSIABuilder<'a>64032     pub fn builder<'a>() -> ImportMemoryBufferCollectionFUCHSIABuilder<'a> {
64033         ImportMemoryBufferCollectionFUCHSIABuilder {
64034             inner: Self::default(),
64035             marker: ::std::marker::PhantomData,
64036         }
64037     }
64038 }
64039 #[repr(transparent)]
64040 pub struct ImportMemoryBufferCollectionFUCHSIABuilder<'a> {
64041     inner: ImportMemoryBufferCollectionFUCHSIA,
64042     marker: ::std::marker::PhantomData<&'a ()>,
64043 }
64044 unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryBufferCollectionFUCHSIABuilder<'_> {}
64045 unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryBufferCollectionFUCHSIA {}
64046 impl<'a> ::std::ops::Deref for ImportMemoryBufferCollectionFUCHSIABuilder<'a> {
64047     type Target = ImportMemoryBufferCollectionFUCHSIA;
deref(&self) -> &Self::Target64048     fn deref(&self) -> &Self::Target {
64049         &self.inner
64050     }
64051 }
64052 impl<'a> ::std::ops::DerefMut for ImportMemoryBufferCollectionFUCHSIABuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target64053     fn deref_mut(&mut self) -> &mut Self::Target {
64054         &mut self.inner
64055     }
64056 }
64057 impl<'a> ImportMemoryBufferCollectionFUCHSIABuilder<'a> {
64058     #[inline]
collection(mut self, collection: BufferCollectionFUCHSIA) -> Self64059     pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self {
64060         self.inner.collection = collection;
64061         self
64062     }
64063     #[inline]
index(mut self, index: u32) -> Self64064     pub fn index(mut self, index: u32) -> Self {
64065         self.inner.index = index;
64066         self
64067     }
64068     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
64069     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
64070     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImportMemoryBufferCollectionFUCHSIA64071     pub fn build(self) -> ImportMemoryBufferCollectionFUCHSIA {
64072         self.inner
64073     }
64074 }
64075 #[repr(C)]
64076 #[cfg_attr(feature = "debug", derive(Debug))]
64077 #[derive(Copy, Clone)]
64078 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCollectionImageCreateInfoFUCHSIA.html>"]
64079 pub struct BufferCollectionImageCreateInfoFUCHSIA {
64080     pub s_type: StructureType,
64081     pub p_next: *const c_void,
64082     pub collection: BufferCollectionFUCHSIA,
64083     pub index: u32,
64084 }
64085 impl ::std::default::Default for BufferCollectionImageCreateInfoFUCHSIA {
64086     #[inline]
default() -> Self64087     fn default() -> Self {
64088         Self {
64089             s_type: Self::STRUCTURE_TYPE,
64090             p_next: ::std::ptr::null(),
64091             collection: BufferCollectionFUCHSIA::default(),
64092             index: u32::default(),
64093         }
64094     }
64095 }
64096 unsafe impl TaggedStructure for BufferCollectionImageCreateInfoFUCHSIA {
64097     const STRUCTURE_TYPE: StructureType =
64098         StructureType::BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA;
64099 }
64100 impl BufferCollectionImageCreateInfoFUCHSIA {
builder<'a>() -> BufferCollectionImageCreateInfoFUCHSIABuilder<'a>64101     pub fn builder<'a>() -> BufferCollectionImageCreateInfoFUCHSIABuilder<'a> {
64102         BufferCollectionImageCreateInfoFUCHSIABuilder {
64103             inner: Self::default(),
64104             marker: ::std::marker::PhantomData,
64105         }
64106     }
64107 }
64108 #[repr(transparent)]
64109 pub struct BufferCollectionImageCreateInfoFUCHSIABuilder<'a> {
64110     inner: BufferCollectionImageCreateInfoFUCHSIA,
64111     marker: ::std::marker::PhantomData<&'a ()>,
64112 }
64113 unsafe impl ExtendsImageCreateInfo for BufferCollectionImageCreateInfoFUCHSIABuilder<'_> {}
64114 unsafe impl ExtendsImageCreateInfo for BufferCollectionImageCreateInfoFUCHSIA {}
64115 impl<'a> ::std::ops::Deref for BufferCollectionImageCreateInfoFUCHSIABuilder<'a> {
64116     type Target = BufferCollectionImageCreateInfoFUCHSIA;
deref(&self) -> &Self::Target64117     fn deref(&self) -> &Self::Target {
64118         &self.inner
64119     }
64120 }
64121 impl<'a> ::std::ops::DerefMut for BufferCollectionImageCreateInfoFUCHSIABuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target64122     fn deref_mut(&mut self) -> &mut Self::Target {
64123         &mut self.inner
64124     }
64125 }
64126 impl<'a> BufferCollectionImageCreateInfoFUCHSIABuilder<'a> {
64127     #[inline]
collection(mut self, collection: BufferCollectionFUCHSIA) -> Self64128     pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self {
64129         self.inner.collection = collection;
64130         self
64131     }
64132     #[inline]
index(mut self, index: u32) -> Self64133     pub fn index(mut self, index: u32) -> Self {
64134         self.inner.index = index;
64135         self
64136     }
64137     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
64138     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
64139     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferCollectionImageCreateInfoFUCHSIA64140     pub fn build(self) -> BufferCollectionImageCreateInfoFUCHSIA {
64141         self.inner
64142     }
64143 }
64144 #[repr(C)]
64145 #[cfg_attr(feature = "debug", derive(Debug))]
64146 #[derive(Copy, Clone)]
64147 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCollectionBufferCreateInfoFUCHSIA.html>"]
64148 pub struct BufferCollectionBufferCreateInfoFUCHSIA {
64149     pub s_type: StructureType,
64150     pub p_next: *const c_void,
64151     pub collection: BufferCollectionFUCHSIA,
64152     pub index: u32,
64153 }
64154 impl ::std::default::Default for BufferCollectionBufferCreateInfoFUCHSIA {
64155     #[inline]
default() -> Self64156     fn default() -> Self {
64157         Self {
64158             s_type: Self::STRUCTURE_TYPE,
64159             p_next: ::std::ptr::null(),
64160             collection: BufferCollectionFUCHSIA::default(),
64161             index: u32::default(),
64162         }
64163     }
64164 }
64165 unsafe impl TaggedStructure for BufferCollectionBufferCreateInfoFUCHSIA {
64166     const STRUCTURE_TYPE: StructureType =
64167         StructureType::BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA;
64168 }
64169 impl BufferCollectionBufferCreateInfoFUCHSIA {
builder<'a>() -> BufferCollectionBufferCreateInfoFUCHSIABuilder<'a>64170     pub fn builder<'a>() -> BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> {
64171         BufferCollectionBufferCreateInfoFUCHSIABuilder {
64172             inner: Self::default(),
64173             marker: ::std::marker::PhantomData,
64174         }
64175     }
64176 }
64177 #[repr(transparent)]
64178 pub struct BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> {
64179     inner: BufferCollectionBufferCreateInfoFUCHSIA,
64180     marker: ::std::marker::PhantomData<&'a ()>,
64181 }
64182 unsafe impl ExtendsBufferCreateInfo for BufferCollectionBufferCreateInfoFUCHSIABuilder<'_> {}
64183 unsafe impl ExtendsBufferCreateInfo for BufferCollectionBufferCreateInfoFUCHSIA {}
64184 impl<'a> ::std::ops::Deref for BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> {
64185     type Target = BufferCollectionBufferCreateInfoFUCHSIA;
deref(&self) -> &Self::Target64186     fn deref(&self) -> &Self::Target {
64187         &self.inner
64188     }
64189 }
64190 impl<'a> ::std::ops::DerefMut for BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target64191     fn deref_mut(&mut self) -> &mut Self::Target {
64192         &mut self.inner
64193     }
64194 }
64195 impl<'a> BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> {
64196     #[inline]
collection(mut self, collection: BufferCollectionFUCHSIA) -> Self64197     pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self {
64198         self.inner.collection = collection;
64199         self
64200     }
64201     #[inline]
index(mut self, index: u32) -> Self64202     pub fn index(mut self, index: u32) -> Self {
64203         self.inner.index = index;
64204         self
64205     }
64206     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
64207     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
64208     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferCollectionBufferCreateInfoFUCHSIA64209     pub fn build(self) -> BufferCollectionBufferCreateInfoFUCHSIA {
64210         self.inner
64211     }
64212 }
64213 #[repr(C)]
64214 #[cfg_attr(feature = "debug", derive(Debug))]
64215 #[derive(Copy, Clone)]
64216 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCollectionCreateInfoFUCHSIA.html>"]
64217 pub struct BufferCollectionCreateInfoFUCHSIA {
64218     pub s_type: StructureType,
64219     pub p_next: *const c_void,
64220     pub collection_token: zx_handle_t,
64221 }
64222 impl ::std::default::Default for BufferCollectionCreateInfoFUCHSIA {
64223     #[inline]
default() -> Self64224     fn default() -> Self {
64225         Self {
64226             s_type: Self::STRUCTURE_TYPE,
64227             p_next: ::std::ptr::null(),
64228             collection_token: zx_handle_t::default(),
64229         }
64230     }
64231 }
64232 unsafe impl TaggedStructure for BufferCollectionCreateInfoFUCHSIA {
64233     const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_COLLECTION_CREATE_INFO_FUCHSIA;
64234 }
64235 impl BufferCollectionCreateInfoFUCHSIA {
builder<'a>() -> BufferCollectionCreateInfoFUCHSIABuilder<'a>64236     pub fn builder<'a>() -> BufferCollectionCreateInfoFUCHSIABuilder<'a> {
64237         BufferCollectionCreateInfoFUCHSIABuilder {
64238             inner: Self::default(),
64239             marker: ::std::marker::PhantomData,
64240         }
64241     }
64242 }
64243 #[repr(transparent)]
64244 pub struct BufferCollectionCreateInfoFUCHSIABuilder<'a> {
64245     inner: BufferCollectionCreateInfoFUCHSIA,
64246     marker: ::std::marker::PhantomData<&'a ()>,
64247 }
64248 impl<'a> ::std::ops::Deref for BufferCollectionCreateInfoFUCHSIABuilder<'a> {
64249     type Target = BufferCollectionCreateInfoFUCHSIA;
deref(&self) -> &Self::Target64250     fn deref(&self) -> &Self::Target {
64251         &self.inner
64252     }
64253 }
64254 impl<'a> ::std::ops::DerefMut for BufferCollectionCreateInfoFUCHSIABuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target64255     fn deref_mut(&mut self) -> &mut Self::Target {
64256         &mut self.inner
64257     }
64258 }
64259 impl<'a> BufferCollectionCreateInfoFUCHSIABuilder<'a> {
64260     #[inline]
collection_token(mut self, collection_token: zx_handle_t) -> Self64261     pub fn collection_token(mut self, collection_token: zx_handle_t) -> Self {
64262         self.inner.collection_token = collection_token;
64263         self
64264     }
64265     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
64266     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
64267     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferCollectionCreateInfoFUCHSIA64268     pub fn build(self) -> BufferCollectionCreateInfoFUCHSIA {
64269         self.inner
64270     }
64271 }
64272 #[repr(C)]
64273 #[cfg_attr(feature = "debug", derive(Debug))]
64274 #[derive(Copy, Clone)]
64275 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCollectionPropertiesFUCHSIA.html>"]
64276 pub struct BufferCollectionPropertiesFUCHSIA {
64277     pub s_type: StructureType,
64278     pub p_next: *mut c_void,
64279     pub memory_type_bits: u32,
64280     pub buffer_count: u32,
64281     pub create_info_index: u32,
64282     pub sysmem_pixel_format: u64,
64283     pub format_features: FormatFeatureFlags,
64284     pub sysmem_color_space_index: SysmemColorSpaceFUCHSIA,
64285     pub sampler_ycbcr_conversion_components: ComponentMapping,
64286     pub suggested_ycbcr_model: SamplerYcbcrModelConversion,
64287     pub suggested_ycbcr_range: SamplerYcbcrRange,
64288     pub suggested_x_chroma_offset: ChromaLocation,
64289     pub suggested_y_chroma_offset: ChromaLocation,
64290 }
64291 impl ::std::default::Default for BufferCollectionPropertiesFUCHSIA {
64292     #[inline]
default() -> Self64293     fn default() -> Self {
64294         Self {
64295             s_type: Self::STRUCTURE_TYPE,
64296             p_next: ::std::ptr::null_mut(),
64297             memory_type_bits: u32::default(),
64298             buffer_count: u32::default(),
64299             create_info_index: u32::default(),
64300             sysmem_pixel_format: u64::default(),
64301             format_features: FormatFeatureFlags::default(),
64302             sysmem_color_space_index: SysmemColorSpaceFUCHSIA::default(),
64303             sampler_ycbcr_conversion_components: ComponentMapping::default(),
64304             suggested_ycbcr_model: SamplerYcbcrModelConversion::default(),
64305             suggested_ycbcr_range: SamplerYcbcrRange::default(),
64306             suggested_x_chroma_offset: ChromaLocation::default(),
64307             suggested_y_chroma_offset: ChromaLocation::default(),
64308         }
64309     }
64310 }
64311 unsafe impl TaggedStructure for BufferCollectionPropertiesFUCHSIA {
64312     const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_COLLECTION_PROPERTIES_FUCHSIA;
64313 }
64314 impl BufferCollectionPropertiesFUCHSIA {
builder<'a>() -> BufferCollectionPropertiesFUCHSIABuilder<'a>64315     pub fn builder<'a>() -> BufferCollectionPropertiesFUCHSIABuilder<'a> {
64316         BufferCollectionPropertiesFUCHSIABuilder {
64317             inner: Self::default(),
64318             marker: ::std::marker::PhantomData,
64319         }
64320     }
64321 }
64322 #[repr(transparent)]
64323 pub struct BufferCollectionPropertiesFUCHSIABuilder<'a> {
64324     inner: BufferCollectionPropertiesFUCHSIA,
64325     marker: ::std::marker::PhantomData<&'a ()>,
64326 }
64327 impl<'a> ::std::ops::Deref for BufferCollectionPropertiesFUCHSIABuilder<'a> {
64328     type Target = BufferCollectionPropertiesFUCHSIA;
deref(&self) -> &Self::Target64329     fn deref(&self) -> &Self::Target {
64330         &self.inner
64331     }
64332 }
64333 impl<'a> ::std::ops::DerefMut for BufferCollectionPropertiesFUCHSIABuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target64334     fn deref_mut(&mut self) -> &mut Self::Target {
64335         &mut self.inner
64336     }
64337 }
64338 impl<'a> BufferCollectionPropertiesFUCHSIABuilder<'a> {
64339     #[inline]
memory_type_bits(mut self, memory_type_bits: u32) -> Self64340     pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self {
64341         self.inner.memory_type_bits = memory_type_bits;
64342         self
64343     }
64344     #[inline]
buffer_count(mut self, buffer_count: u32) -> Self64345     pub fn buffer_count(mut self, buffer_count: u32) -> Self {
64346         self.inner.buffer_count = buffer_count;
64347         self
64348     }
64349     #[inline]
create_info_index(mut self, create_info_index: u32) -> Self64350     pub fn create_info_index(mut self, create_info_index: u32) -> Self {
64351         self.inner.create_info_index = create_info_index;
64352         self
64353     }
64354     #[inline]
sysmem_pixel_format(mut self, sysmem_pixel_format: u64) -> Self64355     pub fn sysmem_pixel_format(mut self, sysmem_pixel_format: u64) -> Self {
64356         self.inner.sysmem_pixel_format = sysmem_pixel_format;
64357         self
64358     }
64359     #[inline]
format_features(mut self, format_features: FormatFeatureFlags) -> Self64360     pub fn format_features(mut self, format_features: FormatFeatureFlags) -> Self {
64361         self.inner.format_features = format_features;
64362         self
64363     }
64364     #[inline]
sysmem_color_space_index( mut self, sysmem_color_space_index: SysmemColorSpaceFUCHSIA, ) -> Self64365     pub fn sysmem_color_space_index(
64366         mut self,
64367         sysmem_color_space_index: SysmemColorSpaceFUCHSIA,
64368     ) -> Self {
64369         self.inner.sysmem_color_space_index = sysmem_color_space_index;
64370         self
64371     }
64372     #[inline]
sampler_ycbcr_conversion_components( mut self, sampler_ycbcr_conversion_components: ComponentMapping, ) -> Self64373     pub fn sampler_ycbcr_conversion_components(
64374         mut self,
64375         sampler_ycbcr_conversion_components: ComponentMapping,
64376     ) -> Self {
64377         self.inner.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components;
64378         self
64379     }
64380     #[inline]
suggested_ycbcr_model( mut self, suggested_ycbcr_model: SamplerYcbcrModelConversion, ) -> Self64381     pub fn suggested_ycbcr_model(
64382         mut self,
64383         suggested_ycbcr_model: SamplerYcbcrModelConversion,
64384     ) -> Self {
64385         self.inner.suggested_ycbcr_model = suggested_ycbcr_model;
64386         self
64387     }
64388     #[inline]
suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self64389     pub fn suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self {
64390         self.inner.suggested_ycbcr_range = suggested_ycbcr_range;
64391         self
64392     }
64393     #[inline]
suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self64394     pub fn suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self {
64395         self.inner.suggested_x_chroma_offset = suggested_x_chroma_offset;
64396         self
64397     }
64398     #[inline]
suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self64399     pub fn suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self {
64400         self.inner.suggested_y_chroma_offset = suggested_y_chroma_offset;
64401         self
64402     }
64403     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
64404     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
64405     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferCollectionPropertiesFUCHSIA64406     pub fn build(self) -> BufferCollectionPropertiesFUCHSIA {
64407         self.inner
64408     }
64409 }
64410 #[repr(C)]
64411 #[cfg_attr(feature = "debug", derive(Debug))]
64412 #[derive(Copy, Clone)]
64413 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferConstraintsInfoFUCHSIA.html>"]
64414 pub struct BufferConstraintsInfoFUCHSIA {
64415     pub s_type: StructureType,
64416     pub p_next: *const c_void,
64417     pub create_info: BufferCreateInfo,
64418     pub required_format_features: FormatFeatureFlags,
64419     pub buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA,
64420 }
64421 impl ::std::default::Default for BufferConstraintsInfoFUCHSIA {
64422     #[inline]
default() -> Self64423     fn default() -> Self {
64424         Self {
64425             s_type: Self::STRUCTURE_TYPE,
64426             p_next: ::std::ptr::null(),
64427             create_info: BufferCreateInfo::default(),
64428             required_format_features: FormatFeatureFlags::default(),
64429             buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA::default(),
64430         }
64431     }
64432 }
64433 unsafe impl TaggedStructure for BufferConstraintsInfoFUCHSIA {
64434     const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_CONSTRAINTS_INFO_FUCHSIA;
64435 }
64436 impl BufferConstraintsInfoFUCHSIA {
builder<'a>() -> BufferConstraintsInfoFUCHSIABuilder<'a>64437     pub fn builder<'a>() -> BufferConstraintsInfoFUCHSIABuilder<'a> {
64438         BufferConstraintsInfoFUCHSIABuilder {
64439             inner: Self::default(),
64440             marker: ::std::marker::PhantomData,
64441         }
64442     }
64443 }
64444 #[repr(transparent)]
64445 pub struct BufferConstraintsInfoFUCHSIABuilder<'a> {
64446     inner: BufferConstraintsInfoFUCHSIA,
64447     marker: ::std::marker::PhantomData<&'a ()>,
64448 }
64449 impl<'a> ::std::ops::Deref for BufferConstraintsInfoFUCHSIABuilder<'a> {
64450     type Target = BufferConstraintsInfoFUCHSIA;
deref(&self) -> &Self::Target64451     fn deref(&self) -> &Self::Target {
64452         &self.inner
64453     }
64454 }
64455 impl<'a> ::std::ops::DerefMut for BufferConstraintsInfoFUCHSIABuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target64456     fn deref_mut(&mut self) -> &mut Self::Target {
64457         &mut self.inner
64458     }
64459 }
64460 impl<'a> BufferConstraintsInfoFUCHSIABuilder<'a> {
64461     #[inline]
create_info(mut self, create_info: BufferCreateInfo) -> Self64462     pub fn create_info(mut self, create_info: BufferCreateInfo) -> Self {
64463         self.inner.create_info = create_info;
64464         self
64465     }
64466     #[inline]
required_format_features( mut self, required_format_features: FormatFeatureFlags, ) -> Self64467     pub fn required_format_features(
64468         mut self,
64469         required_format_features: FormatFeatureFlags,
64470     ) -> Self {
64471         self.inner.required_format_features = required_format_features;
64472         self
64473     }
64474     #[inline]
buffer_collection_constraints( mut self, buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA, ) -> Self64475     pub fn buffer_collection_constraints(
64476         mut self,
64477         buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA,
64478     ) -> Self {
64479         self.inner.buffer_collection_constraints = buffer_collection_constraints;
64480         self
64481     }
64482     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
64483     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
64484     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferConstraintsInfoFUCHSIA64485     pub fn build(self) -> BufferConstraintsInfoFUCHSIA {
64486         self.inner
64487     }
64488 }
64489 #[repr(C)]
64490 #[cfg_attr(feature = "debug", derive(Debug))]
64491 #[derive(Copy, Clone)]
64492 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSysmemColorSpaceFUCHSIA.html>"]
64493 pub struct SysmemColorSpaceFUCHSIA {
64494     pub s_type: StructureType,
64495     pub p_next: *const c_void,
64496     pub color_space: u32,
64497 }
64498 impl ::std::default::Default for SysmemColorSpaceFUCHSIA {
64499     #[inline]
default() -> Self64500     fn default() -> Self {
64501         Self {
64502             s_type: Self::STRUCTURE_TYPE,
64503             p_next: ::std::ptr::null(),
64504             color_space: u32::default(),
64505         }
64506     }
64507 }
64508 unsafe impl TaggedStructure for SysmemColorSpaceFUCHSIA {
64509     const STRUCTURE_TYPE: StructureType = StructureType::SYSMEM_COLOR_SPACE_FUCHSIA;
64510 }
64511 impl SysmemColorSpaceFUCHSIA {
builder<'a>() -> SysmemColorSpaceFUCHSIABuilder<'a>64512     pub fn builder<'a>() -> SysmemColorSpaceFUCHSIABuilder<'a> {
64513         SysmemColorSpaceFUCHSIABuilder {
64514             inner: Self::default(),
64515             marker: ::std::marker::PhantomData,
64516         }
64517     }
64518 }
64519 #[repr(transparent)]
64520 pub struct SysmemColorSpaceFUCHSIABuilder<'a> {
64521     inner: SysmemColorSpaceFUCHSIA,
64522     marker: ::std::marker::PhantomData<&'a ()>,
64523 }
64524 impl<'a> ::std::ops::Deref for SysmemColorSpaceFUCHSIABuilder<'a> {
64525     type Target = SysmemColorSpaceFUCHSIA;
deref(&self) -> &Self::Target64526     fn deref(&self) -> &Self::Target {
64527         &self.inner
64528     }
64529 }
64530 impl<'a> ::std::ops::DerefMut for SysmemColorSpaceFUCHSIABuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target64531     fn deref_mut(&mut self) -> &mut Self::Target {
64532         &mut self.inner
64533     }
64534 }
64535 impl<'a> SysmemColorSpaceFUCHSIABuilder<'a> {
64536     #[inline]
color_space(mut self, color_space: u32) -> Self64537     pub fn color_space(mut self, color_space: u32) -> Self {
64538         self.inner.color_space = color_space;
64539         self
64540     }
64541     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
64542     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
64543     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SysmemColorSpaceFUCHSIA64544     pub fn build(self) -> SysmemColorSpaceFUCHSIA {
64545         self.inner
64546     }
64547 }
64548 #[repr(C)]
64549 #[cfg_attr(feature = "debug", derive(Debug))]
64550 #[derive(Copy, Clone)]
64551 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageFormatConstraintsInfoFUCHSIA.html>"]
64552 pub struct ImageFormatConstraintsInfoFUCHSIA {
64553     pub s_type: StructureType,
64554     pub p_next: *const c_void,
64555     pub image_create_info: ImageCreateInfo,
64556     pub required_format_features: FormatFeatureFlags,
64557     pub flags: ImageFormatConstraintsFlagsFUCHSIA,
64558     pub sysmem_pixel_format: u64,
64559     pub color_space_count: u32,
64560     pub p_color_spaces: *const SysmemColorSpaceFUCHSIA,
64561 }
64562 impl ::std::default::Default for ImageFormatConstraintsInfoFUCHSIA {
64563     #[inline]
default() -> Self64564     fn default() -> Self {
64565         Self {
64566             s_type: Self::STRUCTURE_TYPE,
64567             p_next: ::std::ptr::null(),
64568             image_create_info: ImageCreateInfo::default(),
64569             required_format_features: FormatFeatureFlags::default(),
64570             flags: ImageFormatConstraintsFlagsFUCHSIA::default(),
64571             sysmem_pixel_format: u64::default(),
64572             color_space_count: u32::default(),
64573             p_color_spaces: ::std::ptr::null(),
64574         }
64575     }
64576 }
64577 unsafe impl TaggedStructure for ImageFormatConstraintsInfoFUCHSIA {
64578     const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA;
64579 }
64580 impl ImageFormatConstraintsInfoFUCHSIA {
builder<'a>() -> ImageFormatConstraintsInfoFUCHSIABuilder<'a>64581     pub fn builder<'a>() -> ImageFormatConstraintsInfoFUCHSIABuilder<'a> {
64582         ImageFormatConstraintsInfoFUCHSIABuilder {
64583             inner: Self::default(),
64584             marker: ::std::marker::PhantomData,
64585         }
64586     }
64587 }
64588 #[repr(transparent)]
64589 pub struct ImageFormatConstraintsInfoFUCHSIABuilder<'a> {
64590     inner: ImageFormatConstraintsInfoFUCHSIA,
64591     marker: ::std::marker::PhantomData<&'a ()>,
64592 }
64593 impl<'a> ::std::ops::Deref for ImageFormatConstraintsInfoFUCHSIABuilder<'a> {
64594     type Target = ImageFormatConstraintsInfoFUCHSIA;
deref(&self) -> &Self::Target64595     fn deref(&self) -> &Self::Target {
64596         &self.inner
64597     }
64598 }
64599 impl<'a> ::std::ops::DerefMut for ImageFormatConstraintsInfoFUCHSIABuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target64600     fn deref_mut(&mut self) -> &mut Self::Target {
64601         &mut self.inner
64602     }
64603 }
64604 impl<'a> ImageFormatConstraintsInfoFUCHSIABuilder<'a> {
64605     #[inline]
image_create_info(mut self, image_create_info: ImageCreateInfo) -> Self64606     pub fn image_create_info(mut self, image_create_info: ImageCreateInfo) -> Self {
64607         self.inner.image_create_info = image_create_info;
64608         self
64609     }
64610     #[inline]
required_format_features( mut self, required_format_features: FormatFeatureFlags, ) -> Self64611     pub fn required_format_features(
64612         mut self,
64613         required_format_features: FormatFeatureFlags,
64614     ) -> Self {
64615         self.inner.required_format_features = required_format_features;
64616         self
64617     }
64618     #[inline]
flags(mut self, flags: ImageFormatConstraintsFlagsFUCHSIA) -> Self64619     pub fn flags(mut self, flags: ImageFormatConstraintsFlagsFUCHSIA) -> Self {
64620         self.inner.flags = flags;
64621         self
64622     }
64623     #[inline]
sysmem_pixel_format(mut self, sysmem_pixel_format: u64) -> Self64624     pub fn sysmem_pixel_format(mut self, sysmem_pixel_format: u64) -> Self {
64625         self.inner.sysmem_pixel_format = sysmem_pixel_format;
64626         self
64627     }
64628     #[inline]
color_spaces(mut self, color_spaces: &'a [SysmemColorSpaceFUCHSIA]) -> Self64629     pub fn color_spaces(mut self, color_spaces: &'a [SysmemColorSpaceFUCHSIA]) -> Self {
64630         self.inner.color_space_count = color_spaces.len() as _;
64631         self.inner.p_color_spaces = color_spaces.as_ptr();
64632         self
64633     }
64634     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
64635     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
64636     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageFormatConstraintsInfoFUCHSIA64637     pub fn build(self) -> ImageFormatConstraintsInfoFUCHSIA {
64638         self.inner
64639     }
64640 }
64641 #[repr(C)]
64642 #[cfg_attr(feature = "debug", derive(Debug))]
64643 #[derive(Copy, Clone)]
64644 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageConstraintsInfoFUCHSIA.html>"]
64645 pub struct ImageConstraintsInfoFUCHSIA {
64646     pub s_type: StructureType,
64647     pub p_next: *const c_void,
64648     pub format_constraints_count: u32,
64649     pub p_format_constraints: *const ImageFormatConstraintsInfoFUCHSIA,
64650     pub buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA,
64651     pub flags: ImageConstraintsInfoFlagsFUCHSIA,
64652 }
64653 impl ::std::default::Default for ImageConstraintsInfoFUCHSIA {
64654     #[inline]
default() -> Self64655     fn default() -> Self {
64656         Self {
64657             s_type: Self::STRUCTURE_TYPE,
64658             p_next: ::std::ptr::null(),
64659             format_constraints_count: u32::default(),
64660             p_format_constraints: ::std::ptr::null(),
64661             buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA::default(),
64662             flags: ImageConstraintsInfoFlagsFUCHSIA::default(),
64663         }
64664     }
64665 }
64666 unsafe impl TaggedStructure for ImageConstraintsInfoFUCHSIA {
64667     const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_CONSTRAINTS_INFO_FUCHSIA;
64668 }
64669 impl ImageConstraintsInfoFUCHSIA {
builder<'a>() -> ImageConstraintsInfoFUCHSIABuilder<'a>64670     pub fn builder<'a>() -> ImageConstraintsInfoFUCHSIABuilder<'a> {
64671         ImageConstraintsInfoFUCHSIABuilder {
64672             inner: Self::default(),
64673             marker: ::std::marker::PhantomData,
64674         }
64675     }
64676 }
64677 #[repr(transparent)]
64678 pub struct ImageConstraintsInfoFUCHSIABuilder<'a> {
64679     inner: ImageConstraintsInfoFUCHSIA,
64680     marker: ::std::marker::PhantomData<&'a ()>,
64681 }
64682 impl<'a> ::std::ops::Deref for ImageConstraintsInfoFUCHSIABuilder<'a> {
64683     type Target = ImageConstraintsInfoFUCHSIA;
deref(&self) -> &Self::Target64684     fn deref(&self) -> &Self::Target {
64685         &self.inner
64686     }
64687 }
64688 impl<'a> ::std::ops::DerefMut for ImageConstraintsInfoFUCHSIABuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target64689     fn deref_mut(&mut self) -> &mut Self::Target {
64690         &mut self.inner
64691     }
64692 }
64693 impl<'a> ImageConstraintsInfoFUCHSIABuilder<'a> {
64694     #[inline]
format_constraints( mut self, format_constraints: &'a [ImageFormatConstraintsInfoFUCHSIA], ) -> Self64695     pub fn format_constraints(
64696         mut self,
64697         format_constraints: &'a [ImageFormatConstraintsInfoFUCHSIA],
64698     ) -> Self {
64699         self.inner.format_constraints_count = format_constraints.len() as _;
64700         self.inner.p_format_constraints = format_constraints.as_ptr();
64701         self
64702     }
64703     #[inline]
buffer_collection_constraints( mut self, buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA, ) -> Self64704     pub fn buffer_collection_constraints(
64705         mut self,
64706         buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA,
64707     ) -> Self {
64708         self.inner.buffer_collection_constraints = buffer_collection_constraints;
64709         self
64710     }
64711     #[inline]
flags(mut self, flags: ImageConstraintsInfoFlagsFUCHSIA) -> Self64712     pub fn flags(mut self, flags: ImageConstraintsInfoFlagsFUCHSIA) -> Self {
64713         self.inner.flags = flags;
64714         self
64715     }
64716     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
64717     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
64718     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageConstraintsInfoFUCHSIA64719     pub fn build(self) -> ImageConstraintsInfoFUCHSIA {
64720         self.inner
64721     }
64722 }
64723 #[repr(C)]
64724 #[cfg_attr(feature = "debug", derive(Debug))]
64725 #[derive(Copy, Clone)]
64726 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCollectionConstraintsInfoFUCHSIA.html>"]
64727 pub struct BufferCollectionConstraintsInfoFUCHSIA {
64728     pub s_type: StructureType,
64729     pub p_next: *const c_void,
64730     pub min_buffer_count: u32,
64731     pub max_buffer_count: u32,
64732     pub min_buffer_count_for_camping: u32,
64733     pub min_buffer_count_for_dedicated_slack: u32,
64734     pub min_buffer_count_for_shared_slack: u32,
64735 }
64736 impl ::std::default::Default for BufferCollectionConstraintsInfoFUCHSIA {
64737     #[inline]
default() -> Self64738     fn default() -> Self {
64739         Self {
64740             s_type: Self::STRUCTURE_TYPE,
64741             p_next: ::std::ptr::null(),
64742             min_buffer_count: u32::default(),
64743             max_buffer_count: u32::default(),
64744             min_buffer_count_for_camping: u32::default(),
64745             min_buffer_count_for_dedicated_slack: u32::default(),
64746             min_buffer_count_for_shared_slack: u32::default(),
64747         }
64748     }
64749 }
64750 unsafe impl TaggedStructure for BufferCollectionConstraintsInfoFUCHSIA {
64751     const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA;
64752 }
64753 impl BufferCollectionConstraintsInfoFUCHSIA {
builder<'a>() -> BufferCollectionConstraintsInfoFUCHSIABuilder<'a>64754     pub fn builder<'a>() -> BufferCollectionConstraintsInfoFUCHSIABuilder<'a> {
64755         BufferCollectionConstraintsInfoFUCHSIABuilder {
64756             inner: Self::default(),
64757             marker: ::std::marker::PhantomData,
64758         }
64759     }
64760 }
64761 #[repr(transparent)]
64762 pub struct BufferCollectionConstraintsInfoFUCHSIABuilder<'a> {
64763     inner: BufferCollectionConstraintsInfoFUCHSIA,
64764     marker: ::std::marker::PhantomData<&'a ()>,
64765 }
64766 impl<'a> ::std::ops::Deref for BufferCollectionConstraintsInfoFUCHSIABuilder<'a> {
64767     type Target = BufferCollectionConstraintsInfoFUCHSIA;
deref(&self) -> &Self::Target64768     fn deref(&self) -> &Self::Target {
64769         &self.inner
64770     }
64771 }
64772 impl<'a> ::std::ops::DerefMut for BufferCollectionConstraintsInfoFUCHSIABuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target64773     fn deref_mut(&mut self) -> &mut Self::Target {
64774         &mut self.inner
64775     }
64776 }
64777 impl<'a> BufferCollectionConstraintsInfoFUCHSIABuilder<'a> {
64778     #[inline]
min_buffer_count(mut self, min_buffer_count: u32) -> Self64779     pub fn min_buffer_count(mut self, min_buffer_count: u32) -> Self {
64780         self.inner.min_buffer_count = min_buffer_count;
64781         self
64782     }
64783     #[inline]
max_buffer_count(mut self, max_buffer_count: u32) -> Self64784     pub fn max_buffer_count(mut self, max_buffer_count: u32) -> Self {
64785         self.inner.max_buffer_count = max_buffer_count;
64786         self
64787     }
64788     #[inline]
min_buffer_count_for_camping(mut self, min_buffer_count_for_camping: u32) -> Self64789     pub fn min_buffer_count_for_camping(mut self, min_buffer_count_for_camping: u32) -> Self {
64790         self.inner.min_buffer_count_for_camping = min_buffer_count_for_camping;
64791         self
64792     }
64793     #[inline]
min_buffer_count_for_dedicated_slack( mut self, min_buffer_count_for_dedicated_slack: u32, ) -> Self64794     pub fn min_buffer_count_for_dedicated_slack(
64795         mut self,
64796         min_buffer_count_for_dedicated_slack: u32,
64797     ) -> Self {
64798         self.inner.min_buffer_count_for_dedicated_slack = min_buffer_count_for_dedicated_slack;
64799         self
64800     }
64801     #[inline]
min_buffer_count_for_shared_slack( mut self, min_buffer_count_for_shared_slack: u32, ) -> Self64802     pub fn min_buffer_count_for_shared_slack(
64803         mut self,
64804         min_buffer_count_for_shared_slack: u32,
64805     ) -> Self {
64806         self.inner.min_buffer_count_for_shared_slack = min_buffer_count_for_shared_slack;
64807         self
64808     }
64809     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
64810     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
64811     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferCollectionConstraintsInfoFUCHSIA64812     pub fn build(self) -> BufferCollectionConstraintsInfoFUCHSIA {
64813         self.inner
64814     }
64815 }
64816 #[repr(C)]
64817 #[cfg_attr(feature = "debug", derive(Debug))]
64818 #[derive(Copy, Clone)]
64819 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT.html>"]
64820 pub struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT {
64821     pub s_type: StructureType,
64822     pub p_next: *mut c_void,
64823     pub format_rgba10x6_without_y_cb_cr_sampler: Bool32,
64824 }
64825 impl ::std::default::Default for PhysicalDeviceRGBA10X6FormatsFeaturesEXT {
64826     #[inline]
default() -> Self64827     fn default() -> Self {
64828         Self {
64829             s_type: Self::STRUCTURE_TYPE,
64830             p_next: ::std::ptr::null_mut(),
64831             format_rgba10x6_without_y_cb_cr_sampler: Bool32::default(),
64832         }
64833     }
64834 }
64835 unsafe impl TaggedStructure for PhysicalDeviceRGBA10X6FormatsFeaturesEXT {
64836     const STRUCTURE_TYPE: StructureType =
64837         StructureType::PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
64838 }
64839 impl PhysicalDeviceRGBA10X6FormatsFeaturesEXT {
builder<'a>() -> PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a>64840     pub fn builder<'a>() -> PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> {
64841         PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder {
64842             inner: Self::default(),
64843             marker: ::std::marker::PhantomData,
64844         }
64845     }
64846 }
64847 #[repr(transparent)]
64848 pub struct PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> {
64849     inner: PhysicalDeviceRGBA10X6FormatsFeaturesEXT,
64850     marker: ::std::marker::PhantomData<&'a ()>,
64851 }
64852 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'_> {}
64853 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRGBA10X6FormatsFeaturesEXT {}
64854 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'_> {}
64855 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRGBA10X6FormatsFeaturesEXT {}
64856 impl<'a> ::std::ops::Deref for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> {
64857     type Target = PhysicalDeviceRGBA10X6FormatsFeaturesEXT;
deref(&self) -> &Self::Target64858     fn deref(&self) -> &Self::Target {
64859         &self.inner
64860     }
64861 }
64862 impl<'a> ::std::ops::DerefMut for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target64863     fn deref_mut(&mut self) -> &mut Self::Target {
64864         &mut self.inner
64865     }
64866 }
64867 impl<'a> PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> {
64868     #[inline]
format_rgba10x6_without_y_cb_cr_sampler( mut self, format_rgba10x6_without_y_cb_cr_sampler: bool, ) -> Self64869     pub fn format_rgba10x6_without_y_cb_cr_sampler(
64870         mut self,
64871         format_rgba10x6_without_y_cb_cr_sampler: bool,
64872     ) -> Self {
64873         self.inner.format_rgba10x6_without_y_cb_cr_sampler =
64874             format_rgba10x6_without_y_cb_cr_sampler.into();
64875         self
64876     }
64877     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
64878     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
64879     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceRGBA10X6FormatsFeaturesEXT64880     pub fn build(self) -> PhysicalDeviceRGBA10X6FormatsFeaturesEXT {
64881         self.inner
64882     }
64883 }
64884 #[repr(C)]
64885 #[cfg_attr(feature = "debug", derive(Debug))]
64886 #[derive(Copy, Clone)]
64887 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFormatProperties3.html>"]
64888 pub struct FormatProperties3 {
64889     pub s_type: StructureType,
64890     pub p_next: *mut c_void,
64891     pub linear_tiling_features: FormatFeatureFlags2,
64892     pub optimal_tiling_features: FormatFeatureFlags2,
64893     pub buffer_features: FormatFeatureFlags2,
64894 }
64895 impl ::std::default::Default for FormatProperties3 {
64896     #[inline]
default() -> Self64897     fn default() -> Self {
64898         Self {
64899             s_type: Self::STRUCTURE_TYPE,
64900             p_next: ::std::ptr::null_mut(),
64901             linear_tiling_features: FormatFeatureFlags2::default(),
64902             optimal_tiling_features: FormatFeatureFlags2::default(),
64903             buffer_features: FormatFeatureFlags2::default(),
64904         }
64905     }
64906 }
64907 unsafe impl TaggedStructure for FormatProperties3 {
64908     const STRUCTURE_TYPE: StructureType = StructureType::FORMAT_PROPERTIES_3;
64909 }
64910 impl FormatProperties3 {
builder<'a>() -> FormatProperties3Builder<'a>64911     pub fn builder<'a>() -> FormatProperties3Builder<'a> {
64912         FormatProperties3Builder {
64913             inner: Self::default(),
64914             marker: ::std::marker::PhantomData,
64915         }
64916     }
64917 }
64918 #[repr(transparent)]
64919 pub struct FormatProperties3Builder<'a> {
64920     inner: FormatProperties3,
64921     marker: ::std::marker::PhantomData<&'a ()>,
64922 }
64923 unsafe impl ExtendsFormatProperties2 for FormatProperties3Builder<'_> {}
64924 unsafe impl ExtendsFormatProperties2 for FormatProperties3 {}
64925 impl<'a> ::std::ops::Deref for FormatProperties3Builder<'a> {
64926     type Target = FormatProperties3;
deref(&self) -> &Self::Target64927     fn deref(&self) -> &Self::Target {
64928         &self.inner
64929     }
64930 }
64931 impl<'a> ::std::ops::DerefMut for FormatProperties3Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target64932     fn deref_mut(&mut self) -> &mut Self::Target {
64933         &mut self.inner
64934     }
64935 }
64936 impl<'a> FormatProperties3Builder<'a> {
64937     #[inline]
linear_tiling_features(mut self, linear_tiling_features: FormatFeatureFlags2) -> Self64938     pub fn linear_tiling_features(mut self, linear_tiling_features: FormatFeatureFlags2) -> Self {
64939         self.inner.linear_tiling_features = linear_tiling_features;
64940         self
64941     }
64942     #[inline]
optimal_tiling_features(mut self, optimal_tiling_features: FormatFeatureFlags2) -> Self64943     pub fn optimal_tiling_features(mut self, optimal_tiling_features: FormatFeatureFlags2) -> Self {
64944         self.inner.optimal_tiling_features = optimal_tiling_features;
64945         self
64946     }
64947     #[inline]
buffer_features(mut self, buffer_features: FormatFeatureFlags2) -> Self64948     pub fn buffer_features(mut self, buffer_features: FormatFeatureFlags2) -> Self {
64949         self.inner.buffer_features = buffer_features;
64950         self
64951     }
64952     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
64953     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
64954     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> FormatProperties364955     pub fn build(self) -> FormatProperties3 {
64956         self.inner
64957     }
64958 }
64959 #[repr(C)]
64960 #[cfg_attr(feature = "debug", derive(Debug))]
64961 #[derive(Copy, Clone)]
64962 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrmFormatModifierPropertiesList2EXT.html>"]
64963 pub struct DrmFormatModifierPropertiesList2EXT {
64964     pub s_type: StructureType,
64965     pub p_next: *mut c_void,
64966     pub drm_format_modifier_count: u32,
64967     pub p_drm_format_modifier_properties: *mut DrmFormatModifierProperties2EXT,
64968 }
64969 impl ::std::default::Default for DrmFormatModifierPropertiesList2EXT {
64970     #[inline]
default() -> Self64971     fn default() -> Self {
64972         Self {
64973             s_type: Self::STRUCTURE_TYPE,
64974             p_next: ::std::ptr::null_mut(),
64975             drm_format_modifier_count: u32::default(),
64976             p_drm_format_modifier_properties: ::std::ptr::null_mut(),
64977         }
64978     }
64979 }
64980 unsafe impl TaggedStructure for DrmFormatModifierPropertiesList2EXT {
64981     const STRUCTURE_TYPE: StructureType = StructureType::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT;
64982 }
64983 impl DrmFormatModifierPropertiesList2EXT {
builder<'a>() -> DrmFormatModifierPropertiesList2EXTBuilder<'a>64984     pub fn builder<'a>() -> DrmFormatModifierPropertiesList2EXTBuilder<'a> {
64985         DrmFormatModifierPropertiesList2EXTBuilder {
64986             inner: Self::default(),
64987             marker: ::std::marker::PhantomData,
64988         }
64989     }
64990 }
64991 #[repr(transparent)]
64992 pub struct DrmFormatModifierPropertiesList2EXTBuilder<'a> {
64993     inner: DrmFormatModifierPropertiesList2EXT,
64994     marker: ::std::marker::PhantomData<&'a ()>,
64995 }
64996 unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesList2EXTBuilder<'_> {}
64997 unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesList2EXT {}
64998 impl<'a> ::std::ops::Deref for DrmFormatModifierPropertiesList2EXTBuilder<'a> {
64999     type Target = DrmFormatModifierPropertiesList2EXT;
deref(&self) -> &Self::Target65000     fn deref(&self) -> &Self::Target {
65001         &self.inner
65002     }
65003 }
65004 impl<'a> ::std::ops::DerefMut for DrmFormatModifierPropertiesList2EXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target65005     fn deref_mut(&mut self) -> &mut Self::Target {
65006         &mut self.inner
65007     }
65008 }
65009 impl<'a> DrmFormatModifierPropertiesList2EXTBuilder<'a> {
65010     #[inline]
drm_format_modifier_properties( mut self, drm_format_modifier_properties: &'a mut [DrmFormatModifierProperties2EXT], ) -> Self65011     pub fn drm_format_modifier_properties(
65012         mut self,
65013         drm_format_modifier_properties: &'a mut [DrmFormatModifierProperties2EXT],
65014     ) -> Self {
65015         self.inner.drm_format_modifier_count = drm_format_modifier_properties.len() as _;
65016         self.inner.p_drm_format_modifier_properties = drm_format_modifier_properties.as_mut_ptr();
65017         self
65018     }
65019     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
65020     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
65021     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DrmFormatModifierPropertiesList2EXT65022     pub fn build(self) -> DrmFormatModifierPropertiesList2EXT {
65023         self.inner
65024     }
65025 }
65026 #[repr(C)]
65027 #[cfg_attr(feature = "debug", derive(Debug))]
65028 #[derive(Copy, Clone, Default)]
65029 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrmFormatModifierProperties2EXT.html>"]
65030 pub struct DrmFormatModifierProperties2EXT {
65031     pub drm_format_modifier: u64,
65032     pub drm_format_modifier_plane_count: u32,
65033     pub drm_format_modifier_tiling_features: FormatFeatureFlags2,
65034 }
65035 impl DrmFormatModifierProperties2EXT {
builder<'a>() -> DrmFormatModifierProperties2EXTBuilder<'a>65036     pub fn builder<'a>() -> DrmFormatModifierProperties2EXTBuilder<'a> {
65037         DrmFormatModifierProperties2EXTBuilder {
65038             inner: Self::default(),
65039             marker: ::std::marker::PhantomData,
65040         }
65041     }
65042 }
65043 #[repr(transparent)]
65044 pub struct DrmFormatModifierProperties2EXTBuilder<'a> {
65045     inner: DrmFormatModifierProperties2EXT,
65046     marker: ::std::marker::PhantomData<&'a ()>,
65047 }
65048 impl<'a> ::std::ops::Deref for DrmFormatModifierProperties2EXTBuilder<'a> {
65049     type Target = DrmFormatModifierProperties2EXT;
deref(&self) -> &Self::Target65050     fn deref(&self) -> &Self::Target {
65051         &self.inner
65052     }
65053 }
65054 impl<'a> ::std::ops::DerefMut for DrmFormatModifierProperties2EXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target65055     fn deref_mut(&mut self) -> &mut Self::Target {
65056         &mut self.inner
65057     }
65058 }
65059 impl<'a> DrmFormatModifierProperties2EXTBuilder<'a> {
65060     #[inline]
drm_format_modifier(mut self, drm_format_modifier: u64) -> Self65061     pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self {
65062         self.inner.drm_format_modifier = drm_format_modifier;
65063         self
65064     }
65065     #[inline]
drm_format_modifier_plane_count(mut self, drm_format_modifier_plane_count: u32) -> Self65066     pub fn drm_format_modifier_plane_count(mut self, drm_format_modifier_plane_count: u32) -> Self {
65067         self.inner.drm_format_modifier_plane_count = drm_format_modifier_plane_count;
65068         self
65069     }
65070     #[inline]
drm_format_modifier_tiling_features( mut self, drm_format_modifier_tiling_features: FormatFeatureFlags2, ) -> Self65071     pub fn drm_format_modifier_tiling_features(
65072         mut self,
65073         drm_format_modifier_tiling_features: FormatFeatureFlags2,
65074     ) -> Self {
65075         self.inner.drm_format_modifier_tiling_features = drm_format_modifier_tiling_features;
65076         self
65077     }
65078     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
65079     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
65080     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DrmFormatModifierProperties2EXT65081     pub fn build(self) -> DrmFormatModifierProperties2EXT {
65082         self.inner
65083     }
65084 }
65085 #[repr(C)]
65086 #[cfg_attr(feature = "debug", derive(Debug))]
65087 #[derive(Copy, Clone)]
65088 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAndroidHardwareBufferFormatProperties2ANDROID.html>"]
65089 pub struct AndroidHardwareBufferFormatProperties2ANDROID {
65090     pub s_type: StructureType,
65091     pub p_next: *mut c_void,
65092     pub format: Format,
65093     pub external_format: u64,
65094     pub format_features: FormatFeatureFlags2,
65095     pub sampler_ycbcr_conversion_components: ComponentMapping,
65096     pub suggested_ycbcr_model: SamplerYcbcrModelConversion,
65097     pub suggested_ycbcr_range: SamplerYcbcrRange,
65098     pub suggested_x_chroma_offset: ChromaLocation,
65099     pub suggested_y_chroma_offset: ChromaLocation,
65100 }
65101 impl ::std::default::Default for AndroidHardwareBufferFormatProperties2ANDROID {
65102     #[inline]
default() -> Self65103     fn default() -> Self {
65104         Self {
65105             s_type: Self::STRUCTURE_TYPE,
65106             p_next: ::std::ptr::null_mut(),
65107             format: Format::default(),
65108             external_format: u64::default(),
65109             format_features: FormatFeatureFlags2::default(),
65110             sampler_ycbcr_conversion_components: ComponentMapping::default(),
65111             suggested_ycbcr_model: SamplerYcbcrModelConversion::default(),
65112             suggested_ycbcr_range: SamplerYcbcrRange::default(),
65113             suggested_x_chroma_offset: ChromaLocation::default(),
65114             suggested_y_chroma_offset: ChromaLocation::default(),
65115         }
65116     }
65117 }
65118 unsafe impl TaggedStructure for AndroidHardwareBufferFormatProperties2ANDROID {
65119     const STRUCTURE_TYPE: StructureType =
65120         StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID;
65121 }
65122 impl AndroidHardwareBufferFormatProperties2ANDROID {
builder<'a>() -> AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a>65123     pub fn builder<'a>() -> AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> {
65124         AndroidHardwareBufferFormatProperties2ANDROIDBuilder {
65125             inner: Self::default(),
65126             marker: ::std::marker::PhantomData,
65127         }
65128     }
65129 }
65130 #[repr(transparent)]
65131 pub struct AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> {
65132     inner: AndroidHardwareBufferFormatProperties2ANDROID,
65133     marker: ::std::marker::PhantomData<&'a ()>,
65134 }
65135 unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID
65136     for AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'_>
65137 {
65138 }
65139 unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID
65140     for AndroidHardwareBufferFormatProperties2ANDROID
65141 {
65142 }
65143 impl<'a> ::std::ops::Deref for AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> {
65144     type Target = AndroidHardwareBufferFormatProperties2ANDROID;
deref(&self) -> &Self::Target65145     fn deref(&self) -> &Self::Target {
65146         &self.inner
65147     }
65148 }
65149 impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target65150     fn deref_mut(&mut self) -> &mut Self::Target {
65151         &mut self.inner
65152     }
65153 }
65154 impl<'a> AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> {
65155     #[inline]
format(mut self, format: Format) -> Self65156     pub fn format(mut self, format: Format) -> Self {
65157         self.inner.format = format;
65158         self
65159     }
65160     #[inline]
external_format(mut self, external_format: u64) -> Self65161     pub fn external_format(mut self, external_format: u64) -> Self {
65162         self.inner.external_format = external_format;
65163         self
65164     }
65165     #[inline]
format_features(mut self, format_features: FormatFeatureFlags2) -> Self65166     pub fn format_features(mut self, format_features: FormatFeatureFlags2) -> Self {
65167         self.inner.format_features = format_features;
65168         self
65169     }
65170     #[inline]
sampler_ycbcr_conversion_components( mut self, sampler_ycbcr_conversion_components: ComponentMapping, ) -> Self65171     pub fn sampler_ycbcr_conversion_components(
65172         mut self,
65173         sampler_ycbcr_conversion_components: ComponentMapping,
65174     ) -> Self {
65175         self.inner.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components;
65176         self
65177     }
65178     #[inline]
suggested_ycbcr_model( mut self, suggested_ycbcr_model: SamplerYcbcrModelConversion, ) -> Self65179     pub fn suggested_ycbcr_model(
65180         mut self,
65181         suggested_ycbcr_model: SamplerYcbcrModelConversion,
65182     ) -> Self {
65183         self.inner.suggested_ycbcr_model = suggested_ycbcr_model;
65184         self
65185     }
65186     #[inline]
suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self65187     pub fn suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self {
65188         self.inner.suggested_ycbcr_range = suggested_ycbcr_range;
65189         self
65190     }
65191     #[inline]
suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self65192     pub fn suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self {
65193         self.inner.suggested_x_chroma_offset = suggested_x_chroma_offset;
65194         self
65195     }
65196     #[inline]
suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self65197     pub fn suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self {
65198         self.inner.suggested_y_chroma_offset = suggested_y_chroma_offset;
65199         self
65200     }
65201     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
65202     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
65203     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AndroidHardwareBufferFormatProperties2ANDROID65204     pub fn build(self) -> AndroidHardwareBufferFormatProperties2ANDROID {
65205         self.inner
65206     }
65207 }
65208 #[repr(C)]
65209 #[cfg_attr(feature = "debug", derive(Debug))]
65210 #[derive(Copy, Clone)]
65211 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRenderingCreateInfo.html>"]
65212 pub struct PipelineRenderingCreateInfo {
65213     pub s_type: StructureType,
65214     pub p_next: *const c_void,
65215     pub view_mask: u32,
65216     pub color_attachment_count: u32,
65217     pub p_color_attachment_formats: *const Format,
65218     pub depth_attachment_format: Format,
65219     pub stencil_attachment_format: Format,
65220 }
65221 impl ::std::default::Default for PipelineRenderingCreateInfo {
65222     #[inline]
default() -> Self65223     fn default() -> Self {
65224         Self {
65225             s_type: Self::STRUCTURE_TYPE,
65226             p_next: ::std::ptr::null(),
65227             view_mask: u32::default(),
65228             color_attachment_count: u32::default(),
65229             p_color_attachment_formats: ::std::ptr::null(),
65230             depth_attachment_format: Format::default(),
65231             stencil_attachment_format: Format::default(),
65232         }
65233     }
65234 }
65235 unsafe impl TaggedStructure for PipelineRenderingCreateInfo {
65236     const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_RENDERING_CREATE_INFO;
65237 }
65238 impl PipelineRenderingCreateInfo {
builder<'a>() -> PipelineRenderingCreateInfoBuilder<'a>65239     pub fn builder<'a>() -> PipelineRenderingCreateInfoBuilder<'a> {
65240         PipelineRenderingCreateInfoBuilder {
65241             inner: Self::default(),
65242             marker: ::std::marker::PhantomData,
65243         }
65244     }
65245 }
65246 #[repr(transparent)]
65247 pub struct PipelineRenderingCreateInfoBuilder<'a> {
65248     inner: PipelineRenderingCreateInfo,
65249     marker: ::std::marker::PhantomData<&'a ()>,
65250 }
65251 unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRenderingCreateInfoBuilder<'_> {}
65252 unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRenderingCreateInfo {}
65253 impl<'a> ::std::ops::Deref for PipelineRenderingCreateInfoBuilder<'a> {
65254     type Target = PipelineRenderingCreateInfo;
deref(&self) -> &Self::Target65255     fn deref(&self) -> &Self::Target {
65256         &self.inner
65257     }
65258 }
65259 impl<'a> ::std::ops::DerefMut for PipelineRenderingCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target65260     fn deref_mut(&mut self) -> &mut Self::Target {
65261         &mut self.inner
65262     }
65263 }
65264 impl<'a> PipelineRenderingCreateInfoBuilder<'a> {
65265     #[inline]
view_mask(mut self, view_mask: u32) -> Self65266     pub fn view_mask(mut self, view_mask: u32) -> Self {
65267         self.inner.view_mask = view_mask;
65268         self
65269     }
65270     #[inline]
color_attachment_formats(mut self, color_attachment_formats: &'a [Format]) -> Self65271     pub fn color_attachment_formats(mut self, color_attachment_formats: &'a [Format]) -> Self {
65272         self.inner.color_attachment_count = color_attachment_formats.len() as _;
65273         self.inner.p_color_attachment_formats = color_attachment_formats.as_ptr();
65274         self
65275     }
65276     #[inline]
depth_attachment_format(mut self, depth_attachment_format: Format) -> Self65277     pub fn depth_attachment_format(mut self, depth_attachment_format: Format) -> Self {
65278         self.inner.depth_attachment_format = depth_attachment_format;
65279         self
65280     }
65281     #[inline]
stencil_attachment_format(mut self, stencil_attachment_format: Format) -> Self65282     pub fn stencil_attachment_format(mut self, stencil_attachment_format: Format) -> Self {
65283         self.inner.stencil_attachment_format = stencil_attachment_format;
65284         self
65285     }
65286     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
65287     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
65288     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineRenderingCreateInfo65289     pub fn build(self) -> PipelineRenderingCreateInfo {
65290         self.inner
65291     }
65292 }
65293 #[repr(C)]
65294 #[cfg_attr(feature = "debug", derive(Debug))]
65295 #[derive(Copy, Clone)]
65296 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderingInfo.html>"]
65297 pub struct RenderingInfo {
65298     pub s_type: StructureType,
65299     pub p_next: *const c_void,
65300     pub flags: RenderingFlags,
65301     pub render_area: Rect2D,
65302     pub layer_count: u32,
65303     pub view_mask: u32,
65304     pub color_attachment_count: u32,
65305     pub p_color_attachments: *const RenderingAttachmentInfo,
65306     pub p_depth_attachment: *const RenderingAttachmentInfo,
65307     pub p_stencil_attachment: *const RenderingAttachmentInfo,
65308 }
65309 impl ::std::default::Default for RenderingInfo {
65310     #[inline]
default() -> Self65311     fn default() -> Self {
65312         Self {
65313             s_type: Self::STRUCTURE_TYPE,
65314             p_next: ::std::ptr::null(),
65315             flags: RenderingFlags::default(),
65316             render_area: Rect2D::default(),
65317             layer_count: u32::default(),
65318             view_mask: u32::default(),
65319             color_attachment_count: u32::default(),
65320             p_color_attachments: ::std::ptr::null(),
65321             p_depth_attachment: ::std::ptr::null(),
65322             p_stencil_attachment: ::std::ptr::null(),
65323         }
65324     }
65325 }
65326 unsafe impl TaggedStructure for RenderingInfo {
65327     const STRUCTURE_TYPE: StructureType = StructureType::RENDERING_INFO;
65328 }
65329 impl RenderingInfo {
builder<'a>() -> RenderingInfoBuilder<'a>65330     pub fn builder<'a>() -> RenderingInfoBuilder<'a> {
65331         RenderingInfoBuilder {
65332             inner: Self::default(),
65333             marker: ::std::marker::PhantomData,
65334         }
65335     }
65336 }
65337 #[repr(transparent)]
65338 pub struct RenderingInfoBuilder<'a> {
65339     inner: RenderingInfo,
65340     marker: ::std::marker::PhantomData<&'a ()>,
65341 }
65342 pub unsafe trait ExtendsRenderingInfo {}
65343 impl<'a> ::std::ops::Deref for RenderingInfoBuilder<'a> {
65344     type Target = RenderingInfo;
deref(&self) -> &Self::Target65345     fn deref(&self) -> &Self::Target {
65346         &self.inner
65347     }
65348 }
65349 impl<'a> ::std::ops::DerefMut for RenderingInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target65350     fn deref_mut(&mut self) -> &mut Self::Target {
65351         &mut self.inner
65352     }
65353 }
65354 impl<'a> RenderingInfoBuilder<'a> {
65355     #[inline]
flags(mut self, flags: RenderingFlags) -> Self65356     pub fn flags(mut self, flags: RenderingFlags) -> Self {
65357         self.inner.flags = flags;
65358         self
65359     }
65360     #[inline]
render_area(mut self, render_area: Rect2D) -> Self65361     pub fn render_area(mut self, render_area: Rect2D) -> Self {
65362         self.inner.render_area = render_area;
65363         self
65364     }
65365     #[inline]
layer_count(mut self, layer_count: u32) -> Self65366     pub fn layer_count(mut self, layer_count: u32) -> Self {
65367         self.inner.layer_count = layer_count;
65368         self
65369     }
65370     #[inline]
view_mask(mut self, view_mask: u32) -> Self65371     pub fn view_mask(mut self, view_mask: u32) -> Self {
65372         self.inner.view_mask = view_mask;
65373         self
65374     }
65375     #[inline]
color_attachments(mut self, color_attachments: &'a [RenderingAttachmentInfo]) -> Self65376     pub fn color_attachments(mut self, color_attachments: &'a [RenderingAttachmentInfo]) -> Self {
65377         self.inner.color_attachment_count = color_attachments.len() as _;
65378         self.inner.p_color_attachments = color_attachments.as_ptr();
65379         self
65380     }
65381     #[inline]
depth_attachment(mut self, depth_attachment: &'a RenderingAttachmentInfo) -> Self65382     pub fn depth_attachment(mut self, depth_attachment: &'a RenderingAttachmentInfo) -> Self {
65383         self.inner.p_depth_attachment = depth_attachment;
65384         self
65385     }
65386     #[inline]
stencil_attachment(mut self, stencil_attachment: &'a RenderingAttachmentInfo) -> Self65387     pub fn stencil_attachment(mut self, stencil_attachment: &'a RenderingAttachmentInfo) -> Self {
65388         self.inner.p_stencil_attachment = stencil_attachment;
65389         self
65390     }
65391     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
65392     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
65393     #[doc = r" valid extension structs can be pushed into the chain."]
65394     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
65395     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsRenderingInfo>(mut self, next: &'a mut T) -> Self65396     pub fn push_next<T: ExtendsRenderingInfo>(mut self, next: &'a mut T) -> Self {
65397         unsafe {
65398             let next_ptr = <*const T>::cast(next);
65399             let last_next = ptr_chain_iter(next).last().unwrap();
65400             (*last_next).p_next = self.inner.p_next as _;
65401             self.inner.p_next = next_ptr;
65402         }
65403         self
65404     }
65405     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
65406     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
65407     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RenderingInfo65408     pub fn build(self) -> RenderingInfo {
65409         self.inner
65410     }
65411 }
65412 #[repr(C)]
65413 #[derive(Copy, Clone)]
65414 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderingAttachmentInfo.html>"]
65415 pub struct RenderingAttachmentInfo {
65416     pub s_type: StructureType,
65417     pub p_next: *const c_void,
65418     pub image_view: ImageView,
65419     pub image_layout: ImageLayout,
65420     pub resolve_mode: ResolveModeFlags,
65421     pub resolve_image_view: ImageView,
65422     pub resolve_image_layout: ImageLayout,
65423     pub load_op: AttachmentLoadOp,
65424     pub store_op: AttachmentStoreOp,
65425     pub clear_value: ClearValue,
65426 }
65427 #[cfg(feature = "debug")]
65428 impl fmt::Debug for RenderingAttachmentInfo {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result65429     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
65430         fmt.debug_struct("RenderingAttachmentInfo")
65431             .field("s_type", &self.s_type)
65432             .field("p_next", &self.p_next)
65433             .field("image_view", &self.image_view)
65434             .field("image_layout", &self.image_layout)
65435             .field("resolve_mode", &self.resolve_mode)
65436             .field("resolve_image_view", &self.resolve_image_view)
65437             .field("resolve_image_layout", &self.resolve_image_layout)
65438             .field("load_op", &self.load_op)
65439             .field("store_op", &self.store_op)
65440             .field("clear_value", &"union")
65441             .finish()
65442     }
65443 }
65444 impl ::std::default::Default for RenderingAttachmentInfo {
65445     #[inline]
default() -> Self65446     fn default() -> Self {
65447         Self {
65448             s_type: Self::STRUCTURE_TYPE,
65449             p_next: ::std::ptr::null(),
65450             image_view: ImageView::default(),
65451             image_layout: ImageLayout::default(),
65452             resolve_mode: ResolveModeFlags::default(),
65453             resolve_image_view: ImageView::default(),
65454             resolve_image_layout: ImageLayout::default(),
65455             load_op: AttachmentLoadOp::default(),
65456             store_op: AttachmentStoreOp::default(),
65457             clear_value: ClearValue::default(),
65458         }
65459     }
65460 }
65461 unsafe impl TaggedStructure for RenderingAttachmentInfo {
65462     const STRUCTURE_TYPE: StructureType = StructureType::RENDERING_ATTACHMENT_INFO;
65463 }
65464 impl RenderingAttachmentInfo {
builder<'a>() -> RenderingAttachmentInfoBuilder<'a>65465     pub fn builder<'a>() -> RenderingAttachmentInfoBuilder<'a> {
65466         RenderingAttachmentInfoBuilder {
65467             inner: Self::default(),
65468             marker: ::std::marker::PhantomData,
65469         }
65470     }
65471 }
65472 #[repr(transparent)]
65473 pub struct RenderingAttachmentInfoBuilder<'a> {
65474     inner: RenderingAttachmentInfo,
65475     marker: ::std::marker::PhantomData<&'a ()>,
65476 }
65477 impl<'a> ::std::ops::Deref for RenderingAttachmentInfoBuilder<'a> {
65478     type Target = RenderingAttachmentInfo;
deref(&self) -> &Self::Target65479     fn deref(&self) -> &Self::Target {
65480         &self.inner
65481     }
65482 }
65483 impl<'a> ::std::ops::DerefMut for RenderingAttachmentInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target65484     fn deref_mut(&mut self) -> &mut Self::Target {
65485         &mut self.inner
65486     }
65487 }
65488 impl<'a> RenderingAttachmentInfoBuilder<'a> {
65489     #[inline]
image_view(mut self, image_view: ImageView) -> Self65490     pub fn image_view(mut self, image_view: ImageView) -> Self {
65491         self.inner.image_view = image_view;
65492         self
65493     }
65494     #[inline]
image_layout(mut self, image_layout: ImageLayout) -> Self65495     pub fn image_layout(mut self, image_layout: ImageLayout) -> Self {
65496         self.inner.image_layout = image_layout;
65497         self
65498     }
65499     #[inline]
resolve_mode(mut self, resolve_mode: ResolveModeFlags) -> Self65500     pub fn resolve_mode(mut self, resolve_mode: ResolveModeFlags) -> Self {
65501         self.inner.resolve_mode = resolve_mode;
65502         self
65503     }
65504     #[inline]
resolve_image_view(mut self, resolve_image_view: ImageView) -> Self65505     pub fn resolve_image_view(mut self, resolve_image_view: ImageView) -> Self {
65506         self.inner.resolve_image_view = resolve_image_view;
65507         self
65508     }
65509     #[inline]
resolve_image_layout(mut self, resolve_image_layout: ImageLayout) -> Self65510     pub fn resolve_image_layout(mut self, resolve_image_layout: ImageLayout) -> Self {
65511         self.inner.resolve_image_layout = resolve_image_layout;
65512         self
65513     }
65514     #[inline]
load_op(mut self, load_op: AttachmentLoadOp) -> Self65515     pub fn load_op(mut self, load_op: AttachmentLoadOp) -> Self {
65516         self.inner.load_op = load_op;
65517         self
65518     }
65519     #[inline]
store_op(mut self, store_op: AttachmentStoreOp) -> Self65520     pub fn store_op(mut self, store_op: AttachmentStoreOp) -> Self {
65521         self.inner.store_op = store_op;
65522         self
65523     }
65524     #[inline]
clear_value(mut self, clear_value: ClearValue) -> Self65525     pub fn clear_value(mut self, clear_value: ClearValue) -> Self {
65526         self.inner.clear_value = clear_value;
65527         self
65528     }
65529     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
65530     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
65531     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RenderingAttachmentInfo65532     pub fn build(self) -> RenderingAttachmentInfo {
65533         self.inner
65534     }
65535 }
65536 #[repr(C)]
65537 #[cfg_attr(feature = "debug", derive(Debug))]
65538 #[derive(Copy, Clone)]
65539 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderingFragmentShadingRateAttachmentInfoKHR.html>"]
65540 pub struct RenderingFragmentShadingRateAttachmentInfoKHR {
65541     pub s_type: StructureType,
65542     pub p_next: *const c_void,
65543     pub image_view: ImageView,
65544     pub image_layout: ImageLayout,
65545     pub shading_rate_attachment_texel_size: Extent2D,
65546 }
65547 impl ::std::default::Default for RenderingFragmentShadingRateAttachmentInfoKHR {
65548     #[inline]
default() -> Self65549     fn default() -> Self {
65550         Self {
65551             s_type: Self::STRUCTURE_TYPE,
65552             p_next: ::std::ptr::null(),
65553             image_view: ImageView::default(),
65554             image_layout: ImageLayout::default(),
65555             shading_rate_attachment_texel_size: Extent2D::default(),
65556         }
65557     }
65558 }
65559 unsafe impl TaggedStructure for RenderingFragmentShadingRateAttachmentInfoKHR {
65560     const STRUCTURE_TYPE: StructureType =
65561         StructureType::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR;
65562 }
65563 impl RenderingFragmentShadingRateAttachmentInfoKHR {
builder<'a>() -> RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a>65564     pub fn builder<'a>() -> RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> {
65565         RenderingFragmentShadingRateAttachmentInfoKHRBuilder {
65566             inner: Self::default(),
65567             marker: ::std::marker::PhantomData,
65568         }
65569     }
65570 }
65571 #[repr(transparent)]
65572 pub struct RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> {
65573     inner: RenderingFragmentShadingRateAttachmentInfoKHR,
65574     marker: ::std::marker::PhantomData<&'a ()>,
65575 }
65576 unsafe impl ExtendsRenderingInfo for RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'_> {}
65577 unsafe impl ExtendsRenderingInfo for RenderingFragmentShadingRateAttachmentInfoKHR {}
65578 impl<'a> ::std::ops::Deref for RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> {
65579     type Target = RenderingFragmentShadingRateAttachmentInfoKHR;
deref(&self) -> &Self::Target65580     fn deref(&self) -> &Self::Target {
65581         &self.inner
65582     }
65583 }
65584 impl<'a> ::std::ops::DerefMut for RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target65585     fn deref_mut(&mut self) -> &mut Self::Target {
65586         &mut self.inner
65587     }
65588 }
65589 impl<'a> RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> {
65590     #[inline]
image_view(mut self, image_view: ImageView) -> Self65591     pub fn image_view(mut self, image_view: ImageView) -> Self {
65592         self.inner.image_view = image_view;
65593         self
65594     }
65595     #[inline]
image_layout(mut self, image_layout: ImageLayout) -> Self65596     pub fn image_layout(mut self, image_layout: ImageLayout) -> Self {
65597         self.inner.image_layout = image_layout;
65598         self
65599     }
65600     #[inline]
shading_rate_attachment_texel_size( mut self, shading_rate_attachment_texel_size: Extent2D, ) -> Self65601     pub fn shading_rate_attachment_texel_size(
65602         mut self,
65603         shading_rate_attachment_texel_size: Extent2D,
65604     ) -> Self {
65605         self.inner.shading_rate_attachment_texel_size = shading_rate_attachment_texel_size;
65606         self
65607     }
65608     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
65609     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
65610     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RenderingFragmentShadingRateAttachmentInfoKHR65611     pub fn build(self) -> RenderingFragmentShadingRateAttachmentInfoKHR {
65612         self.inner
65613     }
65614 }
65615 #[repr(C)]
65616 #[cfg_attr(feature = "debug", derive(Debug))]
65617 #[derive(Copy, Clone)]
65618 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderingFragmentDensityMapAttachmentInfoEXT.html>"]
65619 pub struct RenderingFragmentDensityMapAttachmentInfoEXT {
65620     pub s_type: StructureType,
65621     pub p_next: *const c_void,
65622     pub image_view: ImageView,
65623     pub image_layout: ImageLayout,
65624 }
65625 impl ::std::default::Default for RenderingFragmentDensityMapAttachmentInfoEXT {
65626     #[inline]
default() -> Self65627     fn default() -> Self {
65628         Self {
65629             s_type: Self::STRUCTURE_TYPE,
65630             p_next: ::std::ptr::null(),
65631             image_view: ImageView::default(),
65632             image_layout: ImageLayout::default(),
65633         }
65634     }
65635 }
65636 unsafe impl TaggedStructure for RenderingFragmentDensityMapAttachmentInfoEXT {
65637     const STRUCTURE_TYPE: StructureType =
65638         StructureType::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT;
65639 }
65640 impl RenderingFragmentDensityMapAttachmentInfoEXT {
builder<'a>() -> RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a>65641     pub fn builder<'a>() -> RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> {
65642         RenderingFragmentDensityMapAttachmentInfoEXTBuilder {
65643             inner: Self::default(),
65644             marker: ::std::marker::PhantomData,
65645         }
65646     }
65647 }
65648 #[repr(transparent)]
65649 pub struct RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> {
65650     inner: RenderingFragmentDensityMapAttachmentInfoEXT,
65651     marker: ::std::marker::PhantomData<&'a ()>,
65652 }
65653 unsafe impl ExtendsRenderingInfo for RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'_> {}
65654 unsafe impl ExtendsRenderingInfo for RenderingFragmentDensityMapAttachmentInfoEXT {}
65655 impl<'a> ::std::ops::Deref for RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> {
65656     type Target = RenderingFragmentDensityMapAttachmentInfoEXT;
deref(&self) -> &Self::Target65657     fn deref(&self) -> &Self::Target {
65658         &self.inner
65659     }
65660 }
65661 impl<'a> ::std::ops::DerefMut for RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target65662     fn deref_mut(&mut self) -> &mut Self::Target {
65663         &mut self.inner
65664     }
65665 }
65666 impl<'a> RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> {
65667     #[inline]
image_view(mut self, image_view: ImageView) -> Self65668     pub fn image_view(mut self, image_view: ImageView) -> Self {
65669         self.inner.image_view = image_view;
65670         self
65671     }
65672     #[inline]
image_layout(mut self, image_layout: ImageLayout) -> Self65673     pub fn image_layout(mut self, image_layout: ImageLayout) -> Self {
65674         self.inner.image_layout = image_layout;
65675         self
65676     }
65677     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
65678     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
65679     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RenderingFragmentDensityMapAttachmentInfoEXT65680     pub fn build(self) -> RenderingFragmentDensityMapAttachmentInfoEXT {
65681         self.inner
65682     }
65683 }
65684 #[repr(C)]
65685 #[cfg_attr(feature = "debug", derive(Debug))]
65686 #[derive(Copy, Clone)]
65687 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDynamicRenderingFeatures.html>"]
65688 pub struct PhysicalDeviceDynamicRenderingFeatures {
65689     pub s_type: StructureType,
65690     pub p_next: *mut c_void,
65691     pub dynamic_rendering: Bool32,
65692 }
65693 impl ::std::default::Default for PhysicalDeviceDynamicRenderingFeatures {
65694     #[inline]
default() -> Self65695     fn default() -> Self {
65696         Self {
65697             s_type: Self::STRUCTURE_TYPE,
65698             p_next: ::std::ptr::null_mut(),
65699             dynamic_rendering: Bool32::default(),
65700         }
65701     }
65702 }
65703 unsafe impl TaggedStructure for PhysicalDeviceDynamicRenderingFeatures {
65704     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
65705 }
65706 impl PhysicalDeviceDynamicRenderingFeatures {
builder<'a>() -> PhysicalDeviceDynamicRenderingFeaturesBuilder<'a>65707     pub fn builder<'a>() -> PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> {
65708         PhysicalDeviceDynamicRenderingFeaturesBuilder {
65709             inner: Self::default(),
65710             marker: ::std::marker::PhantomData,
65711         }
65712     }
65713 }
65714 #[repr(transparent)]
65715 pub struct PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> {
65716     inner: PhysicalDeviceDynamicRenderingFeatures,
65717     marker: ::std::marker::PhantomData<&'a ()>,
65718 }
65719 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDynamicRenderingFeaturesBuilder<'_> {}
65720 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDynamicRenderingFeatures {}
65721 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDynamicRenderingFeaturesBuilder<'_> {}
65722 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDynamicRenderingFeatures {}
65723 impl<'a> ::std::ops::Deref for PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> {
65724     type Target = PhysicalDeviceDynamicRenderingFeatures;
deref(&self) -> &Self::Target65725     fn deref(&self) -> &Self::Target {
65726         &self.inner
65727     }
65728 }
65729 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target65730     fn deref_mut(&mut self) -> &mut Self::Target {
65731         &mut self.inner
65732     }
65733 }
65734 impl<'a> PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> {
65735     #[inline]
dynamic_rendering(mut self, dynamic_rendering: bool) -> Self65736     pub fn dynamic_rendering(mut self, dynamic_rendering: bool) -> Self {
65737         self.inner.dynamic_rendering = dynamic_rendering.into();
65738         self
65739     }
65740     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
65741     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
65742     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDynamicRenderingFeatures65743     pub fn build(self) -> PhysicalDeviceDynamicRenderingFeatures {
65744         self.inner
65745     }
65746 }
65747 #[repr(C)]
65748 #[cfg_attr(feature = "debug", derive(Debug))]
65749 #[derive(Copy, Clone)]
65750 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferInheritanceRenderingInfo.html>"]
65751 pub struct CommandBufferInheritanceRenderingInfo {
65752     pub s_type: StructureType,
65753     pub p_next: *const c_void,
65754     pub flags: RenderingFlags,
65755     pub view_mask: u32,
65756     pub color_attachment_count: u32,
65757     pub p_color_attachment_formats: *const Format,
65758     pub depth_attachment_format: Format,
65759     pub stencil_attachment_format: Format,
65760     pub rasterization_samples: SampleCountFlags,
65761 }
65762 impl ::std::default::Default for CommandBufferInheritanceRenderingInfo {
65763     #[inline]
default() -> Self65764     fn default() -> Self {
65765         Self {
65766             s_type: Self::STRUCTURE_TYPE,
65767             p_next: ::std::ptr::null(),
65768             flags: RenderingFlags::default(),
65769             view_mask: u32::default(),
65770             color_attachment_count: u32::default(),
65771             p_color_attachment_formats: ::std::ptr::null(),
65772             depth_attachment_format: Format::default(),
65773             stencil_attachment_format: Format::default(),
65774             rasterization_samples: SampleCountFlags::default(),
65775         }
65776     }
65777 }
65778 unsafe impl TaggedStructure for CommandBufferInheritanceRenderingInfo {
65779     const STRUCTURE_TYPE: StructureType = StructureType::COMMAND_BUFFER_INHERITANCE_RENDERING_INFO;
65780 }
65781 impl CommandBufferInheritanceRenderingInfo {
builder<'a>() -> CommandBufferInheritanceRenderingInfoBuilder<'a>65782     pub fn builder<'a>() -> CommandBufferInheritanceRenderingInfoBuilder<'a> {
65783         CommandBufferInheritanceRenderingInfoBuilder {
65784             inner: Self::default(),
65785             marker: ::std::marker::PhantomData,
65786         }
65787     }
65788 }
65789 #[repr(transparent)]
65790 pub struct CommandBufferInheritanceRenderingInfoBuilder<'a> {
65791     inner: CommandBufferInheritanceRenderingInfo,
65792     marker: ::std::marker::PhantomData<&'a ()>,
65793 }
65794 unsafe impl ExtendsCommandBufferInheritanceInfo
65795     for CommandBufferInheritanceRenderingInfoBuilder<'_>
65796 {
65797 }
65798 unsafe impl ExtendsCommandBufferInheritanceInfo for CommandBufferInheritanceRenderingInfo {}
65799 impl<'a> ::std::ops::Deref for CommandBufferInheritanceRenderingInfoBuilder<'a> {
65800     type Target = CommandBufferInheritanceRenderingInfo;
deref(&self) -> &Self::Target65801     fn deref(&self) -> &Self::Target {
65802         &self.inner
65803     }
65804 }
65805 impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceRenderingInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target65806     fn deref_mut(&mut self) -> &mut Self::Target {
65807         &mut self.inner
65808     }
65809 }
65810 impl<'a> CommandBufferInheritanceRenderingInfoBuilder<'a> {
65811     #[inline]
flags(mut self, flags: RenderingFlags) -> Self65812     pub fn flags(mut self, flags: RenderingFlags) -> Self {
65813         self.inner.flags = flags;
65814         self
65815     }
65816     #[inline]
view_mask(mut self, view_mask: u32) -> Self65817     pub fn view_mask(mut self, view_mask: u32) -> Self {
65818         self.inner.view_mask = view_mask;
65819         self
65820     }
65821     #[inline]
color_attachment_formats(mut self, color_attachment_formats: &'a [Format]) -> Self65822     pub fn color_attachment_formats(mut self, color_attachment_formats: &'a [Format]) -> Self {
65823         self.inner.color_attachment_count = color_attachment_formats.len() as _;
65824         self.inner.p_color_attachment_formats = color_attachment_formats.as_ptr();
65825         self
65826     }
65827     #[inline]
depth_attachment_format(mut self, depth_attachment_format: Format) -> Self65828     pub fn depth_attachment_format(mut self, depth_attachment_format: Format) -> Self {
65829         self.inner.depth_attachment_format = depth_attachment_format;
65830         self
65831     }
65832     #[inline]
stencil_attachment_format(mut self, stencil_attachment_format: Format) -> Self65833     pub fn stencil_attachment_format(mut self, stencil_attachment_format: Format) -> Self {
65834         self.inner.stencil_attachment_format = stencil_attachment_format;
65835         self
65836     }
65837     #[inline]
rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self65838     pub fn rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self {
65839         self.inner.rasterization_samples = rasterization_samples;
65840         self
65841     }
65842     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
65843     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
65844     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CommandBufferInheritanceRenderingInfo65845     pub fn build(self) -> CommandBufferInheritanceRenderingInfo {
65846         self.inner
65847     }
65848 }
65849 #[repr(C)]
65850 #[cfg_attr(feature = "debug", derive(Debug))]
65851 #[derive(Copy, Clone)]
65852 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentSampleCountInfoAMD.html>"]
65853 pub struct AttachmentSampleCountInfoAMD {
65854     pub s_type: StructureType,
65855     pub p_next: *const c_void,
65856     pub color_attachment_count: u32,
65857     pub p_color_attachment_samples: *const SampleCountFlags,
65858     pub depth_stencil_attachment_samples: SampleCountFlags,
65859 }
65860 impl ::std::default::Default for AttachmentSampleCountInfoAMD {
65861     #[inline]
default() -> Self65862     fn default() -> Self {
65863         Self {
65864             s_type: Self::STRUCTURE_TYPE,
65865             p_next: ::std::ptr::null(),
65866             color_attachment_count: u32::default(),
65867             p_color_attachment_samples: ::std::ptr::null(),
65868             depth_stencil_attachment_samples: SampleCountFlags::default(),
65869         }
65870     }
65871 }
65872 unsafe impl TaggedStructure for AttachmentSampleCountInfoAMD {
65873     const STRUCTURE_TYPE: StructureType = StructureType::ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
65874 }
65875 impl AttachmentSampleCountInfoAMD {
builder<'a>() -> AttachmentSampleCountInfoAMDBuilder<'a>65876     pub fn builder<'a>() -> AttachmentSampleCountInfoAMDBuilder<'a> {
65877         AttachmentSampleCountInfoAMDBuilder {
65878             inner: Self::default(),
65879             marker: ::std::marker::PhantomData,
65880         }
65881     }
65882 }
65883 #[repr(transparent)]
65884 pub struct AttachmentSampleCountInfoAMDBuilder<'a> {
65885     inner: AttachmentSampleCountInfoAMD,
65886     marker: ::std::marker::PhantomData<&'a ()>,
65887 }
65888 unsafe impl ExtendsCommandBufferInheritanceInfo for AttachmentSampleCountInfoAMDBuilder<'_> {}
65889 unsafe impl ExtendsCommandBufferInheritanceInfo for AttachmentSampleCountInfoAMD {}
65890 unsafe impl ExtendsGraphicsPipelineCreateInfo for AttachmentSampleCountInfoAMDBuilder<'_> {}
65891 unsafe impl ExtendsGraphicsPipelineCreateInfo for AttachmentSampleCountInfoAMD {}
65892 impl<'a> ::std::ops::Deref for AttachmentSampleCountInfoAMDBuilder<'a> {
65893     type Target = AttachmentSampleCountInfoAMD;
deref(&self) -> &Self::Target65894     fn deref(&self) -> &Self::Target {
65895         &self.inner
65896     }
65897 }
65898 impl<'a> ::std::ops::DerefMut for AttachmentSampleCountInfoAMDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target65899     fn deref_mut(&mut self) -> &mut Self::Target {
65900         &mut self.inner
65901     }
65902 }
65903 impl<'a> AttachmentSampleCountInfoAMDBuilder<'a> {
65904     #[inline]
color_attachment_samples( mut self, color_attachment_samples: &'a [SampleCountFlags], ) -> Self65905     pub fn color_attachment_samples(
65906         mut self,
65907         color_attachment_samples: &'a [SampleCountFlags],
65908     ) -> Self {
65909         self.inner.color_attachment_count = color_attachment_samples.len() as _;
65910         self.inner.p_color_attachment_samples = color_attachment_samples.as_ptr();
65911         self
65912     }
65913     #[inline]
depth_stencil_attachment_samples( mut self, depth_stencil_attachment_samples: SampleCountFlags, ) -> Self65914     pub fn depth_stencil_attachment_samples(
65915         mut self,
65916         depth_stencil_attachment_samples: SampleCountFlags,
65917     ) -> Self {
65918         self.inner.depth_stencil_attachment_samples = depth_stencil_attachment_samples;
65919         self
65920     }
65921     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
65922     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
65923     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AttachmentSampleCountInfoAMD65924     pub fn build(self) -> AttachmentSampleCountInfoAMD {
65925         self.inner
65926     }
65927 }
65928 #[repr(C)]
65929 #[cfg_attr(feature = "debug", derive(Debug))]
65930 #[derive(Copy, Clone)]
65931 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMultiviewPerViewAttributesInfoNVX.html>"]
65932 pub struct MultiviewPerViewAttributesInfoNVX {
65933     pub s_type: StructureType,
65934     pub p_next: *const c_void,
65935     pub per_view_attributes: Bool32,
65936     pub per_view_attributes_position_x_only: Bool32,
65937 }
65938 impl ::std::default::Default for MultiviewPerViewAttributesInfoNVX {
65939     #[inline]
default() -> Self65940     fn default() -> Self {
65941         Self {
65942             s_type: Self::STRUCTURE_TYPE,
65943             p_next: ::std::ptr::null(),
65944             per_view_attributes: Bool32::default(),
65945             per_view_attributes_position_x_only: Bool32::default(),
65946         }
65947     }
65948 }
65949 unsafe impl TaggedStructure for MultiviewPerViewAttributesInfoNVX {
65950     const STRUCTURE_TYPE: StructureType = StructureType::MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX;
65951 }
65952 impl MultiviewPerViewAttributesInfoNVX {
builder<'a>() -> MultiviewPerViewAttributesInfoNVXBuilder<'a>65953     pub fn builder<'a>() -> MultiviewPerViewAttributesInfoNVXBuilder<'a> {
65954         MultiviewPerViewAttributesInfoNVXBuilder {
65955             inner: Self::default(),
65956             marker: ::std::marker::PhantomData,
65957         }
65958     }
65959 }
65960 #[repr(transparent)]
65961 pub struct MultiviewPerViewAttributesInfoNVXBuilder<'a> {
65962     inner: MultiviewPerViewAttributesInfoNVX,
65963     marker: ::std::marker::PhantomData<&'a ()>,
65964 }
65965 unsafe impl ExtendsCommandBufferInheritanceInfo for MultiviewPerViewAttributesInfoNVXBuilder<'_> {}
65966 unsafe impl ExtendsCommandBufferInheritanceInfo for MultiviewPerViewAttributesInfoNVX {}
65967 unsafe impl ExtendsGraphicsPipelineCreateInfo for MultiviewPerViewAttributesInfoNVXBuilder<'_> {}
65968 unsafe impl ExtendsGraphicsPipelineCreateInfo for MultiviewPerViewAttributesInfoNVX {}
65969 unsafe impl ExtendsRenderingInfo for MultiviewPerViewAttributesInfoNVXBuilder<'_> {}
65970 unsafe impl ExtendsRenderingInfo for MultiviewPerViewAttributesInfoNVX {}
65971 impl<'a> ::std::ops::Deref for MultiviewPerViewAttributesInfoNVXBuilder<'a> {
65972     type Target = MultiviewPerViewAttributesInfoNVX;
deref(&self) -> &Self::Target65973     fn deref(&self) -> &Self::Target {
65974         &self.inner
65975     }
65976 }
65977 impl<'a> ::std::ops::DerefMut for MultiviewPerViewAttributesInfoNVXBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target65978     fn deref_mut(&mut self) -> &mut Self::Target {
65979         &mut self.inner
65980     }
65981 }
65982 impl<'a> MultiviewPerViewAttributesInfoNVXBuilder<'a> {
65983     #[inline]
per_view_attributes(mut self, per_view_attributes: bool) -> Self65984     pub fn per_view_attributes(mut self, per_view_attributes: bool) -> Self {
65985         self.inner.per_view_attributes = per_view_attributes.into();
65986         self
65987     }
65988     #[inline]
per_view_attributes_position_x_only( mut self, per_view_attributes_position_x_only: bool, ) -> Self65989     pub fn per_view_attributes_position_x_only(
65990         mut self,
65991         per_view_attributes_position_x_only: bool,
65992     ) -> Self {
65993         self.inner.per_view_attributes_position_x_only = per_view_attributes_position_x_only.into();
65994         self
65995     }
65996     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
65997     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
65998     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MultiviewPerViewAttributesInfoNVX65999     pub fn build(self) -> MultiviewPerViewAttributesInfoNVX {
66000         self.inner
66001     }
66002 }
66003 #[repr(C)]
66004 #[cfg_attr(feature = "debug", derive(Debug))]
66005 #[derive(Copy, Clone)]
66006 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageViewMinLodFeaturesEXT.html>"]
66007 pub struct PhysicalDeviceImageViewMinLodFeaturesEXT {
66008     pub s_type: StructureType,
66009     pub p_next: *mut c_void,
66010     pub min_lod: Bool32,
66011 }
66012 impl ::std::default::Default for PhysicalDeviceImageViewMinLodFeaturesEXT {
66013     #[inline]
default() -> Self66014     fn default() -> Self {
66015         Self {
66016             s_type: Self::STRUCTURE_TYPE,
66017             p_next: ::std::ptr::null_mut(),
66018             min_lod: Bool32::default(),
66019         }
66020     }
66021 }
66022 unsafe impl TaggedStructure for PhysicalDeviceImageViewMinLodFeaturesEXT {
66023     const STRUCTURE_TYPE: StructureType =
66024         StructureType::PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
66025 }
66026 impl PhysicalDeviceImageViewMinLodFeaturesEXT {
builder<'a>() -> PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a>66027     pub fn builder<'a>() -> PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> {
66028         PhysicalDeviceImageViewMinLodFeaturesEXTBuilder {
66029             inner: Self::default(),
66030             marker: ::std::marker::PhantomData,
66031         }
66032     }
66033 }
66034 #[repr(transparent)]
66035 pub struct PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> {
66036     inner: PhysicalDeviceImageViewMinLodFeaturesEXT,
66037     marker: ::std::marker::PhantomData<&'a ()>,
66038 }
66039 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'_> {}
66040 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageViewMinLodFeaturesEXT {}
66041 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'_> {}
66042 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageViewMinLodFeaturesEXT {}
66043 impl<'a> ::std::ops::Deref for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> {
66044     type Target = PhysicalDeviceImageViewMinLodFeaturesEXT;
deref(&self) -> &Self::Target66045     fn deref(&self) -> &Self::Target {
66046         &self.inner
66047     }
66048 }
66049 impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target66050     fn deref_mut(&mut self) -> &mut Self::Target {
66051         &mut self.inner
66052     }
66053 }
66054 impl<'a> PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> {
66055     #[inline]
min_lod(mut self, min_lod: bool) -> Self66056     pub fn min_lod(mut self, min_lod: bool) -> Self {
66057         self.inner.min_lod = min_lod.into();
66058         self
66059     }
66060     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
66061     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
66062     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceImageViewMinLodFeaturesEXT66063     pub fn build(self) -> PhysicalDeviceImageViewMinLodFeaturesEXT {
66064         self.inner
66065     }
66066 }
66067 #[repr(C)]
66068 #[cfg_attr(feature = "debug", derive(Debug))]
66069 #[derive(Copy, Clone)]
66070 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewMinLodCreateInfoEXT.html>"]
66071 pub struct ImageViewMinLodCreateInfoEXT {
66072     pub s_type: StructureType,
66073     pub p_next: *const c_void,
66074     pub min_lod: f32,
66075 }
66076 impl ::std::default::Default for ImageViewMinLodCreateInfoEXT {
66077     #[inline]
default() -> Self66078     fn default() -> Self {
66079         Self {
66080             s_type: Self::STRUCTURE_TYPE,
66081             p_next: ::std::ptr::null(),
66082             min_lod: f32::default(),
66083         }
66084     }
66085 }
66086 unsafe impl TaggedStructure for ImageViewMinLodCreateInfoEXT {
66087     const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT;
66088 }
66089 impl ImageViewMinLodCreateInfoEXT {
builder<'a>() -> ImageViewMinLodCreateInfoEXTBuilder<'a>66090     pub fn builder<'a>() -> ImageViewMinLodCreateInfoEXTBuilder<'a> {
66091         ImageViewMinLodCreateInfoEXTBuilder {
66092             inner: Self::default(),
66093             marker: ::std::marker::PhantomData,
66094         }
66095     }
66096 }
66097 #[repr(transparent)]
66098 pub struct ImageViewMinLodCreateInfoEXTBuilder<'a> {
66099     inner: ImageViewMinLodCreateInfoEXT,
66100     marker: ::std::marker::PhantomData<&'a ()>,
66101 }
66102 unsafe impl ExtendsImageViewCreateInfo for ImageViewMinLodCreateInfoEXTBuilder<'_> {}
66103 unsafe impl ExtendsImageViewCreateInfo for ImageViewMinLodCreateInfoEXT {}
66104 impl<'a> ::std::ops::Deref for ImageViewMinLodCreateInfoEXTBuilder<'a> {
66105     type Target = ImageViewMinLodCreateInfoEXT;
deref(&self) -> &Self::Target66106     fn deref(&self) -> &Self::Target {
66107         &self.inner
66108     }
66109 }
66110 impl<'a> ::std::ops::DerefMut for ImageViewMinLodCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target66111     fn deref_mut(&mut self) -> &mut Self::Target {
66112         &mut self.inner
66113     }
66114 }
66115 impl<'a> ImageViewMinLodCreateInfoEXTBuilder<'a> {
66116     #[inline]
min_lod(mut self, min_lod: f32) -> Self66117     pub fn min_lod(mut self, min_lod: f32) -> Self {
66118         self.inner.min_lod = min_lod;
66119         self
66120     }
66121     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
66122     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
66123     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageViewMinLodCreateInfoEXT66124     pub fn build(self) -> ImageViewMinLodCreateInfoEXT {
66125         self.inner
66126     }
66127 }
66128 #[repr(C)]
66129 #[cfg_attr(feature = "debug", derive(Debug))]
66130 #[derive(Copy, Clone)]
66131 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.html>"]
66132 pub struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT {
66133     pub s_type: StructureType,
66134     pub p_next: *mut c_void,
66135     pub rasterization_order_color_attachment_access: Bool32,
66136     pub rasterization_order_depth_attachment_access: Bool32,
66137     pub rasterization_order_stencil_attachment_access: Bool32,
66138 }
66139 impl ::std::default::Default for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT {
66140     #[inline]
default() -> Self66141     fn default() -> Self {
66142         Self {
66143             s_type: Self::STRUCTURE_TYPE,
66144             p_next: ::std::ptr::null_mut(),
66145             rasterization_order_color_attachment_access: Bool32::default(),
66146             rasterization_order_depth_attachment_access: Bool32::default(),
66147             rasterization_order_stencil_attachment_access: Bool32::default(),
66148         }
66149     }
66150 }
66151 unsafe impl TaggedStructure for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT {
66152     const STRUCTURE_TYPE: StructureType =
66153         StructureType::PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
66154 }
66155 impl PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT {
builder<'a>() -> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'a>66156     pub fn builder<'a>() -> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'a> {
66157         PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder {
66158             inner: Self::default(),
66159             marker: ::std::marker::PhantomData,
66160         }
66161     }
66162 }
66163 #[repr(transparent)]
66164 pub struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'a> {
66165     inner: PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT,
66166     marker: ::std::marker::PhantomData<&'a ()>,
66167 }
66168 unsafe impl ExtendsPhysicalDeviceFeatures2
66169     for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'_>
66170 {
66171 }
66172 unsafe impl ExtendsPhysicalDeviceFeatures2
66173     for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT
66174 {
66175 }
66176 unsafe impl ExtendsDeviceCreateInfo
66177     for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'_>
66178 {
66179 }
66180 unsafe impl ExtendsDeviceCreateInfo
66181     for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT
66182 {
66183 }
66184 impl<'a> ::std::ops::Deref
66185     for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'a>
66186 {
66187     type Target = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;
deref(&self) -> &Self::Target66188     fn deref(&self) -> &Self::Target {
66189         &self.inner
66190     }
66191 }
66192 impl<'a> ::std::ops::DerefMut
66193     for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'a>
66194 {
deref_mut(&mut self) -> &mut Self::Target66195     fn deref_mut(&mut self) -> &mut Self::Target {
66196         &mut self.inner
66197     }
66198 }
66199 impl<'a> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'a> {
66200     #[inline]
rasterization_order_color_attachment_access( mut self, rasterization_order_color_attachment_access: bool, ) -> Self66201     pub fn rasterization_order_color_attachment_access(
66202         mut self,
66203         rasterization_order_color_attachment_access: bool,
66204     ) -> Self {
66205         self.inner.rasterization_order_color_attachment_access =
66206             rasterization_order_color_attachment_access.into();
66207         self
66208     }
66209     #[inline]
rasterization_order_depth_attachment_access( mut self, rasterization_order_depth_attachment_access: bool, ) -> Self66210     pub fn rasterization_order_depth_attachment_access(
66211         mut self,
66212         rasterization_order_depth_attachment_access: bool,
66213     ) -> Self {
66214         self.inner.rasterization_order_depth_attachment_access =
66215             rasterization_order_depth_attachment_access.into();
66216         self
66217     }
66218     #[inline]
rasterization_order_stencil_attachment_access( mut self, rasterization_order_stencil_attachment_access: bool, ) -> Self66219     pub fn rasterization_order_stencil_attachment_access(
66220         mut self,
66221         rasterization_order_stencil_attachment_access: bool,
66222     ) -> Self {
66223         self.inner.rasterization_order_stencil_attachment_access =
66224             rasterization_order_stencil_attachment_access.into();
66225         self
66226     }
66227     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
66228     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
66229     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT66230     pub fn build(self) -> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT {
66231         self.inner
66232     }
66233 }
66234 #[repr(C)]
66235 #[cfg_attr(feature = "debug", derive(Debug))]
66236 #[derive(Copy, Clone)]
66237 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceLinearColorAttachmentFeaturesNV.html>"]
66238 pub struct PhysicalDeviceLinearColorAttachmentFeaturesNV {
66239     pub s_type: StructureType,
66240     pub p_next: *mut c_void,
66241     pub linear_color_attachment: Bool32,
66242 }
66243 impl ::std::default::Default for PhysicalDeviceLinearColorAttachmentFeaturesNV {
66244     #[inline]
default() -> Self66245     fn default() -> Self {
66246         Self {
66247             s_type: Self::STRUCTURE_TYPE,
66248             p_next: ::std::ptr::null_mut(),
66249             linear_color_attachment: Bool32::default(),
66250         }
66251     }
66252 }
66253 unsafe impl TaggedStructure for PhysicalDeviceLinearColorAttachmentFeaturesNV {
66254     const STRUCTURE_TYPE: StructureType =
66255         StructureType::PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
66256 }
66257 impl PhysicalDeviceLinearColorAttachmentFeaturesNV {
builder<'a>() -> PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a>66258     pub fn builder<'a>() -> PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> {
66259         PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder {
66260             inner: Self::default(),
66261             marker: ::std::marker::PhantomData,
66262         }
66263     }
66264 }
66265 #[repr(transparent)]
66266 pub struct PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> {
66267     inner: PhysicalDeviceLinearColorAttachmentFeaturesNV,
66268     marker: ::std::marker::PhantomData<&'a ()>,
66269 }
66270 unsafe impl ExtendsPhysicalDeviceFeatures2
66271     for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'_>
66272 {
66273 }
66274 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLinearColorAttachmentFeaturesNV {}
66275 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'_> {}
66276 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLinearColorAttachmentFeaturesNV {}
66277 impl<'a> ::std::ops::Deref for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> {
66278     type Target = PhysicalDeviceLinearColorAttachmentFeaturesNV;
deref(&self) -> &Self::Target66279     fn deref(&self) -> &Self::Target {
66280         &self.inner
66281     }
66282 }
66283 impl<'a> ::std::ops::DerefMut for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target66284     fn deref_mut(&mut self) -> &mut Self::Target {
66285         &mut self.inner
66286     }
66287 }
66288 impl<'a> PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> {
66289     #[inline]
linear_color_attachment(mut self, linear_color_attachment: bool) -> Self66290     pub fn linear_color_attachment(mut self, linear_color_attachment: bool) -> Self {
66291         self.inner.linear_color_attachment = linear_color_attachment.into();
66292         self
66293     }
66294     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
66295     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
66296     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceLinearColorAttachmentFeaturesNV66297     pub fn build(self) -> PhysicalDeviceLinearColorAttachmentFeaturesNV {
66298         self.inner
66299     }
66300 }
66301 #[repr(C)]
66302 #[cfg_attr(feature = "debug", derive(Debug))]
66303 #[derive(Copy, Clone)]
66304 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT.html>"]
66305 pub struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {
66306     pub s_type: StructureType,
66307     pub p_next: *mut c_void,
66308     pub graphics_pipeline_library: Bool32,
66309 }
66310 impl ::std::default::Default for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {
66311     #[inline]
default() -> Self66312     fn default() -> Self {
66313         Self {
66314             s_type: Self::STRUCTURE_TYPE,
66315             p_next: ::std::ptr::null_mut(),
66316             graphics_pipeline_library: Bool32::default(),
66317         }
66318     }
66319 }
66320 unsafe impl TaggedStructure for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {
66321     const STRUCTURE_TYPE: StructureType =
66322         StructureType::PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
66323 }
66324 impl PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {
builder<'a>() -> PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'a>66325     pub fn builder<'a>() -> PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'a> {
66326         PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder {
66327             inner: Self::default(),
66328             marker: ::std::marker::PhantomData,
66329         }
66330     }
66331 }
66332 #[repr(transparent)]
66333 pub struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'a> {
66334     inner: PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT,
66335     marker: ::std::marker::PhantomData<&'a ()>,
66336 }
66337 unsafe impl ExtendsPhysicalDeviceFeatures2
66338     for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'_>
66339 {
66340 }
66341 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {}
66342 unsafe impl ExtendsDeviceCreateInfo
66343     for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'_>
66344 {
66345 }
66346 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {}
66347 impl<'a> ::std::ops::Deref for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'a> {
66348     type Target = PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT;
deref(&self) -> &Self::Target66349     fn deref(&self) -> &Self::Target {
66350         &self.inner
66351     }
66352 }
66353 impl<'a> ::std::ops::DerefMut for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target66354     fn deref_mut(&mut self) -> &mut Self::Target {
66355         &mut self.inner
66356     }
66357 }
66358 impl<'a> PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'a> {
66359     #[inline]
graphics_pipeline_library(mut self, graphics_pipeline_library: bool) -> Self66360     pub fn graphics_pipeline_library(mut self, graphics_pipeline_library: bool) -> Self {
66361         self.inner.graphics_pipeline_library = graphics_pipeline_library.into();
66362         self
66363     }
66364     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
66365     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
66366     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT66367     pub fn build(self) -> PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {
66368         self.inner
66369     }
66370 }
66371 #[repr(C)]
66372 #[cfg_attr(feature = "debug", derive(Debug))]
66373 #[derive(Copy, Clone)]
66374 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT.html>"]
66375 pub struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT {
66376     pub s_type: StructureType,
66377     pub p_next: *mut c_void,
66378     pub graphics_pipeline_library_fast_linking: Bool32,
66379     pub graphics_pipeline_library_independent_interpolation_decoration: Bool32,
66380 }
66381 impl ::std::default::Default for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT {
66382     #[inline]
default() -> Self66383     fn default() -> Self {
66384         Self {
66385             s_type: Self::STRUCTURE_TYPE,
66386             p_next: ::std::ptr::null_mut(),
66387             graphics_pipeline_library_fast_linking: Bool32::default(),
66388             graphics_pipeline_library_independent_interpolation_decoration: Bool32::default(),
66389         }
66390     }
66391 }
66392 unsafe impl TaggedStructure for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT {
66393     const STRUCTURE_TYPE: StructureType =
66394         StructureType::PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT;
66395 }
66396 impl PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT {
builder<'a>() -> PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<'a>66397     pub fn builder<'a>() -> PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<'a> {
66398         PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder {
66399             inner: Self::default(),
66400             marker: ::std::marker::PhantomData,
66401         }
66402     }
66403 }
66404 #[repr(transparent)]
66405 pub struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<'a> {
66406     inner: PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT,
66407     marker: ::std::marker::PhantomData<&'a ()>,
66408 }
66409 unsafe impl ExtendsPhysicalDeviceProperties2
66410     for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<'_>
66411 {
66412 }
66413 unsafe impl ExtendsPhysicalDeviceProperties2
66414     for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT
66415 {
66416 }
66417 impl<'a> ::std::ops::Deref for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<'a> {
66418     type Target = PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT;
deref(&self) -> &Self::Target66419     fn deref(&self) -> &Self::Target {
66420         &self.inner
66421     }
66422 }
66423 impl<'a> ::std::ops::DerefMut for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target66424     fn deref_mut(&mut self) -> &mut Self::Target {
66425         &mut self.inner
66426     }
66427 }
66428 impl<'a> PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<'a> {
66429     #[inline]
graphics_pipeline_library_fast_linking( mut self, graphics_pipeline_library_fast_linking: bool, ) -> Self66430     pub fn graphics_pipeline_library_fast_linking(
66431         mut self,
66432         graphics_pipeline_library_fast_linking: bool,
66433     ) -> Self {
66434         self.inner.graphics_pipeline_library_fast_linking =
66435             graphics_pipeline_library_fast_linking.into();
66436         self
66437     }
66438     #[inline]
graphics_pipeline_library_independent_interpolation_decoration( mut self, graphics_pipeline_library_independent_interpolation_decoration: bool, ) -> Self66439     pub fn graphics_pipeline_library_independent_interpolation_decoration(
66440         mut self,
66441         graphics_pipeline_library_independent_interpolation_decoration: bool,
66442     ) -> Self {
66443         self.inner
66444             .graphics_pipeline_library_independent_interpolation_decoration =
66445             graphics_pipeline_library_independent_interpolation_decoration.into();
66446         self
66447     }
66448     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
66449     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
66450     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT66451     pub fn build(self) -> PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT {
66452         self.inner
66453     }
66454 }
66455 #[repr(C)]
66456 #[cfg_attr(feature = "debug", derive(Debug))]
66457 #[derive(Copy, Clone)]
66458 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGraphicsPipelineLibraryCreateInfoEXT.html>"]
66459 pub struct GraphicsPipelineLibraryCreateInfoEXT {
66460     pub s_type: StructureType,
66461     pub p_next: *mut c_void,
66462     pub flags: GraphicsPipelineLibraryFlagsEXT,
66463 }
66464 impl ::std::default::Default for GraphicsPipelineLibraryCreateInfoEXT {
66465     #[inline]
default() -> Self66466     fn default() -> Self {
66467         Self {
66468             s_type: Self::STRUCTURE_TYPE,
66469             p_next: ::std::ptr::null_mut(),
66470             flags: GraphicsPipelineLibraryFlagsEXT::default(),
66471         }
66472     }
66473 }
66474 unsafe impl TaggedStructure for GraphicsPipelineLibraryCreateInfoEXT {
66475     const STRUCTURE_TYPE: StructureType = StructureType::GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT;
66476 }
66477 impl GraphicsPipelineLibraryCreateInfoEXT {
builder<'a>() -> GraphicsPipelineLibraryCreateInfoEXTBuilder<'a>66478     pub fn builder<'a>() -> GraphicsPipelineLibraryCreateInfoEXTBuilder<'a> {
66479         GraphicsPipelineLibraryCreateInfoEXTBuilder {
66480             inner: Self::default(),
66481             marker: ::std::marker::PhantomData,
66482         }
66483     }
66484 }
66485 #[repr(transparent)]
66486 pub struct GraphicsPipelineLibraryCreateInfoEXTBuilder<'a> {
66487     inner: GraphicsPipelineLibraryCreateInfoEXT,
66488     marker: ::std::marker::PhantomData<&'a ()>,
66489 }
66490 unsafe impl ExtendsGraphicsPipelineCreateInfo for GraphicsPipelineLibraryCreateInfoEXTBuilder<'_> {}
66491 unsafe impl ExtendsGraphicsPipelineCreateInfo for GraphicsPipelineLibraryCreateInfoEXT {}
66492 impl<'a> ::std::ops::Deref for GraphicsPipelineLibraryCreateInfoEXTBuilder<'a> {
66493     type Target = GraphicsPipelineLibraryCreateInfoEXT;
deref(&self) -> &Self::Target66494     fn deref(&self) -> &Self::Target {
66495         &self.inner
66496     }
66497 }
66498 impl<'a> ::std::ops::DerefMut for GraphicsPipelineLibraryCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target66499     fn deref_mut(&mut self) -> &mut Self::Target {
66500         &mut self.inner
66501     }
66502 }
66503 impl<'a> GraphicsPipelineLibraryCreateInfoEXTBuilder<'a> {
66504     #[inline]
flags(mut self, flags: GraphicsPipelineLibraryFlagsEXT) -> Self66505     pub fn flags(mut self, flags: GraphicsPipelineLibraryFlagsEXT) -> Self {
66506         self.inner.flags = flags;
66507         self
66508     }
66509     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
66510     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
66511     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> GraphicsPipelineLibraryCreateInfoEXT66512     pub fn build(self) -> GraphicsPipelineLibraryCreateInfoEXT {
66513         self.inner
66514     }
66515 }
66516 #[repr(C)]
66517 #[cfg_attr(feature = "debug", derive(Debug))]
66518 #[derive(Copy, Clone)]
66519 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE.html>"]
66520 pub struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
66521     pub s_type: StructureType,
66522     pub p_next: *mut c_void,
66523     pub descriptor_set_host_mapping: Bool32,
66524 }
66525 impl ::std::default::Default for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
66526     #[inline]
default() -> Self66527     fn default() -> Self {
66528         Self {
66529             s_type: Self::STRUCTURE_TYPE,
66530             p_next: ::std::ptr::null_mut(),
66531             descriptor_set_host_mapping: Bool32::default(),
66532         }
66533     }
66534 }
66535 unsafe impl TaggedStructure for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
66536     const STRUCTURE_TYPE: StructureType =
66537         StructureType::PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
66538 }
66539 impl PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
builder<'a>() -> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a>66540     pub fn builder<'a>() -> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> {
66541         PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder {
66542             inner: Self::default(),
66543             marker: ::std::marker::PhantomData,
66544         }
66545     }
66546 }
66547 #[repr(transparent)]
66548 pub struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> {
66549     inner: PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE,
66550     marker: ::std::marker::PhantomData<&'a ()>,
66551 }
66552 unsafe impl ExtendsPhysicalDeviceFeatures2
66553     for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'_>
66554 {
66555 }
66556 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {}
66557 unsafe impl ExtendsDeviceCreateInfo
66558     for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'_>
66559 {
66560 }
66561 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {}
66562 impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> {
66563     type Target = PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE;
deref(&self) -> &Self::Target66564     fn deref(&self) -> &Self::Target {
66565         &self.inner
66566     }
66567 }
66568 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target66569     fn deref_mut(&mut self) -> &mut Self::Target {
66570         &mut self.inner
66571     }
66572 }
66573 impl<'a> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> {
66574     #[inline]
descriptor_set_host_mapping(mut self, descriptor_set_host_mapping: bool) -> Self66575     pub fn descriptor_set_host_mapping(mut self, descriptor_set_host_mapping: bool) -> Self {
66576         self.inner.descriptor_set_host_mapping = descriptor_set_host_mapping.into();
66577         self
66578     }
66579     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
66580     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
66581     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE66582     pub fn build(self) -> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
66583         self.inner
66584     }
66585 }
66586 #[repr(C)]
66587 #[cfg_attr(feature = "debug", derive(Debug))]
66588 #[derive(Copy, Clone)]
66589 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetBindingReferenceVALVE.html>"]
66590 pub struct DescriptorSetBindingReferenceVALVE {
66591     pub s_type: StructureType,
66592     pub p_next: *const c_void,
66593     pub descriptor_set_layout: DescriptorSetLayout,
66594     pub binding: u32,
66595 }
66596 impl ::std::default::Default for DescriptorSetBindingReferenceVALVE {
66597     #[inline]
default() -> Self66598     fn default() -> Self {
66599         Self {
66600             s_type: Self::STRUCTURE_TYPE,
66601             p_next: ::std::ptr::null(),
66602             descriptor_set_layout: DescriptorSetLayout::default(),
66603             binding: u32::default(),
66604         }
66605     }
66606 }
66607 unsafe impl TaggedStructure for DescriptorSetBindingReferenceVALVE {
66608     const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_SET_BINDING_REFERENCE_VALVE;
66609 }
66610 impl DescriptorSetBindingReferenceVALVE {
builder<'a>() -> DescriptorSetBindingReferenceVALVEBuilder<'a>66611     pub fn builder<'a>() -> DescriptorSetBindingReferenceVALVEBuilder<'a> {
66612         DescriptorSetBindingReferenceVALVEBuilder {
66613             inner: Self::default(),
66614             marker: ::std::marker::PhantomData,
66615         }
66616     }
66617 }
66618 #[repr(transparent)]
66619 pub struct DescriptorSetBindingReferenceVALVEBuilder<'a> {
66620     inner: DescriptorSetBindingReferenceVALVE,
66621     marker: ::std::marker::PhantomData<&'a ()>,
66622 }
66623 impl<'a> ::std::ops::Deref for DescriptorSetBindingReferenceVALVEBuilder<'a> {
66624     type Target = DescriptorSetBindingReferenceVALVE;
deref(&self) -> &Self::Target66625     fn deref(&self) -> &Self::Target {
66626         &self.inner
66627     }
66628 }
66629 impl<'a> ::std::ops::DerefMut for DescriptorSetBindingReferenceVALVEBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target66630     fn deref_mut(&mut self) -> &mut Self::Target {
66631         &mut self.inner
66632     }
66633 }
66634 impl<'a> DescriptorSetBindingReferenceVALVEBuilder<'a> {
66635     #[inline]
descriptor_set_layout(mut self, descriptor_set_layout: DescriptorSetLayout) -> Self66636     pub fn descriptor_set_layout(mut self, descriptor_set_layout: DescriptorSetLayout) -> Self {
66637         self.inner.descriptor_set_layout = descriptor_set_layout;
66638         self
66639     }
66640     #[inline]
binding(mut self, binding: u32) -> Self66641     pub fn binding(mut self, binding: u32) -> Self {
66642         self.inner.binding = binding;
66643         self
66644     }
66645     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
66646     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
66647     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorSetBindingReferenceVALVE66648     pub fn build(self) -> DescriptorSetBindingReferenceVALVE {
66649         self.inner
66650     }
66651 }
66652 #[repr(C)]
66653 #[cfg_attr(feature = "debug", derive(Debug))]
66654 #[derive(Copy, Clone)]
66655 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutHostMappingInfoVALVE.html>"]
66656 pub struct DescriptorSetLayoutHostMappingInfoVALVE {
66657     pub s_type: StructureType,
66658     pub p_next: *mut c_void,
66659     pub descriptor_offset: usize,
66660     pub descriptor_size: u32,
66661 }
66662 impl ::std::default::Default for DescriptorSetLayoutHostMappingInfoVALVE {
66663     #[inline]
default() -> Self66664     fn default() -> Self {
66665         Self {
66666             s_type: Self::STRUCTURE_TYPE,
66667             p_next: ::std::ptr::null_mut(),
66668             descriptor_offset: usize::default(),
66669             descriptor_size: u32::default(),
66670         }
66671     }
66672 }
66673 unsafe impl TaggedStructure for DescriptorSetLayoutHostMappingInfoVALVE {
66674     const STRUCTURE_TYPE: StructureType =
66675         StructureType::DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE;
66676 }
66677 impl DescriptorSetLayoutHostMappingInfoVALVE {
builder<'a>() -> DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a>66678     pub fn builder<'a>() -> DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> {
66679         DescriptorSetLayoutHostMappingInfoVALVEBuilder {
66680             inner: Self::default(),
66681             marker: ::std::marker::PhantomData,
66682         }
66683     }
66684 }
66685 #[repr(transparent)]
66686 pub struct DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> {
66687     inner: DescriptorSetLayoutHostMappingInfoVALVE,
66688     marker: ::std::marker::PhantomData<&'a ()>,
66689 }
66690 impl<'a> ::std::ops::Deref for DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> {
66691     type Target = DescriptorSetLayoutHostMappingInfoVALVE;
deref(&self) -> &Self::Target66692     fn deref(&self) -> &Self::Target {
66693         &self.inner
66694     }
66695 }
66696 impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target66697     fn deref_mut(&mut self) -> &mut Self::Target {
66698         &mut self.inner
66699     }
66700 }
66701 impl<'a> DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> {
66702     #[inline]
descriptor_offset(mut self, descriptor_offset: usize) -> Self66703     pub fn descriptor_offset(mut self, descriptor_offset: usize) -> Self {
66704         self.inner.descriptor_offset = descriptor_offset;
66705         self
66706     }
66707     #[inline]
descriptor_size(mut self, descriptor_size: u32) -> Self66708     pub fn descriptor_size(mut self, descriptor_size: u32) -> Self {
66709         self.inner.descriptor_size = descriptor_size;
66710         self
66711     }
66712     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
66713     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
66714     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorSetLayoutHostMappingInfoVALVE66715     pub fn build(self) -> DescriptorSetLayoutHostMappingInfoVALVE {
66716         self.inner
66717     }
66718 }
66719 #[repr(C)]
66720 #[cfg_attr(feature = "debug", derive(Debug))]
66721 #[derive(Copy, Clone)]
66722 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT.html>"]
66723 pub struct PhysicalDeviceShaderModuleIdentifierFeaturesEXT {
66724     pub s_type: StructureType,
66725     pub p_next: *mut c_void,
66726     pub shader_module_identifier: Bool32,
66727 }
66728 impl ::std::default::Default for PhysicalDeviceShaderModuleIdentifierFeaturesEXT {
66729     #[inline]
default() -> Self66730     fn default() -> Self {
66731         Self {
66732             s_type: Self::STRUCTURE_TYPE,
66733             p_next: ::std::ptr::null_mut(),
66734             shader_module_identifier: Bool32::default(),
66735         }
66736     }
66737 }
66738 unsafe impl TaggedStructure for PhysicalDeviceShaderModuleIdentifierFeaturesEXT {
66739     const STRUCTURE_TYPE: StructureType =
66740         StructureType::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
66741 }
66742 impl PhysicalDeviceShaderModuleIdentifierFeaturesEXT {
builder<'a>() -> PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a>66743     pub fn builder<'a>() -> PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> {
66744         PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder {
66745             inner: Self::default(),
66746             marker: ::std::marker::PhantomData,
66747         }
66748     }
66749 }
66750 #[repr(transparent)]
66751 pub struct PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> {
66752     inner: PhysicalDeviceShaderModuleIdentifierFeaturesEXT,
66753     marker: ::std::marker::PhantomData<&'a ()>,
66754 }
66755 unsafe impl ExtendsPhysicalDeviceFeatures2
66756     for PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'_>
66757 {
66758 }
66759 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderModuleIdentifierFeaturesEXT {}
66760 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'_> {}
66761 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderModuleIdentifierFeaturesEXT {}
66762 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> {
66763     type Target = PhysicalDeviceShaderModuleIdentifierFeaturesEXT;
deref(&self) -> &Self::Target66764     fn deref(&self) -> &Self::Target {
66765         &self.inner
66766     }
66767 }
66768 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target66769     fn deref_mut(&mut self) -> &mut Self::Target {
66770         &mut self.inner
66771     }
66772 }
66773 impl<'a> PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> {
66774     #[inline]
shader_module_identifier(mut self, shader_module_identifier: bool) -> Self66775     pub fn shader_module_identifier(mut self, shader_module_identifier: bool) -> Self {
66776         self.inner.shader_module_identifier = shader_module_identifier.into();
66777         self
66778     }
66779     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
66780     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
66781     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderModuleIdentifierFeaturesEXT66782     pub fn build(self) -> PhysicalDeviceShaderModuleIdentifierFeaturesEXT {
66783         self.inner
66784     }
66785 }
66786 #[repr(C)]
66787 #[cfg_attr(feature = "debug", derive(Debug))]
66788 #[derive(Copy, Clone)]
66789 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT.html>"]
66790 pub struct PhysicalDeviceShaderModuleIdentifierPropertiesEXT {
66791     pub s_type: StructureType,
66792     pub p_next: *mut c_void,
66793     pub shader_module_identifier_algorithm_uuid: [u8; UUID_SIZE],
66794 }
66795 impl ::std::default::Default for PhysicalDeviceShaderModuleIdentifierPropertiesEXT {
66796     #[inline]
default() -> Self66797     fn default() -> Self {
66798         Self {
66799             s_type: Self::STRUCTURE_TYPE,
66800             p_next: ::std::ptr::null_mut(),
66801             shader_module_identifier_algorithm_uuid: unsafe { ::std::mem::zeroed() },
66802         }
66803     }
66804 }
66805 unsafe impl TaggedStructure for PhysicalDeviceShaderModuleIdentifierPropertiesEXT {
66806     const STRUCTURE_TYPE: StructureType =
66807         StructureType::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT;
66808 }
66809 impl PhysicalDeviceShaderModuleIdentifierPropertiesEXT {
builder<'a>() -> PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a>66810     pub fn builder<'a>() -> PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a> {
66811         PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder {
66812             inner: Self::default(),
66813             marker: ::std::marker::PhantomData,
66814         }
66815     }
66816 }
66817 #[repr(transparent)]
66818 pub struct PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a> {
66819     inner: PhysicalDeviceShaderModuleIdentifierPropertiesEXT,
66820     marker: ::std::marker::PhantomData<&'a ()>,
66821 }
66822 unsafe impl ExtendsPhysicalDeviceProperties2
66823     for PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'_>
66824 {
66825 }
66826 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderModuleIdentifierPropertiesEXT {}
66827 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a> {
66828     type Target = PhysicalDeviceShaderModuleIdentifierPropertiesEXT;
deref(&self) -> &Self::Target66829     fn deref(&self) -> &Self::Target {
66830         &self.inner
66831     }
66832 }
66833 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target66834     fn deref_mut(&mut self) -> &mut Self::Target {
66835         &mut self.inner
66836     }
66837 }
66838 impl<'a> PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a> {
66839     #[inline]
shader_module_identifier_algorithm_uuid( mut self, shader_module_identifier_algorithm_uuid: [u8; UUID_SIZE], ) -> Self66840     pub fn shader_module_identifier_algorithm_uuid(
66841         mut self,
66842         shader_module_identifier_algorithm_uuid: [u8; UUID_SIZE],
66843     ) -> Self {
66844         self.inner.shader_module_identifier_algorithm_uuid =
66845             shader_module_identifier_algorithm_uuid;
66846         self
66847     }
66848     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
66849     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
66850     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderModuleIdentifierPropertiesEXT66851     pub fn build(self) -> PhysicalDeviceShaderModuleIdentifierPropertiesEXT {
66852         self.inner
66853     }
66854 }
66855 #[repr(C)]
66856 #[cfg_attr(feature = "debug", derive(Debug))]
66857 #[derive(Copy, Clone)]
66858 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineShaderStageModuleIdentifierCreateInfoEXT.html>"]
66859 pub struct PipelineShaderStageModuleIdentifierCreateInfoEXT {
66860     pub s_type: StructureType,
66861     pub p_next: *const c_void,
66862     pub identifier_size: u32,
66863     pub p_identifier: *const u8,
66864 }
66865 impl ::std::default::Default for PipelineShaderStageModuleIdentifierCreateInfoEXT {
66866     #[inline]
default() -> Self66867     fn default() -> Self {
66868         Self {
66869             s_type: Self::STRUCTURE_TYPE,
66870             p_next: ::std::ptr::null(),
66871             identifier_size: u32::default(),
66872             p_identifier: ::std::ptr::null(),
66873         }
66874     }
66875 }
66876 unsafe impl TaggedStructure for PipelineShaderStageModuleIdentifierCreateInfoEXT {
66877     const STRUCTURE_TYPE: StructureType =
66878         StructureType::PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT;
66879 }
66880 impl PipelineShaderStageModuleIdentifierCreateInfoEXT {
builder<'a>() -> PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a>66881     pub fn builder<'a>() -> PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> {
66882         PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder {
66883             inner: Self::default(),
66884             marker: ::std::marker::PhantomData,
66885         }
66886     }
66887 }
66888 #[repr(transparent)]
66889 pub struct PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> {
66890     inner: PipelineShaderStageModuleIdentifierCreateInfoEXT,
66891     marker: ::std::marker::PhantomData<&'a ()>,
66892 }
66893 unsafe impl ExtendsPipelineShaderStageCreateInfo
66894     for PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'_>
66895 {
66896 }
66897 unsafe impl ExtendsPipelineShaderStageCreateInfo
66898     for PipelineShaderStageModuleIdentifierCreateInfoEXT
66899 {
66900 }
66901 impl<'a> ::std::ops::Deref for PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> {
66902     type Target = PipelineShaderStageModuleIdentifierCreateInfoEXT;
deref(&self) -> &Self::Target66903     fn deref(&self) -> &Self::Target {
66904         &self.inner
66905     }
66906 }
66907 impl<'a> ::std::ops::DerefMut for PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target66908     fn deref_mut(&mut self) -> &mut Self::Target {
66909         &mut self.inner
66910     }
66911 }
66912 impl<'a> PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> {
66913     #[inline]
identifier(mut self, identifier: &'a [u8]) -> Self66914     pub fn identifier(mut self, identifier: &'a [u8]) -> Self {
66915         self.inner.identifier_size = identifier.len() as _;
66916         self.inner.p_identifier = identifier.as_ptr();
66917         self
66918     }
66919     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
66920     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
66921     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineShaderStageModuleIdentifierCreateInfoEXT66922     pub fn build(self) -> PipelineShaderStageModuleIdentifierCreateInfoEXT {
66923         self.inner
66924     }
66925 }
66926 #[repr(C)]
66927 #[cfg_attr(feature = "debug", derive(Debug))]
66928 #[derive(Copy, Clone)]
66929 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderModuleIdentifierEXT.html>"]
66930 pub struct ShaderModuleIdentifierEXT {
66931     pub s_type: StructureType,
66932     pub p_next: *mut c_void,
66933     pub identifier_size: u32,
66934     pub identifier: [u8; MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT],
66935 }
66936 impl ::std::default::Default for ShaderModuleIdentifierEXT {
66937     #[inline]
default() -> Self66938     fn default() -> Self {
66939         Self {
66940             s_type: Self::STRUCTURE_TYPE,
66941             p_next: ::std::ptr::null_mut(),
66942             identifier_size: u32::default(),
66943             identifier: unsafe { ::std::mem::zeroed() },
66944         }
66945     }
66946 }
66947 unsafe impl TaggedStructure for ShaderModuleIdentifierEXT {
66948     const STRUCTURE_TYPE: StructureType = StructureType::SHADER_MODULE_IDENTIFIER_EXT;
66949 }
66950 impl ShaderModuleIdentifierEXT {
builder<'a>() -> ShaderModuleIdentifierEXTBuilder<'a>66951     pub fn builder<'a>() -> ShaderModuleIdentifierEXTBuilder<'a> {
66952         ShaderModuleIdentifierEXTBuilder {
66953             inner: Self::default(),
66954             marker: ::std::marker::PhantomData,
66955         }
66956     }
66957 }
66958 #[repr(transparent)]
66959 pub struct ShaderModuleIdentifierEXTBuilder<'a> {
66960     inner: ShaderModuleIdentifierEXT,
66961     marker: ::std::marker::PhantomData<&'a ()>,
66962 }
66963 impl<'a> ::std::ops::Deref for ShaderModuleIdentifierEXTBuilder<'a> {
66964     type Target = ShaderModuleIdentifierEXT;
deref(&self) -> &Self::Target66965     fn deref(&self) -> &Self::Target {
66966         &self.inner
66967     }
66968 }
66969 impl<'a> ::std::ops::DerefMut for ShaderModuleIdentifierEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target66970     fn deref_mut(&mut self) -> &mut Self::Target {
66971         &mut self.inner
66972     }
66973 }
66974 impl<'a> ShaderModuleIdentifierEXTBuilder<'a> {
66975     #[inline]
identifier_size(mut self, identifier_size: u32) -> Self66976     pub fn identifier_size(mut self, identifier_size: u32) -> Self {
66977         self.inner.identifier_size = identifier_size;
66978         self
66979     }
66980     #[inline]
identifier(mut self, identifier: [u8; MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT]) -> Self66981     pub fn identifier(mut self, identifier: [u8; MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT]) -> Self {
66982         self.inner.identifier = identifier;
66983         self
66984     }
66985     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
66986     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
66987     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ShaderModuleIdentifierEXT66988     pub fn build(self) -> ShaderModuleIdentifierEXT {
66989         self.inner
66990     }
66991 }
66992 #[repr(C)]
66993 #[cfg_attr(feature = "debug", derive(Debug))]
66994 #[derive(Copy, Clone)]
66995 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCompressionControlEXT.html>"]
66996 pub struct ImageCompressionControlEXT {
66997     pub s_type: StructureType,
66998     pub p_next: *const c_void,
66999     pub flags: ImageCompressionFlagsEXT,
67000     pub compression_control_plane_count: u32,
67001     pub p_fixed_rate_flags: *mut ImageCompressionFixedRateFlagsEXT,
67002 }
67003 impl ::std::default::Default for ImageCompressionControlEXT {
67004     #[inline]
default() -> Self67005     fn default() -> Self {
67006         Self {
67007             s_type: Self::STRUCTURE_TYPE,
67008             p_next: ::std::ptr::null(),
67009             flags: ImageCompressionFlagsEXT::default(),
67010             compression_control_plane_count: u32::default(),
67011             p_fixed_rate_flags: ::std::ptr::null_mut(),
67012         }
67013     }
67014 }
67015 unsafe impl TaggedStructure for ImageCompressionControlEXT {
67016     const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_COMPRESSION_CONTROL_EXT;
67017 }
67018 impl ImageCompressionControlEXT {
builder<'a>() -> ImageCompressionControlEXTBuilder<'a>67019     pub fn builder<'a>() -> ImageCompressionControlEXTBuilder<'a> {
67020         ImageCompressionControlEXTBuilder {
67021             inner: Self::default(),
67022             marker: ::std::marker::PhantomData,
67023         }
67024     }
67025 }
67026 #[repr(transparent)]
67027 pub struct ImageCompressionControlEXTBuilder<'a> {
67028     inner: ImageCompressionControlEXT,
67029     marker: ::std::marker::PhantomData<&'a ()>,
67030 }
67031 unsafe impl ExtendsImageCreateInfo for ImageCompressionControlEXTBuilder<'_> {}
67032 unsafe impl ExtendsImageCreateInfo for ImageCompressionControlEXT {}
67033 unsafe impl ExtendsSwapchainCreateInfoKHR for ImageCompressionControlEXTBuilder<'_> {}
67034 unsafe impl ExtendsSwapchainCreateInfoKHR for ImageCompressionControlEXT {}
67035 unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageCompressionControlEXTBuilder<'_> {}
67036 unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageCompressionControlEXT {}
67037 impl<'a> ::std::ops::Deref for ImageCompressionControlEXTBuilder<'a> {
67038     type Target = ImageCompressionControlEXT;
deref(&self) -> &Self::Target67039     fn deref(&self) -> &Self::Target {
67040         &self.inner
67041     }
67042 }
67043 impl<'a> ::std::ops::DerefMut for ImageCompressionControlEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target67044     fn deref_mut(&mut self) -> &mut Self::Target {
67045         &mut self.inner
67046     }
67047 }
67048 impl<'a> ImageCompressionControlEXTBuilder<'a> {
67049     #[inline]
flags(mut self, flags: ImageCompressionFlagsEXT) -> Self67050     pub fn flags(mut self, flags: ImageCompressionFlagsEXT) -> Self {
67051         self.inner.flags = flags;
67052         self
67053     }
67054     #[inline]
fixed_rate_flags( mut self, fixed_rate_flags: &'a mut [ImageCompressionFixedRateFlagsEXT], ) -> Self67055     pub fn fixed_rate_flags(
67056         mut self,
67057         fixed_rate_flags: &'a mut [ImageCompressionFixedRateFlagsEXT],
67058     ) -> Self {
67059         self.inner.compression_control_plane_count = fixed_rate_flags.len() as _;
67060         self.inner.p_fixed_rate_flags = fixed_rate_flags.as_mut_ptr();
67061         self
67062     }
67063     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
67064     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
67065     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageCompressionControlEXT67066     pub fn build(self) -> ImageCompressionControlEXT {
67067         self.inner
67068     }
67069 }
67070 #[repr(C)]
67071 #[cfg_attr(feature = "debug", derive(Debug))]
67072 #[derive(Copy, Clone)]
67073 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageCompressionControlFeaturesEXT.html>"]
67074 pub struct PhysicalDeviceImageCompressionControlFeaturesEXT {
67075     pub s_type: StructureType,
67076     pub p_next: *mut c_void,
67077     pub image_compression_control: Bool32,
67078 }
67079 impl ::std::default::Default for PhysicalDeviceImageCompressionControlFeaturesEXT {
67080     #[inline]
default() -> Self67081     fn default() -> Self {
67082         Self {
67083             s_type: Self::STRUCTURE_TYPE,
67084             p_next: ::std::ptr::null_mut(),
67085             image_compression_control: Bool32::default(),
67086         }
67087     }
67088 }
67089 unsafe impl TaggedStructure for PhysicalDeviceImageCompressionControlFeaturesEXT {
67090     const STRUCTURE_TYPE: StructureType =
67091         StructureType::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
67092 }
67093 impl PhysicalDeviceImageCompressionControlFeaturesEXT {
builder<'a>() -> PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a>67094     pub fn builder<'a>() -> PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> {
67095         PhysicalDeviceImageCompressionControlFeaturesEXTBuilder {
67096             inner: Self::default(),
67097             marker: ::std::marker::PhantomData,
67098         }
67099     }
67100 }
67101 #[repr(transparent)]
67102 pub struct PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> {
67103     inner: PhysicalDeviceImageCompressionControlFeaturesEXT,
67104     marker: ::std::marker::PhantomData<&'a ()>,
67105 }
67106 unsafe impl ExtendsPhysicalDeviceFeatures2
67107     for PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'_>
67108 {
67109 }
67110 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageCompressionControlFeaturesEXT {}
67111 unsafe impl ExtendsDeviceCreateInfo
67112     for PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'_>
67113 {
67114 }
67115 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageCompressionControlFeaturesEXT {}
67116 impl<'a> ::std::ops::Deref for PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> {
67117     type Target = PhysicalDeviceImageCompressionControlFeaturesEXT;
deref(&self) -> &Self::Target67118     fn deref(&self) -> &Self::Target {
67119         &self.inner
67120     }
67121 }
67122 impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target67123     fn deref_mut(&mut self) -> &mut Self::Target {
67124         &mut self.inner
67125     }
67126 }
67127 impl<'a> PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> {
67128     #[inline]
image_compression_control(mut self, image_compression_control: bool) -> Self67129     pub fn image_compression_control(mut self, image_compression_control: bool) -> Self {
67130         self.inner.image_compression_control = image_compression_control.into();
67131         self
67132     }
67133     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
67134     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
67135     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceImageCompressionControlFeaturesEXT67136     pub fn build(self) -> PhysicalDeviceImageCompressionControlFeaturesEXT {
67137         self.inner
67138     }
67139 }
67140 #[repr(C)]
67141 #[cfg_attr(feature = "debug", derive(Debug))]
67142 #[derive(Copy, Clone)]
67143 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCompressionPropertiesEXT.html>"]
67144 pub struct ImageCompressionPropertiesEXT {
67145     pub s_type: StructureType,
67146     pub p_next: *mut c_void,
67147     pub image_compression_flags: ImageCompressionFlagsEXT,
67148     pub image_compression_fixed_rate_flags: ImageCompressionFixedRateFlagsEXT,
67149 }
67150 impl ::std::default::Default for ImageCompressionPropertiesEXT {
67151     #[inline]
default() -> Self67152     fn default() -> Self {
67153         Self {
67154             s_type: Self::STRUCTURE_TYPE,
67155             p_next: ::std::ptr::null_mut(),
67156             image_compression_flags: ImageCompressionFlagsEXT::default(),
67157             image_compression_fixed_rate_flags: ImageCompressionFixedRateFlagsEXT::default(),
67158         }
67159     }
67160 }
67161 unsafe impl TaggedStructure for ImageCompressionPropertiesEXT {
67162     const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_COMPRESSION_PROPERTIES_EXT;
67163 }
67164 impl ImageCompressionPropertiesEXT {
builder<'a>() -> ImageCompressionPropertiesEXTBuilder<'a>67165     pub fn builder<'a>() -> ImageCompressionPropertiesEXTBuilder<'a> {
67166         ImageCompressionPropertiesEXTBuilder {
67167             inner: Self::default(),
67168             marker: ::std::marker::PhantomData,
67169         }
67170     }
67171 }
67172 #[repr(transparent)]
67173 pub struct ImageCompressionPropertiesEXTBuilder<'a> {
67174     inner: ImageCompressionPropertiesEXT,
67175     marker: ::std::marker::PhantomData<&'a ()>,
67176 }
67177 unsafe impl ExtendsImageFormatProperties2 for ImageCompressionPropertiesEXTBuilder<'_> {}
67178 unsafe impl ExtendsImageFormatProperties2 for ImageCompressionPropertiesEXT {}
67179 unsafe impl ExtendsSurfaceFormat2KHR for ImageCompressionPropertiesEXTBuilder<'_> {}
67180 unsafe impl ExtendsSurfaceFormat2KHR for ImageCompressionPropertiesEXT {}
67181 unsafe impl ExtendsSubresourceLayout2EXT for ImageCompressionPropertiesEXTBuilder<'_> {}
67182 unsafe impl ExtendsSubresourceLayout2EXT for ImageCompressionPropertiesEXT {}
67183 impl<'a> ::std::ops::Deref for ImageCompressionPropertiesEXTBuilder<'a> {
67184     type Target = ImageCompressionPropertiesEXT;
deref(&self) -> &Self::Target67185     fn deref(&self) -> &Self::Target {
67186         &self.inner
67187     }
67188 }
67189 impl<'a> ::std::ops::DerefMut for ImageCompressionPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target67190     fn deref_mut(&mut self) -> &mut Self::Target {
67191         &mut self.inner
67192     }
67193 }
67194 impl<'a> ImageCompressionPropertiesEXTBuilder<'a> {
67195     #[inline]
image_compression_flags( mut self, image_compression_flags: ImageCompressionFlagsEXT, ) -> Self67196     pub fn image_compression_flags(
67197         mut self,
67198         image_compression_flags: ImageCompressionFlagsEXT,
67199     ) -> Self {
67200         self.inner.image_compression_flags = image_compression_flags;
67201         self
67202     }
67203     #[inline]
image_compression_fixed_rate_flags( mut self, image_compression_fixed_rate_flags: ImageCompressionFixedRateFlagsEXT, ) -> Self67204     pub fn image_compression_fixed_rate_flags(
67205         mut self,
67206         image_compression_fixed_rate_flags: ImageCompressionFixedRateFlagsEXT,
67207     ) -> Self {
67208         self.inner.image_compression_fixed_rate_flags = image_compression_fixed_rate_flags;
67209         self
67210     }
67211     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
67212     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
67213     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageCompressionPropertiesEXT67214     pub fn build(self) -> ImageCompressionPropertiesEXT {
67215         self.inner
67216     }
67217 }
67218 #[repr(C)]
67219 #[cfg_attr(feature = "debug", derive(Debug))]
67220 #[derive(Copy, Clone)]
67221 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT.html>"]
67222 pub struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {
67223     pub s_type: StructureType,
67224     pub p_next: *mut c_void,
67225     pub image_compression_control_swapchain: Bool32,
67226 }
67227 impl ::std::default::Default for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {
67228     #[inline]
default() -> Self67229     fn default() -> Self {
67230         Self {
67231             s_type: Self::STRUCTURE_TYPE,
67232             p_next: ::std::ptr::null_mut(),
67233             image_compression_control_swapchain: Bool32::default(),
67234         }
67235     }
67236 }
67237 unsafe impl TaggedStructure for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {
67238     const STRUCTURE_TYPE: StructureType =
67239         StructureType::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
67240 }
67241 impl PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {
builder<'a>() -> PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a>67242     pub fn builder<'a>() -> PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a> {
67243         PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder {
67244             inner: Self::default(),
67245             marker: ::std::marker::PhantomData,
67246         }
67247     }
67248 }
67249 #[repr(transparent)]
67250 pub struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a> {
67251     inner: PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT,
67252     marker: ::std::marker::PhantomData<&'a ()>,
67253 }
67254 unsafe impl ExtendsPhysicalDeviceFeatures2
67255     for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'_>
67256 {
67257 }
67258 unsafe impl ExtendsPhysicalDeviceFeatures2
67259     for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT
67260 {
67261 }
67262 unsafe impl ExtendsDeviceCreateInfo
67263     for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'_>
67264 {
67265 }
67266 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {}
67267 impl<'a> ::std::ops::Deref
67268     for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a>
67269 {
67270     type Target = PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT;
deref(&self) -> &Self::Target67271     fn deref(&self) -> &Self::Target {
67272         &self.inner
67273     }
67274 }
67275 impl<'a> ::std::ops::DerefMut
67276     for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a>
67277 {
deref_mut(&mut self) -> &mut Self::Target67278     fn deref_mut(&mut self) -> &mut Self::Target {
67279         &mut self.inner
67280     }
67281 }
67282 impl<'a> PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a> {
67283     #[inline]
image_compression_control_swapchain( mut self, image_compression_control_swapchain: bool, ) -> Self67284     pub fn image_compression_control_swapchain(
67285         mut self,
67286         image_compression_control_swapchain: bool,
67287     ) -> Self {
67288         self.inner.image_compression_control_swapchain = image_compression_control_swapchain.into();
67289         self
67290     }
67291     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
67292     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
67293     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT67294     pub fn build(self) -> PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {
67295         self.inner
67296     }
67297 }
67298 #[repr(C)]
67299 #[cfg_attr(feature = "debug", derive(Debug))]
67300 #[derive(Copy, Clone)]
67301 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSubresource2EXT.html>"]
67302 pub struct ImageSubresource2EXT {
67303     pub s_type: StructureType,
67304     pub p_next: *mut c_void,
67305     pub image_subresource: ImageSubresource,
67306 }
67307 impl ::std::default::Default for ImageSubresource2EXT {
67308     #[inline]
default() -> Self67309     fn default() -> Self {
67310         Self {
67311             s_type: Self::STRUCTURE_TYPE,
67312             p_next: ::std::ptr::null_mut(),
67313             image_subresource: ImageSubresource::default(),
67314         }
67315     }
67316 }
67317 unsafe impl TaggedStructure for ImageSubresource2EXT {
67318     const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_SUBRESOURCE_2_EXT;
67319 }
67320 impl ImageSubresource2EXT {
builder<'a>() -> ImageSubresource2EXTBuilder<'a>67321     pub fn builder<'a>() -> ImageSubresource2EXTBuilder<'a> {
67322         ImageSubresource2EXTBuilder {
67323             inner: Self::default(),
67324             marker: ::std::marker::PhantomData,
67325         }
67326     }
67327 }
67328 #[repr(transparent)]
67329 pub struct ImageSubresource2EXTBuilder<'a> {
67330     inner: ImageSubresource2EXT,
67331     marker: ::std::marker::PhantomData<&'a ()>,
67332 }
67333 impl<'a> ::std::ops::Deref for ImageSubresource2EXTBuilder<'a> {
67334     type Target = ImageSubresource2EXT;
deref(&self) -> &Self::Target67335     fn deref(&self) -> &Self::Target {
67336         &self.inner
67337     }
67338 }
67339 impl<'a> ::std::ops::DerefMut for ImageSubresource2EXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target67340     fn deref_mut(&mut self) -> &mut Self::Target {
67341         &mut self.inner
67342     }
67343 }
67344 impl<'a> ImageSubresource2EXTBuilder<'a> {
67345     #[inline]
image_subresource(mut self, image_subresource: ImageSubresource) -> Self67346     pub fn image_subresource(mut self, image_subresource: ImageSubresource) -> Self {
67347         self.inner.image_subresource = image_subresource;
67348         self
67349     }
67350     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
67351     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
67352     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageSubresource2EXT67353     pub fn build(self) -> ImageSubresource2EXT {
67354         self.inner
67355     }
67356 }
67357 #[repr(C)]
67358 #[cfg_attr(feature = "debug", derive(Debug))]
67359 #[derive(Copy, Clone)]
67360 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubresourceLayout2EXT.html>"]
67361 pub struct SubresourceLayout2EXT {
67362     pub s_type: StructureType,
67363     pub p_next: *mut c_void,
67364     pub subresource_layout: SubresourceLayout,
67365 }
67366 impl ::std::default::Default for SubresourceLayout2EXT {
67367     #[inline]
default() -> Self67368     fn default() -> Self {
67369         Self {
67370             s_type: Self::STRUCTURE_TYPE,
67371             p_next: ::std::ptr::null_mut(),
67372             subresource_layout: SubresourceLayout::default(),
67373         }
67374     }
67375 }
67376 unsafe impl TaggedStructure for SubresourceLayout2EXT {
67377     const STRUCTURE_TYPE: StructureType = StructureType::SUBRESOURCE_LAYOUT_2_EXT;
67378 }
67379 impl SubresourceLayout2EXT {
builder<'a>() -> SubresourceLayout2EXTBuilder<'a>67380     pub fn builder<'a>() -> SubresourceLayout2EXTBuilder<'a> {
67381         SubresourceLayout2EXTBuilder {
67382             inner: Self::default(),
67383             marker: ::std::marker::PhantomData,
67384         }
67385     }
67386 }
67387 #[repr(transparent)]
67388 pub struct SubresourceLayout2EXTBuilder<'a> {
67389     inner: SubresourceLayout2EXT,
67390     marker: ::std::marker::PhantomData<&'a ()>,
67391 }
67392 pub unsafe trait ExtendsSubresourceLayout2EXT {}
67393 impl<'a> ::std::ops::Deref for SubresourceLayout2EXTBuilder<'a> {
67394     type Target = SubresourceLayout2EXT;
deref(&self) -> &Self::Target67395     fn deref(&self) -> &Self::Target {
67396         &self.inner
67397     }
67398 }
67399 impl<'a> ::std::ops::DerefMut for SubresourceLayout2EXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target67400     fn deref_mut(&mut self) -> &mut Self::Target {
67401         &mut self.inner
67402     }
67403 }
67404 impl<'a> SubresourceLayout2EXTBuilder<'a> {
67405     #[inline]
subresource_layout(mut self, subresource_layout: SubresourceLayout) -> Self67406     pub fn subresource_layout(mut self, subresource_layout: SubresourceLayout) -> Self {
67407         self.inner.subresource_layout = subresource_layout;
67408         self
67409     }
67410     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
67411     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
67412     #[doc = r" valid extension structs can be pushed into the chain."]
67413     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
67414     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSubresourceLayout2EXT>(mut self, next: &'a mut T) -> Self67415     pub fn push_next<T: ExtendsSubresourceLayout2EXT>(mut self, next: &'a mut T) -> Self {
67416         unsafe {
67417             let next_ptr = <*mut T>::cast(next);
67418             let last_next = ptr_chain_iter(next).last().unwrap();
67419             (*last_next).p_next = self.inner.p_next as _;
67420             self.inner.p_next = next_ptr;
67421         }
67422         self
67423     }
67424     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
67425     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
67426     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SubresourceLayout2EXT67427     pub fn build(self) -> SubresourceLayout2EXT {
67428         self.inner
67429     }
67430 }
67431 #[repr(C)]
67432 #[cfg_attr(feature = "debug", derive(Debug))]
67433 #[derive(Copy, Clone)]
67434 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassCreationControlEXT.html>"]
67435 pub struct RenderPassCreationControlEXT {
67436     pub s_type: StructureType,
67437     pub p_next: *const c_void,
67438     pub disallow_merging: Bool32,
67439 }
67440 impl ::std::default::Default for RenderPassCreationControlEXT {
67441     #[inline]
default() -> Self67442     fn default() -> Self {
67443         Self {
67444             s_type: Self::STRUCTURE_TYPE,
67445             p_next: ::std::ptr::null(),
67446             disallow_merging: Bool32::default(),
67447         }
67448     }
67449 }
67450 unsafe impl TaggedStructure for RenderPassCreationControlEXT {
67451     const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_CREATION_CONTROL_EXT;
67452 }
67453 impl RenderPassCreationControlEXT {
builder<'a>() -> RenderPassCreationControlEXTBuilder<'a>67454     pub fn builder<'a>() -> RenderPassCreationControlEXTBuilder<'a> {
67455         RenderPassCreationControlEXTBuilder {
67456             inner: Self::default(),
67457             marker: ::std::marker::PhantomData,
67458         }
67459     }
67460 }
67461 #[repr(transparent)]
67462 pub struct RenderPassCreationControlEXTBuilder<'a> {
67463     inner: RenderPassCreationControlEXT,
67464     marker: ::std::marker::PhantomData<&'a ()>,
67465 }
67466 unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassCreationControlEXTBuilder<'_> {}
67467 unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassCreationControlEXT {}
67468 unsafe impl ExtendsSubpassDescription2 for RenderPassCreationControlEXTBuilder<'_> {}
67469 unsafe impl ExtendsSubpassDescription2 for RenderPassCreationControlEXT {}
67470 impl<'a> ::std::ops::Deref for RenderPassCreationControlEXTBuilder<'a> {
67471     type Target = RenderPassCreationControlEXT;
deref(&self) -> &Self::Target67472     fn deref(&self) -> &Self::Target {
67473         &self.inner
67474     }
67475 }
67476 impl<'a> ::std::ops::DerefMut for RenderPassCreationControlEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target67477     fn deref_mut(&mut self) -> &mut Self::Target {
67478         &mut self.inner
67479     }
67480 }
67481 impl<'a> RenderPassCreationControlEXTBuilder<'a> {
67482     #[inline]
disallow_merging(mut self, disallow_merging: bool) -> Self67483     pub fn disallow_merging(mut self, disallow_merging: bool) -> Self {
67484         self.inner.disallow_merging = disallow_merging.into();
67485         self
67486     }
67487     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
67488     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
67489     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RenderPassCreationControlEXT67490     pub fn build(self) -> RenderPassCreationControlEXT {
67491         self.inner
67492     }
67493 }
67494 #[repr(C)]
67495 #[cfg_attr(feature = "debug", derive(Debug))]
67496 #[derive(Copy, Clone, Default)]
67497 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassCreationFeedbackInfoEXT.html>"]
67498 pub struct RenderPassCreationFeedbackInfoEXT {
67499     pub post_merge_subpass_count: u32,
67500 }
67501 impl RenderPassCreationFeedbackInfoEXT {
builder<'a>() -> RenderPassCreationFeedbackInfoEXTBuilder<'a>67502     pub fn builder<'a>() -> RenderPassCreationFeedbackInfoEXTBuilder<'a> {
67503         RenderPassCreationFeedbackInfoEXTBuilder {
67504             inner: Self::default(),
67505             marker: ::std::marker::PhantomData,
67506         }
67507     }
67508 }
67509 #[repr(transparent)]
67510 pub struct RenderPassCreationFeedbackInfoEXTBuilder<'a> {
67511     inner: RenderPassCreationFeedbackInfoEXT,
67512     marker: ::std::marker::PhantomData<&'a ()>,
67513 }
67514 impl<'a> ::std::ops::Deref for RenderPassCreationFeedbackInfoEXTBuilder<'a> {
67515     type Target = RenderPassCreationFeedbackInfoEXT;
deref(&self) -> &Self::Target67516     fn deref(&self) -> &Self::Target {
67517         &self.inner
67518     }
67519 }
67520 impl<'a> ::std::ops::DerefMut for RenderPassCreationFeedbackInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target67521     fn deref_mut(&mut self) -> &mut Self::Target {
67522         &mut self.inner
67523     }
67524 }
67525 impl<'a> RenderPassCreationFeedbackInfoEXTBuilder<'a> {
67526     #[inline]
post_merge_subpass_count(mut self, post_merge_subpass_count: u32) -> Self67527     pub fn post_merge_subpass_count(mut self, post_merge_subpass_count: u32) -> Self {
67528         self.inner.post_merge_subpass_count = post_merge_subpass_count;
67529         self
67530     }
67531     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
67532     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
67533     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RenderPassCreationFeedbackInfoEXT67534     pub fn build(self) -> RenderPassCreationFeedbackInfoEXT {
67535         self.inner
67536     }
67537 }
67538 #[repr(C)]
67539 #[cfg_attr(feature = "debug", derive(Debug))]
67540 #[derive(Copy, Clone)]
67541 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassCreationFeedbackCreateInfoEXT.html>"]
67542 pub struct RenderPassCreationFeedbackCreateInfoEXT {
67543     pub s_type: StructureType,
67544     pub p_next: *const c_void,
67545     pub p_render_pass_feedback: *mut RenderPassCreationFeedbackInfoEXT,
67546 }
67547 impl ::std::default::Default for RenderPassCreationFeedbackCreateInfoEXT {
67548     #[inline]
default() -> Self67549     fn default() -> Self {
67550         Self {
67551             s_type: Self::STRUCTURE_TYPE,
67552             p_next: ::std::ptr::null(),
67553             p_render_pass_feedback: ::std::ptr::null_mut(),
67554         }
67555     }
67556 }
67557 unsafe impl TaggedStructure for RenderPassCreationFeedbackCreateInfoEXT {
67558     const STRUCTURE_TYPE: StructureType =
67559         StructureType::RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT;
67560 }
67561 impl RenderPassCreationFeedbackCreateInfoEXT {
builder<'a>() -> RenderPassCreationFeedbackCreateInfoEXTBuilder<'a>67562     pub fn builder<'a>() -> RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> {
67563         RenderPassCreationFeedbackCreateInfoEXTBuilder {
67564             inner: Self::default(),
67565             marker: ::std::marker::PhantomData,
67566         }
67567     }
67568 }
67569 #[repr(transparent)]
67570 pub struct RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> {
67571     inner: RenderPassCreationFeedbackCreateInfoEXT,
67572     marker: ::std::marker::PhantomData<&'a ()>,
67573 }
67574 unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassCreationFeedbackCreateInfoEXTBuilder<'_> {}
67575 unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassCreationFeedbackCreateInfoEXT {}
67576 impl<'a> ::std::ops::Deref for RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> {
67577     type Target = RenderPassCreationFeedbackCreateInfoEXT;
deref(&self) -> &Self::Target67578     fn deref(&self) -> &Self::Target {
67579         &self.inner
67580     }
67581 }
67582 impl<'a> ::std::ops::DerefMut for RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target67583     fn deref_mut(&mut self) -> &mut Self::Target {
67584         &mut self.inner
67585     }
67586 }
67587 impl<'a> RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> {
67588     #[inline]
render_pass_feedback( mut self, render_pass_feedback: &'a mut RenderPassCreationFeedbackInfoEXT, ) -> Self67589     pub fn render_pass_feedback(
67590         mut self,
67591         render_pass_feedback: &'a mut RenderPassCreationFeedbackInfoEXT,
67592     ) -> Self {
67593         self.inner.p_render_pass_feedback = render_pass_feedback;
67594         self
67595     }
67596     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
67597     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
67598     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RenderPassCreationFeedbackCreateInfoEXT67599     pub fn build(self) -> RenderPassCreationFeedbackCreateInfoEXT {
67600         self.inner
67601     }
67602 }
67603 #[repr(C)]
67604 #[derive(Copy, Clone)]
67605 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassSubpassFeedbackInfoEXT.html>"]
67606 pub struct RenderPassSubpassFeedbackInfoEXT {
67607     pub subpass_merge_status: SubpassMergeStatusEXT,
67608     pub description: [c_char; MAX_DESCRIPTION_SIZE],
67609     pub post_merge_index: u32,
67610 }
67611 #[cfg(feature = "debug")]
67612 impl fmt::Debug for RenderPassSubpassFeedbackInfoEXT {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result67613     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
67614         fmt.debug_struct("RenderPassSubpassFeedbackInfoEXT")
67615             .field("subpass_merge_status", &self.subpass_merge_status)
67616             .field("description", &unsafe {
67617                 ::std::ffi::CStr::from_ptr(self.description.as_ptr())
67618             })
67619             .field("post_merge_index", &self.post_merge_index)
67620             .finish()
67621     }
67622 }
67623 impl ::std::default::Default for RenderPassSubpassFeedbackInfoEXT {
67624     #[inline]
default() -> Self67625     fn default() -> Self {
67626         Self {
67627             subpass_merge_status: SubpassMergeStatusEXT::default(),
67628             description: unsafe { ::std::mem::zeroed() },
67629             post_merge_index: u32::default(),
67630         }
67631     }
67632 }
67633 impl RenderPassSubpassFeedbackInfoEXT {
builder<'a>() -> RenderPassSubpassFeedbackInfoEXTBuilder<'a>67634     pub fn builder<'a>() -> RenderPassSubpassFeedbackInfoEXTBuilder<'a> {
67635         RenderPassSubpassFeedbackInfoEXTBuilder {
67636             inner: Self::default(),
67637             marker: ::std::marker::PhantomData,
67638         }
67639     }
67640 }
67641 #[repr(transparent)]
67642 pub struct RenderPassSubpassFeedbackInfoEXTBuilder<'a> {
67643     inner: RenderPassSubpassFeedbackInfoEXT,
67644     marker: ::std::marker::PhantomData<&'a ()>,
67645 }
67646 impl<'a> ::std::ops::Deref for RenderPassSubpassFeedbackInfoEXTBuilder<'a> {
67647     type Target = RenderPassSubpassFeedbackInfoEXT;
deref(&self) -> &Self::Target67648     fn deref(&self) -> &Self::Target {
67649         &self.inner
67650     }
67651 }
67652 impl<'a> ::std::ops::DerefMut for RenderPassSubpassFeedbackInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target67653     fn deref_mut(&mut self) -> &mut Self::Target {
67654         &mut self.inner
67655     }
67656 }
67657 impl<'a> RenderPassSubpassFeedbackInfoEXTBuilder<'a> {
67658     #[inline]
subpass_merge_status(mut self, subpass_merge_status: SubpassMergeStatusEXT) -> Self67659     pub fn subpass_merge_status(mut self, subpass_merge_status: SubpassMergeStatusEXT) -> Self {
67660         self.inner.subpass_merge_status = subpass_merge_status;
67661         self
67662     }
67663     #[inline]
description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self67664     pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
67665         self.inner.description = description;
67666         self
67667     }
67668     #[inline]
post_merge_index(mut self, post_merge_index: u32) -> Self67669     pub fn post_merge_index(mut self, post_merge_index: u32) -> Self {
67670         self.inner.post_merge_index = post_merge_index;
67671         self
67672     }
67673     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
67674     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
67675     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RenderPassSubpassFeedbackInfoEXT67676     pub fn build(self) -> RenderPassSubpassFeedbackInfoEXT {
67677         self.inner
67678     }
67679 }
67680 #[repr(C)]
67681 #[cfg_attr(feature = "debug", derive(Debug))]
67682 #[derive(Copy, Clone)]
67683 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassSubpassFeedbackCreateInfoEXT.html>"]
67684 pub struct RenderPassSubpassFeedbackCreateInfoEXT {
67685     pub s_type: StructureType,
67686     pub p_next: *const c_void,
67687     pub p_subpass_feedback: *mut RenderPassSubpassFeedbackInfoEXT,
67688 }
67689 impl ::std::default::Default for RenderPassSubpassFeedbackCreateInfoEXT {
67690     #[inline]
default() -> Self67691     fn default() -> Self {
67692         Self {
67693             s_type: Self::STRUCTURE_TYPE,
67694             p_next: ::std::ptr::null(),
67695             p_subpass_feedback: ::std::ptr::null_mut(),
67696         }
67697     }
67698 }
67699 unsafe impl TaggedStructure for RenderPassSubpassFeedbackCreateInfoEXT {
67700     const STRUCTURE_TYPE: StructureType =
67701         StructureType::RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT;
67702 }
67703 impl RenderPassSubpassFeedbackCreateInfoEXT {
builder<'a>() -> RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a>67704     pub fn builder<'a>() -> RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> {
67705         RenderPassSubpassFeedbackCreateInfoEXTBuilder {
67706             inner: Self::default(),
67707             marker: ::std::marker::PhantomData,
67708         }
67709     }
67710 }
67711 #[repr(transparent)]
67712 pub struct RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> {
67713     inner: RenderPassSubpassFeedbackCreateInfoEXT,
67714     marker: ::std::marker::PhantomData<&'a ()>,
67715 }
67716 unsafe impl ExtendsSubpassDescription2 for RenderPassSubpassFeedbackCreateInfoEXTBuilder<'_> {}
67717 unsafe impl ExtendsSubpassDescription2 for RenderPassSubpassFeedbackCreateInfoEXT {}
67718 impl<'a> ::std::ops::Deref for RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> {
67719     type Target = RenderPassSubpassFeedbackCreateInfoEXT;
deref(&self) -> &Self::Target67720     fn deref(&self) -> &Self::Target {
67721         &self.inner
67722     }
67723 }
67724 impl<'a> ::std::ops::DerefMut for RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target67725     fn deref_mut(&mut self) -> &mut Self::Target {
67726         &mut self.inner
67727     }
67728 }
67729 impl<'a> RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> {
67730     #[inline]
subpass_feedback( mut self, subpass_feedback: &'a mut RenderPassSubpassFeedbackInfoEXT, ) -> Self67731     pub fn subpass_feedback(
67732         mut self,
67733         subpass_feedback: &'a mut RenderPassSubpassFeedbackInfoEXT,
67734     ) -> Self {
67735         self.inner.p_subpass_feedback = subpass_feedback;
67736         self
67737     }
67738     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
67739     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
67740     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RenderPassSubpassFeedbackCreateInfoEXT67741     pub fn build(self) -> RenderPassSubpassFeedbackCreateInfoEXT {
67742         self.inner
67743     }
67744 }
67745 #[repr(C)]
67746 #[cfg_attr(feature = "debug", derive(Debug))]
67747 #[derive(Copy, Clone)]
67748 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT.html>"]
67749 pub struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXT {
67750     pub s_type: StructureType,
67751     pub p_next: *mut c_void,
67752     pub subpass_merge_feedback: Bool32,
67753 }
67754 impl ::std::default::Default for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT {
67755     #[inline]
default() -> Self67756     fn default() -> Self {
67757         Self {
67758             s_type: Self::STRUCTURE_TYPE,
67759             p_next: ::std::ptr::null_mut(),
67760             subpass_merge_feedback: Bool32::default(),
67761         }
67762     }
67763 }
67764 unsafe impl TaggedStructure for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT {
67765     const STRUCTURE_TYPE: StructureType =
67766         StructureType::PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
67767 }
67768 impl PhysicalDeviceSubpassMergeFeedbackFeaturesEXT {
builder<'a>() -> PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a>67769     pub fn builder<'a>() -> PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> {
67770         PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder {
67771             inner: Self::default(),
67772             marker: ::std::marker::PhantomData,
67773         }
67774     }
67775 }
67776 #[repr(transparent)]
67777 pub struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> {
67778     inner: PhysicalDeviceSubpassMergeFeedbackFeaturesEXT,
67779     marker: ::std::marker::PhantomData<&'a ()>,
67780 }
67781 unsafe impl ExtendsPhysicalDeviceFeatures2
67782     for PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'_>
67783 {
67784 }
67785 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT {}
67786 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'_> {}
67787 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT {}
67788 impl<'a> ::std::ops::Deref for PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> {
67789     type Target = PhysicalDeviceSubpassMergeFeedbackFeaturesEXT;
deref(&self) -> &Self::Target67790     fn deref(&self) -> &Self::Target {
67791         &self.inner
67792     }
67793 }
67794 impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target67795     fn deref_mut(&mut self) -> &mut Self::Target {
67796         &mut self.inner
67797     }
67798 }
67799 impl<'a> PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> {
67800     #[inline]
subpass_merge_feedback(mut self, subpass_merge_feedback: bool) -> Self67801     pub fn subpass_merge_feedback(mut self, subpass_merge_feedback: bool) -> Self {
67802         self.inner.subpass_merge_feedback = subpass_merge_feedback.into();
67803         self
67804     }
67805     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
67806     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
67807     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceSubpassMergeFeedbackFeaturesEXT67808     pub fn build(self) -> PhysicalDeviceSubpassMergeFeedbackFeaturesEXT {
67809         self.inner
67810     }
67811 }
67812 #[repr(C)]
67813 #[derive(Copy, Clone)]
67814 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMicromapBuildInfoEXT.html>"]
67815 pub struct MicromapBuildInfoEXT {
67816     pub s_type: StructureType,
67817     pub p_next: *const c_void,
67818     pub ty: MicromapTypeEXT,
67819     pub flags: BuildMicromapFlagsEXT,
67820     pub mode: BuildMicromapModeEXT,
67821     pub dst_micromap: MicromapEXT,
67822     pub usage_counts_count: u32,
67823     pub p_usage_counts: *const MicromapUsageEXT,
67824     pub pp_usage_counts: *const *const MicromapUsageEXT,
67825     pub data: DeviceOrHostAddressConstKHR,
67826     pub scratch_data: DeviceOrHostAddressKHR,
67827     pub triangle_array: DeviceOrHostAddressConstKHR,
67828     pub triangle_array_stride: DeviceSize,
67829 }
67830 #[cfg(feature = "debug")]
67831 impl fmt::Debug for MicromapBuildInfoEXT {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result67832     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
67833         fmt.debug_struct("MicromapBuildInfoEXT")
67834             .field("s_type", &self.s_type)
67835             .field("p_next", &self.p_next)
67836             .field("ty", &self.ty)
67837             .field("flags", &self.flags)
67838             .field("mode", &self.mode)
67839             .field("dst_micromap", &self.dst_micromap)
67840             .field("usage_counts_count", &self.usage_counts_count)
67841             .field("p_usage_counts", &self.p_usage_counts)
67842             .field("pp_usage_counts", &self.pp_usage_counts)
67843             .field("data", &"union")
67844             .field("scratch_data", &"union")
67845             .field("triangle_array", &"union")
67846             .field("triangle_array_stride", &self.triangle_array_stride)
67847             .finish()
67848     }
67849 }
67850 impl ::std::default::Default for MicromapBuildInfoEXT {
67851     #[inline]
default() -> Self67852     fn default() -> Self {
67853         Self {
67854             s_type: Self::STRUCTURE_TYPE,
67855             p_next: ::std::ptr::null(),
67856             ty: MicromapTypeEXT::default(),
67857             flags: BuildMicromapFlagsEXT::default(),
67858             mode: BuildMicromapModeEXT::default(),
67859             dst_micromap: MicromapEXT::default(),
67860             usage_counts_count: u32::default(),
67861             p_usage_counts: ::std::ptr::null(),
67862             pp_usage_counts: ::std::ptr::null(),
67863             data: DeviceOrHostAddressConstKHR::default(),
67864             scratch_data: DeviceOrHostAddressKHR::default(),
67865             triangle_array: DeviceOrHostAddressConstKHR::default(),
67866             triangle_array_stride: DeviceSize::default(),
67867         }
67868     }
67869 }
67870 unsafe impl TaggedStructure for MicromapBuildInfoEXT {
67871     const STRUCTURE_TYPE: StructureType = StructureType::MICROMAP_BUILD_INFO_EXT;
67872 }
67873 impl MicromapBuildInfoEXT {
builder<'a>() -> MicromapBuildInfoEXTBuilder<'a>67874     pub fn builder<'a>() -> MicromapBuildInfoEXTBuilder<'a> {
67875         MicromapBuildInfoEXTBuilder {
67876             inner: Self::default(),
67877             marker: ::std::marker::PhantomData,
67878         }
67879     }
67880 }
67881 #[repr(transparent)]
67882 pub struct MicromapBuildInfoEXTBuilder<'a> {
67883     inner: MicromapBuildInfoEXT,
67884     marker: ::std::marker::PhantomData<&'a ()>,
67885 }
67886 impl<'a> ::std::ops::Deref for MicromapBuildInfoEXTBuilder<'a> {
67887     type Target = MicromapBuildInfoEXT;
deref(&self) -> &Self::Target67888     fn deref(&self) -> &Self::Target {
67889         &self.inner
67890     }
67891 }
67892 impl<'a> ::std::ops::DerefMut for MicromapBuildInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target67893     fn deref_mut(&mut self) -> &mut Self::Target {
67894         &mut self.inner
67895     }
67896 }
67897 impl<'a> MicromapBuildInfoEXTBuilder<'a> {
67898     #[inline]
ty(mut self, ty: MicromapTypeEXT) -> Self67899     pub fn ty(mut self, ty: MicromapTypeEXT) -> Self {
67900         self.inner.ty = ty;
67901         self
67902     }
67903     #[inline]
flags(mut self, flags: BuildMicromapFlagsEXT) -> Self67904     pub fn flags(mut self, flags: BuildMicromapFlagsEXT) -> Self {
67905         self.inner.flags = flags;
67906         self
67907     }
67908     #[inline]
mode(mut self, mode: BuildMicromapModeEXT) -> Self67909     pub fn mode(mut self, mode: BuildMicromapModeEXT) -> Self {
67910         self.inner.mode = mode;
67911         self
67912     }
67913     #[inline]
dst_micromap(mut self, dst_micromap: MicromapEXT) -> Self67914     pub fn dst_micromap(mut self, dst_micromap: MicromapEXT) -> Self {
67915         self.inner.dst_micromap = dst_micromap;
67916         self
67917     }
67918     #[inline]
usage_counts(mut self, usage_counts: &'a [MicromapUsageEXT]) -> Self67919     pub fn usage_counts(mut self, usage_counts: &'a [MicromapUsageEXT]) -> Self {
67920         self.inner.usage_counts_count = usage_counts.len() as _;
67921         self.inner.p_usage_counts = usage_counts.as_ptr();
67922         self
67923     }
67924     #[inline]
usage_counts_ptrs(mut self, usage_counts_ptrs: &'a [&'a MicromapUsageEXT]) -> Self67925     pub fn usage_counts_ptrs(mut self, usage_counts_ptrs: &'a [&'a MicromapUsageEXT]) -> Self {
67926         self.inner.usage_counts_count = usage_counts_ptrs.len() as _;
67927         self.inner.pp_usage_counts = usage_counts_ptrs.as_ptr().cast();
67928         self
67929     }
67930     #[inline]
data(mut self, data: DeviceOrHostAddressConstKHR) -> Self67931     pub fn data(mut self, data: DeviceOrHostAddressConstKHR) -> Self {
67932         self.inner.data = data;
67933         self
67934     }
67935     #[inline]
scratch_data(mut self, scratch_data: DeviceOrHostAddressKHR) -> Self67936     pub fn scratch_data(mut self, scratch_data: DeviceOrHostAddressKHR) -> Self {
67937         self.inner.scratch_data = scratch_data;
67938         self
67939     }
67940     #[inline]
triangle_array(mut self, triangle_array: DeviceOrHostAddressConstKHR) -> Self67941     pub fn triangle_array(mut self, triangle_array: DeviceOrHostAddressConstKHR) -> Self {
67942         self.inner.triangle_array = triangle_array;
67943         self
67944     }
67945     #[inline]
triangle_array_stride(mut self, triangle_array_stride: DeviceSize) -> Self67946     pub fn triangle_array_stride(mut self, triangle_array_stride: DeviceSize) -> Self {
67947         self.inner.triangle_array_stride = triangle_array_stride;
67948         self
67949     }
67950     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
67951     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
67952     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MicromapBuildInfoEXT67953     pub fn build(self) -> MicromapBuildInfoEXT {
67954         self.inner
67955     }
67956 }
67957 #[repr(C)]
67958 #[cfg_attr(feature = "debug", derive(Debug))]
67959 #[derive(Copy, Clone)]
67960 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMicromapCreateInfoEXT.html>"]
67961 pub struct MicromapCreateInfoEXT {
67962     pub s_type: StructureType,
67963     pub p_next: *const c_void,
67964     pub create_flags: MicromapCreateFlagsEXT,
67965     pub buffer: Buffer,
67966     pub offset: DeviceSize,
67967     pub size: DeviceSize,
67968     pub ty: MicromapTypeEXT,
67969     pub device_address: DeviceAddress,
67970 }
67971 impl ::std::default::Default for MicromapCreateInfoEXT {
67972     #[inline]
default() -> Self67973     fn default() -> Self {
67974         Self {
67975             s_type: Self::STRUCTURE_TYPE,
67976             p_next: ::std::ptr::null(),
67977             create_flags: MicromapCreateFlagsEXT::default(),
67978             buffer: Buffer::default(),
67979             offset: DeviceSize::default(),
67980             size: DeviceSize::default(),
67981             ty: MicromapTypeEXT::default(),
67982             device_address: DeviceAddress::default(),
67983         }
67984     }
67985 }
67986 unsafe impl TaggedStructure for MicromapCreateInfoEXT {
67987     const STRUCTURE_TYPE: StructureType = StructureType::MICROMAP_CREATE_INFO_EXT;
67988 }
67989 impl MicromapCreateInfoEXT {
builder<'a>() -> MicromapCreateInfoEXTBuilder<'a>67990     pub fn builder<'a>() -> MicromapCreateInfoEXTBuilder<'a> {
67991         MicromapCreateInfoEXTBuilder {
67992             inner: Self::default(),
67993             marker: ::std::marker::PhantomData,
67994         }
67995     }
67996 }
67997 #[repr(transparent)]
67998 pub struct MicromapCreateInfoEXTBuilder<'a> {
67999     inner: MicromapCreateInfoEXT,
68000     marker: ::std::marker::PhantomData<&'a ()>,
68001 }
68002 impl<'a> ::std::ops::Deref for MicromapCreateInfoEXTBuilder<'a> {
68003     type Target = MicromapCreateInfoEXT;
deref(&self) -> &Self::Target68004     fn deref(&self) -> &Self::Target {
68005         &self.inner
68006     }
68007 }
68008 impl<'a> ::std::ops::DerefMut for MicromapCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target68009     fn deref_mut(&mut self) -> &mut Self::Target {
68010         &mut self.inner
68011     }
68012 }
68013 impl<'a> MicromapCreateInfoEXTBuilder<'a> {
68014     #[inline]
create_flags(mut self, create_flags: MicromapCreateFlagsEXT) -> Self68015     pub fn create_flags(mut self, create_flags: MicromapCreateFlagsEXT) -> Self {
68016         self.inner.create_flags = create_flags;
68017         self
68018     }
68019     #[inline]
buffer(mut self, buffer: Buffer) -> Self68020     pub fn buffer(mut self, buffer: Buffer) -> Self {
68021         self.inner.buffer = buffer;
68022         self
68023     }
68024     #[inline]
offset(mut self, offset: DeviceSize) -> Self68025     pub fn offset(mut self, offset: DeviceSize) -> Self {
68026         self.inner.offset = offset;
68027         self
68028     }
68029     #[inline]
size(mut self, size: DeviceSize) -> Self68030     pub fn size(mut self, size: DeviceSize) -> Self {
68031         self.inner.size = size;
68032         self
68033     }
68034     #[inline]
ty(mut self, ty: MicromapTypeEXT) -> Self68035     pub fn ty(mut self, ty: MicromapTypeEXT) -> Self {
68036         self.inner.ty = ty;
68037         self
68038     }
68039     #[inline]
device_address(mut self, device_address: DeviceAddress) -> Self68040     pub fn device_address(mut self, device_address: DeviceAddress) -> Self {
68041         self.inner.device_address = device_address;
68042         self
68043     }
68044     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
68045     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
68046     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MicromapCreateInfoEXT68047     pub fn build(self) -> MicromapCreateInfoEXT {
68048         self.inner
68049     }
68050 }
68051 #[repr(C)]
68052 #[cfg_attr(feature = "debug", derive(Debug))]
68053 #[derive(Copy, Clone)]
68054 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMicromapVersionInfoEXT.html>"]
68055 pub struct MicromapVersionInfoEXT {
68056     pub s_type: StructureType,
68057     pub p_next: *const c_void,
68058     pub p_version_data: *const [u8; 2 * UUID_SIZE],
68059 }
68060 impl ::std::default::Default for MicromapVersionInfoEXT {
68061     #[inline]
default() -> Self68062     fn default() -> Self {
68063         Self {
68064             s_type: Self::STRUCTURE_TYPE,
68065             p_next: ::std::ptr::null(),
68066             p_version_data: ::std::ptr::null(),
68067         }
68068     }
68069 }
68070 unsafe impl TaggedStructure for MicromapVersionInfoEXT {
68071     const STRUCTURE_TYPE: StructureType = StructureType::MICROMAP_VERSION_INFO_EXT;
68072 }
68073 impl MicromapVersionInfoEXT {
builder<'a>() -> MicromapVersionInfoEXTBuilder<'a>68074     pub fn builder<'a>() -> MicromapVersionInfoEXTBuilder<'a> {
68075         MicromapVersionInfoEXTBuilder {
68076             inner: Self::default(),
68077             marker: ::std::marker::PhantomData,
68078         }
68079     }
68080 }
68081 #[repr(transparent)]
68082 pub struct MicromapVersionInfoEXTBuilder<'a> {
68083     inner: MicromapVersionInfoEXT,
68084     marker: ::std::marker::PhantomData<&'a ()>,
68085 }
68086 impl<'a> ::std::ops::Deref for MicromapVersionInfoEXTBuilder<'a> {
68087     type Target = MicromapVersionInfoEXT;
deref(&self) -> &Self::Target68088     fn deref(&self) -> &Self::Target {
68089         &self.inner
68090     }
68091 }
68092 impl<'a> ::std::ops::DerefMut for MicromapVersionInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target68093     fn deref_mut(&mut self) -> &mut Self::Target {
68094         &mut self.inner
68095     }
68096 }
68097 impl<'a> MicromapVersionInfoEXTBuilder<'a> {
68098     #[inline]
version_data(mut self, version_data: &'a [u8; 2 * UUID_SIZE]) -> Self68099     pub fn version_data(mut self, version_data: &'a [u8; 2 * UUID_SIZE]) -> Self {
68100         self.inner.p_version_data = version_data;
68101         self
68102     }
68103     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
68104     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
68105     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MicromapVersionInfoEXT68106     pub fn build(self) -> MicromapVersionInfoEXT {
68107         self.inner
68108     }
68109 }
68110 #[repr(C)]
68111 #[cfg_attr(feature = "debug", derive(Debug))]
68112 #[derive(Copy, Clone)]
68113 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyMicromapInfoEXT.html>"]
68114 pub struct CopyMicromapInfoEXT {
68115     pub s_type: StructureType,
68116     pub p_next: *const c_void,
68117     pub src: MicromapEXT,
68118     pub dst: MicromapEXT,
68119     pub mode: CopyMicromapModeEXT,
68120 }
68121 impl ::std::default::Default for CopyMicromapInfoEXT {
68122     #[inline]
default() -> Self68123     fn default() -> Self {
68124         Self {
68125             s_type: Self::STRUCTURE_TYPE,
68126             p_next: ::std::ptr::null(),
68127             src: MicromapEXT::default(),
68128             dst: MicromapEXT::default(),
68129             mode: CopyMicromapModeEXT::default(),
68130         }
68131     }
68132 }
68133 unsafe impl TaggedStructure for CopyMicromapInfoEXT {
68134     const STRUCTURE_TYPE: StructureType = StructureType::COPY_MICROMAP_INFO_EXT;
68135 }
68136 impl CopyMicromapInfoEXT {
builder<'a>() -> CopyMicromapInfoEXTBuilder<'a>68137     pub fn builder<'a>() -> CopyMicromapInfoEXTBuilder<'a> {
68138         CopyMicromapInfoEXTBuilder {
68139             inner: Self::default(),
68140             marker: ::std::marker::PhantomData,
68141         }
68142     }
68143 }
68144 #[repr(transparent)]
68145 pub struct CopyMicromapInfoEXTBuilder<'a> {
68146     inner: CopyMicromapInfoEXT,
68147     marker: ::std::marker::PhantomData<&'a ()>,
68148 }
68149 impl<'a> ::std::ops::Deref for CopyMicromapInfoEXTBuilder<'a> {
68150     type Target = CopyMicromapInfoEXT;
deref(&self) -> &Self::Target68151     fn deref(&self) -> &Self::Target {
68152         &self.inner
68153     }
68154 }
68155 impl<'a> ::std::ops::DerefMut for CopyMicromapInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target68156     fn deref_mut(&mut self) -> &mut Self::Target {
68157         &mut self.inner
68158     }
68159 }
68160 impl<'a> CopyMicromapInfoEXTBuilder<'a> {
68161     #[inline]
src(mut self, src: MicromapEXT) -> Self68162     pub fn src(mut self, src: MicromapEXT) -> Self {
68163         self.inner.src = src;
68164         self
68165     }
68166     #[inline]
dst(mut self, dst: MicromapEXT) -> Self68167     pub fn dst(mut self, dst: MicromapEXT) -> Self {
68168         self.inner.dst = dst;
68169         self
68170     }
68171     #[inline]
mode(mut self, mode: CopyMicromapModeEXT) -> Self68172     pub fn mode(mut self, mode: CopyMicromapModeEXT) -> Self {
68173         self.inner.mode = mode;
68174         self
68175     }
68176     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
68177     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
68178     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CopyMicromapInfoEXT68179     pub fn build(self) -> CopyMicromapInfoEXT {
68180         self.inner
68181     }
68182 }
68183 #[repr(C)]
68184 #[derive(Copy, Clone)]
68185 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyMicromapToMemoryInfoEXT.html>"]
68186 pub struct CopyMicromapToMemoryInfoEXT {
68187     pub s_type: StructureType,
68188     pub p_next: *const c_void,
68189     pub src: MicromapEXT,
68190     pub dst: DeviceOrHostAddressKHR,
68191     pub mode: CopyMicromapModeEXT,
68192 }
68193 #[cfg(feature = "debug")]
68194 impl fmt::Debug for CopyMicromapToMemoryInfoEXT {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result68195     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
68196         fmt.debug_struct("CopyMicromapToMemoryInfoEXT")
68197             .field("s_type", &self.s_type)
68198             .field("p_next", &self.p_next)
68199             .field("src", &self.src)
68200             .field("dst", &"union")
68201             .field("mode", &self.mode)
68202             .finish()
68203     }
68204 }
68205 impl ::std::default::Default for CopyMicromapToMemoryInfoEXT {
68206     #[inline]
default() -> Self68207     fn default() -> Self {
68208         Self {
68209             s_type: Self::STRUCTURE_TYPE,
68210             p_next: ::std::ptr::null(),
68211             src: MicromapEXT::default(),
68212             dst: DeviceOrHostAddressKHR::default(),
68213             mode: CopyMicromapModeEXT::default(),
68214         }
68215     }
68216 }
68217 unsafe impl TaggedStructure for CopyMicromapToMemoryInfoEXT {
68218     const STRUCTURE_TYPE: StructureType = StructureType::COPY_MICROMAP_TO_MEMORY_INFO_EXT;
68219 }
68220 impl CopyMicromapToMemoryInfoEXT {
builder<'a>() -> CopyMicromapToMemoryInfoEXTBuilder<'a>68221     pub fn builder<'a>() -> CopyMicromapToMemoryInfoEXTBuilder<'a> {
68222         CopyMicromapToMemoryInfoEXTBuilder {
68223             inner: Self::default(),
68224             marker: ::std::marker::PhantomData,
68225         }
68226     }
68227 }
68228 #[repr(transparent)]
68229 pub struct CopyMicromapToMemoryInfoEXTBuilder<'a> {
68230     inner: CopyMicromapToMemoryInfoEXT,
68231     marker: ::std::marker::PhantomData<&'a ()>,
68232 }
68233 impl<'a> ::std::ops::Deref for CopyMicromapToMemoryInfoEXTBuilder<'a> {
68234     type Target = CopyMicromapToMemoryInfoEXT;
deref(&self) -> &Self::Target68235     fn deref(&self) -> &Self::Target {
68236         &self.inner
68237     }
68238 }
68239 impl<'a> ::std::ops::DerefMut for CopyMicromapToMemoryInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target68240     fn deref_mut(&mut self) -> &mut Self::Target {
68241         &mut self.inner
68242     }
68243 }
68244 impl<'a> CopyMicromapToMemoryInfoEXTBuilder<'a> {
68245     #[inline]
src(mut self, src: MicromapEXT) -> Self68246     pub fn src(mut self, src: MicromapEXT) -> Self {
68247         self.inner.src = src;
68248         self
68249     }
68250     #[inline]
dst(mut self, dst: DeviceOrHostAddressKHR) -> Self68251     pub fn dst(mut self, dst: DeviceOrHostAddressKHR) -> Self {
68252         self.inner.dst = dst;
68253         self
68254     }
68255     #[inline]
mode(mut self, mode: CopyMicromapModeEXT) -> Self68256     pub fn mode(mut self, mode: CopyMicromapModeEXT) -> Self {
68257         self.inner.mode = mode;
68258         self
68259     }
68260     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
68261     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
68262     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CopyMicromapToMemoryInfoEXT68263     pub fn build(self) -> CopyMicromapToMemoryInfoEXT {
68264         self.inner
68265     }
68266 }
68267 #[repr(C)]
68268 #[derive(Copy, Clone)]
68269 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyMemoryToMicromapInfoEXT.html>"]
68270 pub struct CopyMemoryToMicromapInfoEXT {
68271     pub s_type: StructureType,
68272     pub p_next: *const c_void,
68273     pub src: DeviceOrHostAddressConstKHR,
68274     pub dst: MicromapEXT,
68275     pub mode: CopyMicromapModeEXT,
68276 }
68277 #[cfg(feature = "debug")]
68278 impl fmt::Debug for CopyMemoryToMicromapInfoEXT {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result68279     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
68280         fmt.debug_struct("CopyMemoryToMicromapInfoEXT")
68281             .field("s_type", &self.s_type)
68282             .field("p_next", &self.p_next)
68283             .field("src", &"union")
68284             .field("dst", &self.dst)
68285             .field("mode", &self.mode)
68286             .finish()
68287     }
68288 }
68289 impl ::std::default::Default for CopyMemoryToMicromapInfoEXT {
68290     #[inline]
default() -> Self68291     fn default() -> Self {
68292         Self {
68293             s_type: Self::STRUCTURE_TYPE,
68294             p_next: ::std::ptr::null(),
68295             src: DeviceOrHostAddressConstKHR::default(),
68296             dst: MicromapEXT::default(),
68297             mode: CopyMicromapModeEXT::default(),
68298         }
68299     }
68300 }
68301 unsafe impl TaggedStructure for CopyMemoryToMicromapInfoEXT {
68302     const STRUCTURE_TYPE: StructureType = StructureType::COPY_MEMORY_TO_MICROMAP_INFO_EXT;
68303 }
68304 impl CopyMemoryToMicromapInfoEXT {
builder<'a>() -> CopyMemoryToMicromapInfoEXTBuilder<'a>68305     pub fn builder<'a>() -> CopyMemoryToMicromapInfoEXTBuilder<'a> {
68306         CopyMemoryToMicromapInfoEXTBuilder {
68307             inner: Self::default(),
68308             marker: ::std::marker::PhantomData,
68309         }
68310     }
68311 }
68312 #[repr(transparent)]
68313 pub struct CopyMemoryToMicromapInfoEXTBuilder<'a> {
68314     inner: CopyMemoryToMicromapInfoEXT,
68315     marker: ::std::marker::PhantomData<&'a ()>,
68316 }
68317 impl<'a> ::std::ops::Deref for CopyMemoryToMicromapInfoEXTBuilder<'a> {
68318     type Target = CopyMemoryToMicromapInfoEXT;
deref(&self) -> &Self::Target68319     fn deref(&self) -> &Self::Target {
68320         &self.inner
68321     }
68322 }
68323 impl<'a> ::std::ops::DerefMut for CopyMemoryToMicromapInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target68324     fn deref_mut(&mut self) -> &mut Self::Target {
68325         &mut self.inner
68326     }
68327 }
68328 impl<'a> CopyMemoryToMicromapInfoEXTBuilder<'a> {
68329     #[inline]
src(mut self, src: DeviceOrHostAddressConstKHR) -> Self68330     pub fn src(mut self, src: DeviceOrHostAddressConstKHR) -> Self {
68331         self.inner.src = src;
68332         self
68333     }
68334     #[inline]
dst(mut self, dst: MicromapEXT) -> Self68335     pub fn dst(mut self, dst: MicromapEXT) -> Self {
68336         self.inner.dst = dst;
68337         self
68338     }
68339     #[inline]
mode(mut self, mode: CopyMicromapModeEXT) -> Self68340     pub fn mode(mut self, mode: CopyMicromapModeEXT) -> Self {
68341         self.inner.mode = mode;
68342         self
68343     }
68344     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
68345     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
68346     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CopyMemoryToMicromapInfoEXT68347     pub fn build(self) -> CopyMemoryToMicromapInfoEXT {
68348         self.inner
68349     }
68350 }
68351 #[repr(C)]
68352 #[cfg_attr(feature = "debug", derive(Debug))]
68353 #[derive(Copy, Clone)]
68354 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMicromapBuildSizesInfoEXT.html>"]
68355 pub struct MicromapBuildSizesInfoEXT {
68356     pub s_type: StructureType,
68357     pub p_next: *const c_void,
68358     pub micromap_size: DeviceSize,
68359     pub build_scratch_size: DeviceSize,
68360     pub discardable: Bool32,
68361 }
68362 impl ::std::default::Default for MicromapBuildSizesInfoEXT {
68363     #[inline]
default() -> Self68364     fn default() -> Self {
68365         Self {
68366             s_type: Self::STRUCTURE_TYPE,
68367             p_next: ::std::ptr::null(),
68368             micromap_size: DeviceSize::default(),
68369             build_scratch_size: DeviceSize::default(),
68370             discardable: Bool32::default(),
68371         }
68372     }
68373 }
68374 unsafe impl TaggedStructure for MicromapBuildSizesInfoEXT {
68375     const STRUCTURE_TYPE: StructureType = StructureType::MICROMAP_BUILD_SIZES_INFO_EXT;
68376 }
68377 impl MicromapBuildSizesInfoEXT {
builder<'a>() -> MicromapBuildSizesInfoEXTBuilder<'a>68378     pub fn builder<'a>() -> MicromapBuildSizesInfoEXTBuilder<'a> {
68379         MicromapBuildSizesInfoEXTBuilder {
68380             inner: Self::default(),
68381             marker: ::std::marker::PhantomData,
68382         }
68383     }
68384 }
68385 #[repr(transparent)]
68386 pub struct MicromapBuildSizesInfoEXTBuilder<'a> {
68387     inner: MicromapBuildSizesInfoEXT,
68388     marker: ::std::marker::PhantomData<&'a ()>,
68389 }
68390 impl<'a> ::std::ops::Deref for MicromapBuildSizesInfoEXTBuilder<'a> {
68391     type Target = MicromapBuildSizesInfoEXT;
deref(&self) -> &Self::Target68392     fn deref(&self) -> &Self::Target {
68393         &self.inner
68394     }
68395 }
68396 impl<'a> ::std::ops::DerefMut for MicromapBuildSizesInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target68397     fn deref_mut(&mut self) -> &mut Self::Target {
68398         &mut self.inner
68399     }
68400 }
68401 impl<'a> MicromapBuildSizesInfoEXTBuilder<'a> {
68402     #[inline]
micromap_size(mut self, micromap_size: DeviceSize) -> Self68403     pub fn micromap_size(mut self, micromap_size: DeviceSize) -> Self {
68404         self.inner.micromap_size = micromap_size;
68405         self
68406     }
68407     #[inline]
build_scratch_size(mut self, build_scratch_size: DeviceSize) -> Self68408     pub fn build_scratch_size(mut self, build_scratch_size: DeviceSize) -> Self {
68409         self.inner.build_scratch_size = build_scratch_size;
68410         self
68411     }
68412     #[inline]
discardable(mut self, discardable: bool) -> Self68413     pub fn discardable(mut self, discardable: bool) -> Self {
68414         self.inner.discardable = discardable.into();
68415         self
68416     }
68417     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
68418     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
68419     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MicromapBuildSizesInfoEXT68420     pub fn build(self) -> MicromapBuildSizesInfoEXT {
68421         self.inner
68422     }
68423 }
68424 #[repr(C)]
68425 #[cfg_attr(feature = "debug", derive(Debug))]
68426 #[derive(Copy, Clone, Default)]
68427 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMicromapUsageEXT.html>"]
68428 pub struct MicromapUsageEXT {
68429     pub count: u32,
68430     pub subdivision_level: u32,
68431     pub format: u32,
68432 }
68433 impl MicromapUsageEXT {
builder<'a>() -> MicromapUsageEXTBuilder<'a>68434     pub fn builder<'a>() -> MicromapUsageEXTBuilder<'a> {
68435         MicromapUsageEXTBuilder {
68436             inner: Self::default(),
68437             marker: ::std::marker::PhantomData,
68438         }
68439     }
68440 }
68441 #[repr(transparent)]
68442 pub struct MicromapUsageEXTBuilder<'a> {
68443     inner: MicromapUsageEXT,
68444     marker: ::std::marker::PhantomData<&'a ()>,
68445 }
68446 impl<'a> ::std::ops::Deref for MicromapUsageEXTBuilder<'a> {
68447     type Target = MicromapUsageEXT;
deref(&self) -> &Self::Target68448     fn deref(&self) -> &Self::Target {
68449         &self.inner
68450     }
68451 }
68452 impl<'a> ::std::ops::DerefMut for MicromapUsageEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target68453     fn deref_mut(&mut self) -> &mut Self::Target {
68454         &mut self.inner
68455     }
68456 }
68457 impl<'a> MicromapUsageEXTBuilder<'a> {
68458     #[inline]
count(mut self, count: u32) -> Self68459     pub fn count(mut self, count: u32) -> Self {
68460         self.inner.count = count;
68461         self
68462     }
68463     #[inline]
subdivision_level(mut self, subdivision_level: u32) -> Self68464     pub fn subdivision_level(mut self, subdivision_level: u32) -> Self {
68465         self.inner.subdivision_level = subdivision_level;
68466         self
68467     }
68468     #[inline]
format(mut self, format: u32) -> Self68469     pub fn format(mut self, format: u32) -> Self {
68470         self.inner.format = format;
68471         self
68472     }
68473     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
68474     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
68475     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MicromapUsageEXT68476     pub fn build(self) -> MicromapUsageEXT {
68477         self.inner
68478     }
68479 }
68480 #[repr(C)]
68481 #[cfg_attr(feature = "debug", derive(Debug))]
68482 #[derive(Copy, Clone, Default)]
68483 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMicromapTriangleEXT.html>"]
68484 pub struct MicromapTriangleEXT {
68485     pub data_offset: u32,
68486     pub subdivision_level: u16,
68487     pub format: u16,
68488 }
68489 impl MicromapTriangleEXT {
builder<'a>() -> MicromapTriangleEXTBuilder<'a>68490     pub fn builder<'a>() -> MicromapTriangleEXTBuilder<'a> {
68491         MicromapTriangleEXTBuilder {
68492             inner: Self::default(),
68493             marker: ::std::marker::PhantomData,
68494         }
68495     }
68496 }
68497 #[repr(transparent)]
68498 pub struct MicromapTriangleEXTBuilder<'a> {
68499     inner: MicromapTriangleEXT,
68500     marker: ::std::marker::PhantomData<&'a ()>,
68501 }
68502 impl<'a> ::std::ops::Deref for MicromapTriangleEXTBuilder<'a> {
68503     type Target = MicromapTriangleEXT;
deref(&self) -> &Self::Target68504     fn deref(&self) -> &Self::Target {
68505         &self.inner
68506     }
68507 }
68508 impl<'a> ::std::ops::DerefMut for MicromapTriangleEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target68509     fn deref_mut(&mut self) -> &mut Self::Target {
68510         &mut self.inner
68511     }
68512 }
68513 impl<'a> MicromapTriangleEXTBuilder<'a> {
68514     #[inline]
data_offset(mut self, data_offset: u32) -> Self68515     pub fn data_offset(mut self, data_offset: u32) -> Self {
68516         self.inner.data_offset = data_offset;
68517         self
68518     }
68519     #[inline]
subdivision_level(mut self, subdivision_level: u16) -> Self68520     pub fn subdivision_level(mut self, subdivision_level: u16) -> Self {
68521         self.inner.subdivision_level = subdivision_level;
68522         self
68523     }
68524     #[inline]
format(mut self, format: u16) -> Self68525     pub fn format(mut self, format: u16) -> Self {
68526         self.inner.format = format;
68527         self
68528     }
68529     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
68530     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
68531     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MicromapTriangleEXT68532     pub fn build(self) -> MicromapTriangleEXT {
68533         self.inner
68534     }
68535 }
68536 #[repr(C)]
68537 #[cfg_attr(feature = "debug", derive(Debug))]
68538 #[derive(Copy, Clone)]
68539 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceOpacityMicromapFeaturesEXT.html>"]
68540 pub struct PhysicalDeviceOpacityMicromapFeaturesEXT {
68541     pub s_type: StructureType,
68542     pub p_next: *mut c_void,
68543     pub micromap: Bool32,
68544     pub micromap_capture_replay: Bool32,
68545     pub micromap_host_commands: Bool32,
68546 }
68547 impl ::std::default::Default for PhysicalDeviceOpacityMicromapFeaturesEXT {
68548     #[inline]
default() -> Self68549     fn default() -> Self {
68550         Self {
68551             s_type: Self::STRUCTURE_TYPE,
68552             p_next: ::std::ptr::null_mut(),
68553             micromap: Bool32::default(),
68554             micromap_capture_replay: Bool32::default(),
68555             micromap_host_commands: Bool32::default(),
68556         }
68557     }
68558 }
68559 unsafe impl TaggedStructure for PhysicalDeviceOpacityMicromapFeaturesEXT {
68560     const STRUCTURE_TYPE: StructureType =
68561         StructureType::PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
68562 }
68563 impl PhysicalDeviceOpacityMicromapFeaturesEXT {
builder<'a>() -> PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'a>68564     pub fn builder<'a>() -> PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'a> {
68565         PhysicalDeviceOpacityMicromapFeaturesEXTBuilder {
68566             inner: Self::default(),
68567             marker: ::std::marker::PhantomData,
68568         }
68569     }
68570 }
68571 #[repr(transparent)]
68572 pub struct PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'a> {
68573     inner: PhysicalDeviceOpacityMicromapFeaturesEXT,
68574     marker: ::std::marker::PhantomData<&'a ()>,
68575 }
68576 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'_> {}
68577 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceOpacityMicromapFeaturesEXT {}
68578 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'_> {}
68579 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceOpacityMicromapFeaturesEXT {}
68580 impl<'a> ::std::ops::Deref for PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'a> {
68581     type Target = PhysicalDeviceOpacityMicromapFeaturesEXT;
deref(&self) -> &Self::Target68582     fn deref(&self) -> &Self::Target {
68583         &self.inner
68584     }
68585 }
68586 impl<'a> ::std::ops::DerefMut for PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target68587     fn deref_mut(&mut self) -> &mut Self::Target {
68588         &mut self.inner
68589     }
68590 }
68591 impl<'a> PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'a> {
68592     #[inline]
micromap(mut self, micromap: bool) -> Self68593     pub fn micromap(mut self, micromap: bool) -> Self {
68594         self.inner.micromap = micromap.into();
68595         self
68596     }
68597     #[inline]
micromap_capture_replay(mut self, micromap_capture_replay: bool) -> Self68598     pub fn micromap_capture_replay(mut self, micromap_capture_replay: bool) -> Self {
68599         self.inner.micromap_capture_replay = micromap_capture_replay.into();
68600         self
68601     }
68602     #[inline]
micromap_host_commands(mut self, micromap_host_commands: bool) -> Self68603     pub fn micromap_host_commands(mut self, micromap_host_commands: bool) -> Self {
68604         self.inner.micromap_host_commands = micromap_host_commands.into();
68605         self
68606     }
68607     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
68608     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
68609     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceOpacityMicromapFeaturesEXT68610     pub fn build(self) -> PhysicalDeviceOpacityMicromapFeaturesEXT {
68611         self.inner
68612     }
68613 }
68614 #[repr(C)]
68615 #[cfg_attr(feature = "debug", derive(Debug))]
68616 #[derive(Copy, Clone)]
68617 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceOpacityMicromapPropertiesEXT.html>"]
68618 pub struct PhysicalDeviceOpacityMicromapPropertiesEXT {
68619     pub s_type: StructureType,
68620     pub p_next: *mut c_void,
68621     pub max_opacity2_state_subdivision_level: u32,
68622     pub max_opacity4_state_subdivision_level: u32,
68623 }
68624 impl ::std::default::Default for PhysicalDeviceOpacityMicromapPropertiesEXT {
68625     #[inline]
default() -> Self68626     fn default() -> Self {
68627         Self {
68628             s_type: Self::STRUCTURE_TYPE,
68629             p_next: ::std::ptr::null_mut(),
68630             max_opacity2_state_subdivision_level: u32::default(),
68631             max_opacity4_state_subdivision_level: u32::default(),
68632         }
68633     }
68634 }
68635 unsafe impl TaggedStructure for PhysicalDeviceOpacityMicromapPropertiesEXT {
68636     const STRUCTURE_TYPE: StructureType =
68637         StructureType::PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT;
68638 }
68639 impl PhysicalDeviceOpacityMicromapPropertiesEXT {
builder<'a>() -> PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'a>68640     pub fn builder<'a>() -> PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'a> {
68641         PhysicalDeviceOpacityMicromapPropertiesEXTBuilder {
68642             inner: Self::default(),
68643             marker: ::std::marker::PhantomData,
68644         }
68645     }
68646 }
68647 #[repr(transparent)]
68648 pub struct PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'a> {
68649     inner: PhysicalDeviceOpacityMicromapPropertiesEXT,
68650     marker: ::std::marker::PhantomData<&'a ()>,
68651 }
68652 unsafe impl ExtendsPhysicalDeviceProperties2
68653     for PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'_>
68654 {
68655 }
68656 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceOpacityMicromapPropertiesEXT {}
68657 impl<'a> ::std::ops::Deref for PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'a> {
68658     type Target = PhysicalDeviceOpacityMicromapPropertiesEXT;
deref(&self) -> &Self::Target68659     fn deref(&self) -> &Self::Target {
68660         &self.inner
68661     }
68662 }
68663 impl<'a> ::std::ops::DerefMut for PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target68664     fn deref_mut(&mut self) -> &mut Self::Target {
68665         &mut self.inner
68666     }
68667 }
68668 impl<'a> PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'a> {
68669     #[inline]
max_opacity2_state_subdivision_level( mut self, max_opacity2_state_subdivision_level: u32, ) -> Self68670     pub fn max_opacity2_state_subdivision_level(
68671         mut self,
68672         max_opacity2_state_subdivision_level: u32,
68673     ) -> Self {
68674         self.inner.max_opacity2_state_subdivision_level = max_opacity2_state_subdivision_level;
68675         self
68676     }
68677     #[inline]
max_opacity4_state_subdivision_level( mut self, max_opacity4_state_subdivision_level: u32, ) -> Self68678     pub fn max_opacity4_state_subdivision_level(
68679         mut self,
68680         max_opacity4_state_subdivision_level: u32,
68681     ) -> Self {
68682         self.inner.max_opacity4_state_subdivision_level = max_opacity4_state_subdivision_level;
68683         self
68684     }
68685     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
68686     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
68687     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceOpacityMicromapPropertiesEXT68688     pub fn build(self) -> PhysicalDeviceOpacityMicromapPropertiesEXT {
68689         self.inner
68690     }
68691 }
68692 #[repr(C)]
68693 #[derive(Copy, Clone)]
68694 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureTrianglesOpacityMicromapEXT.html>"]
68695 pub struct AccelerationStructureTrianglesOpacityMicromapEXT {
68696     pub s_type: StructureType,
68697     pub p_next: *mut c_void,
68698     pub index_type: IndexType,
68699     pub index_buffer: DeviceOrHostAddressConstKHR,
68700     pub index_stride: DeviceSize,
68701     pub base_triangle: u32,
68702     pub usage_counts_count: u32,
68703     pub p_usage_counts: *const MicromapUsageEXT,
68704     pub pp_usage_counts: *const *const MicromapUsageEXT,
68705     pub micromap: MicromapEXT,
68706 }
68707 #[cfg(feature = "debug")]
68708 impl fmt::Debug for AccelerationStructureTrianglesOpacityMicromapEXT {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result68709     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
68710         fmt.debug_struct("AccelerationStructureTrianglesOpacityMicromapEXT")
68711             .field("s_type", &self.s_type)
68712             .field("p_next", &self.p_next)
68713             .field("index_type", &self.index_type)
68714             .field("index_buffer", &"union")
68715             .field("index_stride", &self.index_stride)
68716             .field("base_triangle", &self.base_triangle)
68717             .field("usage_counts_count", &self.usage_counts_count)
68718             .field("p_usage_counts", &self.p_usage_counts)
68719             .field("pp_usage_counts", &self.pp_usage_counts)
68720             .field("micromap", &self.micromap)
68721             .finish()
68722     }
68723 }
68724 impl ::std::default::Default for AccelerationStructureTrianglesOpacityMicromapEXT {
68725     #[inline]
default() -> Self68726     fn default() -> Self {
68727         Self {
68728             s_type: Self::STRUCTURE_TYPE,
68729             p_next: ::std::ptr::null_mut(),
68730             index_type: IndexType::default(),
68731             index_buffer: DeviceOrHostAddressConstKHR::default(),
68732             index_stride: DeviceSize::default(),
68733             base_triangle: u32::default(),
68734             usage_counts_count: u32::default(),
68735             p_usage_counts: ::std::ptr::null(),
68736             pp_usage_counts: ::std::ptr::null(),
68737             micromap: MicromapEXT::default(),
68738         }
68739     }
68740 }
68741 unsafe impl TaggedStructure for AccelerationStructureTrianglesOpacityMicromapEXT {
68742     const STRUCTURE_TYPE: StructureType =
68743         StructureType::ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT;
68744 }
68745 impl AccelerationStructureTrianglesOpacityMicromapEXT {
builder<'a>() -> AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'a>68746     pub fn builder<'a>() -> AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'a> {
68747         AccelerationStructureTrianglesOpacityMicromapEXTBuilder {
68748             inner: Self::default(),
68749             marker: ::std::marker::PhantomData,
68750         }
68751     }
68752 }
68753 #[repr(transparent)]
68754 pub struct AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'a> {
68755     inner: AccelerationStructureTrianglesOpacityMicromapEXT,
68756     marker: ::std::marker::PhantomData<&'a ()>,
68757 }
68758 unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR
68759     for AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'_>
68760 {
68761 }
68762 unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR
68763     for AccelerationStructureTrianglesOpacityMicromapEXT
68764 {
68765 }
68766 impl<'a> ::std::ops::Deref for AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'a> {
68767     type Target = AccelerationStructureTrianglesOpacityMicromapEXT;
deref(&self) -> &Self::Target68768     fn deref(&self) -> &Self::Target {
68769         &self.inner
68770     }
68771 }
68772 impl<'a> ::std::ops::DerefMut for AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target68773     fn deref_mut(&mut self) -> &mut Self::Target {
68774         &mut self.inner
68775     }
68776 }
68777 impl<'a> AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'a> {
68778     #[inline]
index_type(mut self, index_type: IndexType) -> Self68779     pub fn index_type(mut self, index_type: IndexType) -> Self {
68780         self.inner.index_type = index_type;
68781         self
68782     }
68783     #[inline]
index_buffer(mut self, index_buffer: DeviceOrHostAddressConstKHR) -> Self68784     pub fn index_buffer(mut self, index_buffer: DeviceOrHostAddressConstKHR) -> Self {
68785         self.inner.index_buffer = index_buffer;
68786         self
68787     }
68788     #[inline]
index_stride(mut self, index_stride: DeviceSize) -> Self68789     pub fn index_stride(mut self, index_stride: DeviceSize) -> Self {
68790         self.inner.index_stride = index_stride;
68791         self
68792     }
68793     #[inline]
base_triangle(mut self, base_triangle: u32) -> Self68794     pub fn base_triangle(mut self, base_triangle: u32) -> Self {
68795         self.inner.base_triangle = base_triangle;
68796         self
68797     }
68798     #[inline]
usage_counts(mut self, usage_counts: &'a [MicromapUsageEXT]) -> Self68799     pub fn usage_counts(mut self, usage_counts: &'a [MicromapUsageEXT]) -> Self {
68800         self.inner.usage_counts_count = usage_counts.len() as _;
68801         self.inner.p_usage_counts = usage_counts.as_ptr();
68802         self
68803     }
68804     #[inline]
usage_counts_ptrs(mut self, usage_counts_ptrs: &'a [&'a MicromapUsageEXT]) -> Self68805     pub fn usage_counts_ptrs(mut self, usage_counts_ptrs: &'a [&'a MicromapUsageEXT]) -> Self {
68806         self.inner.usage_counts_count = usage_counts_ptrs.len() as _;
68807         self.inner.pp_usage_counts = usage_counts_ptrs.as_ptr().cast();
68808         self
68809     }
68810     #[inline]
micromap(mut self, micromap: MicromapEXT) -> Self68811     pub fn micromap(mut self, micromap: MicromapEXT) -> Self {
68812         self.inner.micromap = micromap;
68813         self
68814     }
68815     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
68816     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
68817     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureTrianglesOpacityMicromapEXT68818     pub fn build(self) -> AccelerationStructureTrianglesOpacityMicromapEXT {
68819         self.inner
68820     }
68821 }
68822 #[repr(C)]
68823 #[cfg_attr(feature = "debug", derive(Debug))]
68824 #[derive(Copy, Clone)]
68825 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDisplacementMicromapFeaturesNV.html>"]
68826 pub struct PhysicalDeviceDisplacementMicromapFeaturesNV {
68827     pub s_type: StructureType,
68828     pub p_next: *mut c_void,
68829     pub displacement_micromap: Bool32,
68830 }
68831 impl ::std::default::Default for PhysicalDeviceDisplacementMicromapFeaturesNV {
68832     #[inline]
default() -> Self68833     fn default() -> Self {
68834         Self {
68835             s_type: Self::STRUCTURE_TYPE,
68836             p_next: ::std::ptr::null_mut(),
68837             displacement_micromap: Bool32::default(),
68838         }
68839     }
68840 }
68841 unsafe impl TaggedStructure for PhysicalDeviceDisplacementMicromapFeaturesNV {
68842     const STRUCTURE_TYPE: StructureType =
68843         StructureType::PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV;
68844 }
68845 impl PhysicalDeviceDisplacementMicromapFeaturesNV {
builder<'a>() -> PhysicalDeviceDisplacementMicromapFeaturesNVBuilder<'a>68846     pub fn builder<'a>() -> PhysicalDeviceDisplacementMicromapFeaturesNVBuilder<'a> {
68847         PhysicalDeviceDisplacementMicromapFeaturesNVBuilder {
68848             inner: Self::default(),
68849             marker: ::std::marker::PhantomData,
68850         }
68851     }
68852 }
68853 #[repr(transparent)]
68854 pub struct PhysicalDeviceDisplacementMicromapFeaturesNVBuilder<'a> {
68855     inner: PhysicalDeviceDisplacementMicromapFeaturesNV,
68856     marker: ::std::marker::PhantomData<&'a ()>,
68857 }
68858 unsafe impl ExtendsPhysicalDeviceFeatures2
68859     for PhysicalDeviceDisplacementMicromapFeaturesNVBuilder<'_>
68860 {
68861 }
68862 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDisplacementMicromapFeaturesNV {}
68863 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDisplacementMicromapFeaturesNVBuilder<'_> {}
68864 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDisplacementMicromapFeaturesNV {}
68865 impl<'a> ::std::ops::Deref for PhysicalDeviceDisplacementMicromapFeaturesNVBuilder<'a> {
68866     type Target = PhysicalDeviceDisplacementMicromapFeaturesNV;
deref(&self) -> &Self::Target68867     fn deref(&self) -> &Self::Target {
68868         &self.inner
68869     }
68870 }
68871 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDisplacementMicromapFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target68872     fn deref_mut(&mut self) -> &mut Self::Target {
68873         &mut self.inner
68874     }
68875 }
68876 impl<'a> PhysicalDeviceDisplacementMicromapFeaturesNVBuilder<'a> {
68877     #[inline]
displacement_micromap(mut self, displacement_micromap: bool) -> Self68878     pub fn displacement_micromap(mut self, displacement_micromap: bool) -> Self {
68879         self.inner.displacement_micromap = displacement_micromap.into();
68880         self
68881     }
68882     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
68883     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
68884     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDisplacementMicromapFeaturesNV68885     pub fn build(self) -> PhysicalDeviceDisplacementMicromapFeaturesNV {
68886         self.inner
68887     }
68888 }
68889 #[repr(C)]
68890 #[cfg_attr(feature = "debug", derive(Debug))]
68891 #[derive(Copy, Clone)]
68892 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDisplacementMicromapPropertiesNV.html>"]
68893 pub struct PhysicalDeviceDisplacementMicromapPropertiesNV {
68894     pub s_type: StructureType,
68895     pub p_next: *mut c_void,
68896     pub max_displacement_micromap_subdivision_level: u32,
68897 }
68898 impl ::std::default::Default for PhysicalDeviceDisplacementMicromapPropertiesNV {
68899     #[inline]
default() -> Self68900     fn default() -> Self {
68901         Self {
68902             s_type: Self::STRUCTURE_TYPE,
68903             p_next: ::std::ptr::null_mut(),
68904             max_displacement_micromap_subdivision_level: u32::default(),
68905         }
68906     }
68907 }
68908 unsafe impl TaggedStructure for PhysicalDeviceDisplacementMicromapPropertiesNV {
68909     const STRUCTURE_TYPE: StructureType =
68910         StructureType::PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV;
68911 }
68912 impl PhysicalDeviceDisplacementMicromapPropertiesNV {
builder<'a>() -> PhysicalDeviceDisplacementMicromapPropertiesNVBuilder<'a>68913     pub fn builder<'a>() -> PhysicalDeviceDisplacementMicromapPropertiesNVBuilder<'a> {
68914         PhysicalDeviceDisplacementMicromapPropertiesNVBuilder {
68915             inner: Self::default(),
68916             marker: ::std::marker::PhantomData,
68917         }
68918     }
68919 }
68920 #[repr(transparent)]
68921 pub struct PhysicalDeviceDisplacementMicromapPropertiesNVBuilder<'a> {
68922     inner: PhysicalDeviceDisplacementMicromapPropertiesNV,
68923     marker: ::std::marker::PhantomData<&'a ()>,
68924 }
68925 unsafe impl ExtendsPhysicalDeviceProperties2
68926     for PhysicalDeviceDisplacementMicromapPropertiesNVBuilder<'_>
68927 {
68928 }
68929 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDisplacementMicromapPropertiesNV {}
68930 impl<'a> ::std::ops::Deref for PhysicalDeviceDisplacementMicromapPropertiesNVBuilder<'a> {
68931     type Target = PhysicalDeviceDisplacementMicromapPropertiesNV;
deref(&self) -> &Self::Target68932     fn deref(&self) -> &Self::Target {
68933         &self.inner
68934     }
68935 }
68936 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDisplacementMicromapPropertiesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target68937     fn deref_mut(&mut self) -> &mut Self::Target {
68938         &mut self.inner
68939     }
68940 }
68941 impl<'a> PhysicalDeviceDisplacementMicromapPropertiesNVBuilder<'a> {
68942     #[inline]
max_displacement_micromap_subdivision_level( mut self, max_displacement_micromap_subdivision_level: u32, ) -> Self68943     pub fn max_displacement_micromap_subdivision_level(
68944         mut self,
68945         max_displacement_micromap_subdivision_level: u32,
68946     ) -> Self {
68947         self.inner.max_displacement_micromap_subdivision_level =
68948             max_displacement_micromap_subdivision_level;
68949         self
68950     }
68951     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
68952     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
68953     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDisplacementMicromapPropertiesNV68954     pub fn build(self) -> PhysicalDeviceDisplacementMicromapPropertiesNV {
68955         self.inner
68956     }
68957 }
68958 #[repr(C)]
68959 #[derive(Copy, Clone)]
68960 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureTrianglesDisplacementMicromapNV.html>"]
68961 pub struct AccelerationStructureTrianglesDisplacementMicromapNV {
68962     pub s_type: StructureType,
68963     pub p_next: *mut c_void,
68964     pub displacement_bias_and_scale_format: Format,
68965     pub displacement_vector_format: Format,
68966     pub displacement_bias_and_scale_buffer: DeviceOrHostAddressConstKHR,
68967     pub displacement_bias_and_scale_stride: DeviceSize,
68968     pub displacement_vector_buffer: DeviceOrHostAddressConstKHR,
68969     pub displacement_vector_stride: DeviceSize,
68970     pub displaced_micromap_primitive_flags: DeviceOrHostAddressConstKHR,
68971     pub displaced_micromap_primitive_flags_stride: DeviceSize,
68972     pub index_type: IndexType,
68973     pub index_buffer: DeviceOrHostAddressConstKHR,
68974     pub index_stride: DeviceSize,
68975     pub base_triangle: u32,
68976     pub usage_counts_count: u32,
68977     pub p_usage_counts: *const MicromapUsageEXT,
68978     pub pp_usage_counts: *const *const MicromapUsageEXT,
68979     pub micromap: MicromapEXT,
68980 }
68981 #[cfg(feature = "debug")]
68982 impl fmt::Debug for AccelerationStructureTrianglesDisplacementMicromapNV {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result68983     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
68984         fmt.debug_struct("AccelerationStructureTrianglesDisplacementMicromapNV")
68985             .field("s_type", &self.s_type)
68986             .field("p_next", &self.p_next)
68987             .field(
68988                 "displacement_bias_and_scale_format",
68989                 &self.displacement_bias_and_scale_format,
68990             )
68991             .field(
68992                 "displacement_vector_format",
68993                 &self.displacement_vector_format,
68994             )
68995             .field("displacement_bias_and_scale_buffer", &"union")
68996             .field(
68997                 "displacement_bias_and_scale_stride",
68998                 &self.displacement_bias_and_scale_stride,
68999             )
69000             .field("displacement_vector_buffer", &"union")
69001             .field(
69002                 "displacement_vector_stride",
69003                 &self.displacement_vector_stride,
69004             )
69005             .field("displaced_micromap_primitive_flags", &"union")
69006             .field(
69007                 "displaced_micromap_primitive_flags_stride",
69008                 &self.displaced_micromap_primitive_flags_stride,
69009             )
69010             .field("index_type", &self.index_type)
69011             .field("index_buffer", &"union")
69012             .field("index_stride", &self.index_stride)
69013             .field("base_triangle", &self.base_triangle)
69014             .field("usage_counts_count", &self.usage_counts_count)
69015             .field("p_usage_counts", &self.p_usage_counts)
69016             .field("pp_usage_counts", &self.pp_usage_counts)
69017             .field("micromap", &self.micromap)
69018             .finish()
69019     }
69020 }
69021 impl ::std::default::Default for AccelerationStructureTrianglesDisplacementMicromapNV {
69022     #[inline]
default() -> Self69023     fn default() -> Self {
69024         Self {
69025             s_type: Self::STRUCTURE_TYPE,
69026             p_next: ::std::ptr::null_mut(),
69027             displacement_bias_and_scale_format: Format::default(),
69028             displacement_vector_format: Format::default(),
69029             displacement_bias_and_scale_buffer: DeviceOrHostAddressConstKHR::default(),
69030             displacement_bias_and_scale_stride: DeviceSize::default(),
69031             displacement_vector_buffer: DeviceOrHostAddressConstKHR::default(),
69032             displacement_vector_stride: DeviceSize::default(),
69033             displaced_micromap_primitive_flags: DeviceOrHostAddressConstKHR::default(),
69034             displaced_micromap_primitive_flags_stride: DeviceSize::default(),
69035             index_type: IndexType::default(),
69036             index_buffer: DeviceOrHostAddressConstKHR::default(),
69037             index_stride: DeviceSize::default(),
69038             base_triangle: u32::default(),
69039             usage_counts_count: u32::default(),
69040             p_usage_counts: ::std::ptr::null(),
69041             pp_usage_counts: ::std::ptr::null(),
69042             micromap: MicromapEXT::default(),
69043         }
69044     }
69045 }
69046 unsafe impl TaggedStructure for AccelerationStructureTrianglesDisplacementMicromapNV {
69047     const STRUCTURE_TYPE: StructureType =
69048         StructureType::ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV;
69049 }
69050 impl AccelerationStructureTrianglesDisplacementMicromapNV {
builder<'a>() -> AccelerationStructureTrianglesDisplacementMicromapNVBuilder<'a>69051     pub fn builder<'a>() -> AccelerationStructureTrianglesDisplacementMicromapNVBuilder<'a> {
69052         AccelerationStructureTrianglesDisplacementMicromapNVBuilder {
69053             inner: Self::default(),
69054             marker: ::std::marker::PhantomData,
69055         }
69056     }
69057 }
69058 #[repr(transparent)]
69059 pub struct AccelerationStructureTrianglesDisplacementMicromapNVBuilder<'a> {
69060     inner: AccelerationStructureTrianglesDisplacementMicromapNV,
69061     marker: ::std::marker::PhantomData<&'a ()>,
69062 }
69063 unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR
69064     for AccelerationStructureTrianglesDisplacementMicromapNVBuilder<'_>
69065 {
69066 }
69067 unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR
69068     for AccelerationStructureTrianglesDisplacementMicromapNV
69069 {
69070 }
69071 impl<'a> ::std::ops::Deref for AccelerationStructureTrianglesDisplacementMicromapNVBuilder<'a> {
69072     type Target = AccelerationStructureTrianglesDisplacementMicromapNV;
deref(&self) -> &Self::Target69073     fn deref(&self) -> &Self::Target {
69074         &self.inner
69075     }
69076 }
69077 impl<'a> ::std::ops::DerefMut for AccelerationStructureTrianglesDisplacementMicromapNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target69078     fn deref_mut(&mut self) -> &mut Self::Target {
69079         &mut self.inner
69080     }
69081 }
69082 impl<'a> AccelerationStructureTrianglesDisplacementMicromapNVBuilder<'a> {
69083     #[inline]
displacement_bias_and_scale_format( mut self, displacement_bias_and_scale_format: Format, ) -> Self69084     pub fn displacement_bias_and_scale_format(
69085         mut self,
69086         displacement_bias_and_scale_format: Format,
69087     ) -> Self {
69088         self.inner.displacement_bias_and_scale_format = displacement_bias_and_scale_format;
69089         self
69090     }
69091     #[inline]
displacement_vector_format(mut self, displacement_vector_format: Format) -> Self69092     pub fn displacement_vector_format(mut self, displacement_vector_format: Format) -> Self {
69093         self.inner.displacement_vector_format = displacement_vector_format;
69094         self
69095     }
69096     #[inline]
displacement_bias_and_scale_buffer( mut self, displacement_bias_and_scale_buffer: DeviceOrHostAddressConstKHR, ) -> Self69097     pub fn displacement_bias_and_scale_buffer(
69098         mut self,
69099         displacement_bias_and_scale_buffer: DeviceOrHostAddressConstKHR,
69100     ) -> Self {
69101         self.inner.displacement_bias_and_scale_buffer = displacement_bias_and_scale_buffer;
69102         self
69103     }
69104     #[inline]
displacement_bias_and_scale_stride( mut self, displacement_bias_and_scale_stride: DeviceSize, ) -> Self69105     pub fn displacement_bias_and_scale_stride(
69106         mut self,
69107         displacement_bias_and_scale_stride: DeviceSize,
69108     ) -> Self {
69109         self.inner.displacement_bias_and_scale_stride = displacement_bias_and_scale_stride;
69110         self
69111     }
69112     #[inline]
displacement_vector_buffer( mut self, displacement_vector_buffer: DeviceOrHostAddressConstKHR, ) -> Self69113     pub fn displacement_vector_buffer(
69114         mut self,
69115         displacement_vector_buffer: DeviceOrHostAddressConstKHR,
69116     ) -> Self {
69117         self.inner.displacement_vector_buffer = displacement_vector_buffer;
69118         self
69119     }
69120     #[inline]
displacement_vector_stride(mut self, displacement_vector_stride: DeviceSize) -> Self69121     pub fn displacement_vector_stride(mut self, displacement_vector_stride: DeviceSize) -> Self {
69122         self.inner.displacement_vector_stride = displacement_vector_stride;
69123         self
69124     }
69125     #[inline]
displaced_micromap_primitive_flags( mut self, displaced_micromap_primitive_flags: DeviceOrHostAddressConstKHR, ) -> Self69126     pub fn displaced_micromap_primitive_flags(
69127         mut self,
69128         displaced_micromap_primitive_flags: DeviceOrHostAddressConstKHR,
69129     ) -> Self {
69130         self.inner.displaced_micromap_primitive_flags = displaced_micromap_primitive_flags;
69131         self
69132     }
69133     #[inline]
displaced_micromap_primitive_flags_stride( mut self, displaced_micromap_primitive_flags_stride: DeviceSize, ) -> Self69134     pub fn displaced_micromap_primitive_flags_stride(
69135         mut self,
69136         displaced_micromap_primitive_flags_stride: DeviceSize,
69137     ) -> Self {
69138         self.inner.displaced_micromap_primitive_flags_stride =
69139             displaced_micromap_primitive_flags_stride;
69140         self
69141     }
69142     #[inline]
index_type(mut self, index_type: IndexType) -> Self69143     pub fn index_type(mut self, index_type: IndexType) -> Self {
69144         self.inner.index_type = index_type;
69145         self
69146     }
69147     #[inline]
index_buffer(mut self, index_buffer: DeviceOrHostAddressConstKHR) -> Self69148     pub fn index_buffer(mut self, index_buffer: DeviceOrHostAddressConstKHR) -> Self {
69149         self.inner.index_buffer = index_buffer;
69150         self
69151     }
69152     #[inline]
index_stride(mut self, index_stride: DeviceSize) -> Self69153     pub fn index_stride(mut self, index_stride: DeviceSize) -> Self {
69154         self.inner.index_stride = index_stride;
69155         self
69156     }
69157     #[inline]
base_triangle(mut self, base_triangle: u32) -> Self69158     pub fn base_triangle(mut self, base_triangle: u32) -> Self {
69159         self.inner.base_triangle = base_triangle;
69160         self
69161     }
69162     #[inline]
usage_counts(mut self, usage_counts: &'a [MicromapUsageEXT]) -> Self69163     pub fn usage_counts(mut self, usage_counts: &'a [MicromapUsageEXT]) -> Self {
69164         self.inner.usage_counts_count = usage_counts.len() as _;
69165         self.inner.p_usage_counts = usage_counts.as_ptr();
69166         self
69167     }
69168     #[inline]
usage_counts_ptrs(mut self, usage_counts_ptrs: &'a [&'a MicromapUsageEXT]) -> Self69169     pub fn usage_counts_ptrs(mut self, usage_counts_ptrs: &'a [&'a MicromapUsageEXT]) -> Self {
69170         self.inner.usage_counts_count = usage_counts_ptrs.len() as _;
69171         self.inner.pp_usage_counts = usage_counts_ptrs.as_ptr().cast();
69172         self
69173     }
69174     #[inline]
micromap(mut self, micromap: MicromapEXT) -> Self69175     pub fn micromap(mut self, micromap: MicromapEXT) -> Self {
69176         self.inner.micromap = micromap;
69177         self
69178     }
69179     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
69180     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
69181     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureTrianglesDisplacementMicromapNV69182     pub fn build(self) -> AccelerationStructureTrianglesDisplacementMicromapNV {
69183         self.inner
69184     }
69185 }
69186 #[repr(C)]
69187 #[cfg_attr(feature = "debug", derive(Debug))]
69188 #[derive(Copy, Clone)]
69189 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelinePropertiesIdentifierEXT.html>"]
69190 pub struct PipelinePropertiesIdentifierEXT {
69191     pub s_type: StructureType,
69192     pub p_next: *mut c_void,
69193     pub pipeline_identifier: [u8; UUID_SIZE],
69194 }
69195 impl ::std::default::Default for PipelinePropertiesIdentifierEXT {
69196     #[inline]
default() -> Self69197     fn default() -> Self {
69198         Self {
69199             s_type: Self::STRUCTURE_TYPE,
69200             p_next: ::std::ptr::null_mut(),
69201             pipeline_identifier: unsafe { ::std::mem::zeroed() },
69202         }
69203     }
69204 }
69205 unsafe impl TaggedStructure for PipelinePropertiesIdentifierEXT {
69206     const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_PROPERTIES_IDENTIFIER_EXT;
69207 }
69208 impl PipelinePropertiesIdentifierEXT {
builder<'a>() -> PipelinePropertiesIdentifierEXTBuilder<'a>69209     pub fn builder<'a>() -> PipelinePropertiesIdentifierEXTBuilder<'a> {
69210         PipelinePropertiesIdentifierEXTBuilder {
69211             inner: Self::default(),
69212             marker: ::std::marker::PhantomData,
69213         }
69214     }
69215 }
69216 #[repr(transparent)]
69217 pub struct PipelinePropertiesIdentifierEXTBuilder<'a> {
69218     inner: PipelinePropertiesIdentifierEXT,
69219     marker: ::std::marker::PhantomData<&'a ()>,
69220 }
69221 impl<'a> ::std::ops::Deref for PipelinePropertiesIdentifierEXTBuilder<'a> {
69222     type Target = PipelinePropertiesIdentifierEXT;
deref(&self) -> &Self::Target69223     fn deref(&self) -> &Self::Target {
69224         &self.inner
69225     }
69226 }
69227 impl<'a> ::std::ops::DerefMut for PipelinePropertiesIdentifierEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target69228     fn deref_mut(&mut self) -> &mut Self::Target {
69229         &mut self.inner
69230     }
69231 }
69232 impl<'a> PipelinePropertiesIdentifierEXTBuilder<'a> {
69233     #[inline]
pipeline_identifier(mut self, pipeline_identifier: [u8; UUID_SIZE]) -> Self69234     pub fn pipeline_identifier(mut self, pipeline_identifier: [u8; UUID_SIZE]) -> Self {
69235         self.inner.pipeline_identifier = pipeline_identifier;
69236         self
69237     }
69238     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
69239     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
69240     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelinePropertiesIdentifierEXT69241     pub fn build(self) -> PipelinePropertiesIdentifierEXT {
69242         self.inner
69243     }
69244 }
69245 #[repr(C)]
69246 #[cfg_attr(feature = "debug", derive(Debug))]
69247 #[derive(Copy, Clone)]
69248 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePipelinePropertiesFeaturesEXT.html>"]
69249 pub struct PhysicalDevicePipelinePropertiesFeaturesEXT {
69250     pub s_type: StructureType,
69251     pub p_next: *mut c_void,
69252     pub pipeline_properties_identifier: Bool32,
69253 }
69254 impl ::std::default::Default for PhysicalDevicePipelinePropertiesFeaturesEXT {
69255     #[inline]
default() -> Self69256     fn default() -> Self {
69257         Self {
69258             s_type: Self::STRUCTURE_TYPE,
69259             p_next: ::std::ptr::null_mut(),
69260             pipeline_properties_identifier: Bool32::default(),
69261         }
69262     }
69263 }
69264 unsafe impl TaggedStructure for PhysicalDevicePipelinePropertiesFeaturesEXT {
69265     const STRUCTURE_TYPE: StructureType =
69266         StructureType::PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
69267 }
69268 impl PhysicalDevicePipelinePropertiesFeaturesEXT {
builder<'a>() -> PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a>69269     pub fn builder<'a>() -> PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> {
69270         PhysicalDevicePipelinePropertiesFeaturesEXTBuilder {
69271             inner: Self::default(),
69272             marker: ::std::marker::PhantomData,
69273         }
69274     }
69275 }
69276 #[repr(transparent)]
69277 pub struct PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> {
69278     inner: PhysicalDevicePipelinePropertiesFeaturesEXT,
69279     marker: ::std::marker::PhantomData<&'a ()>,
69280 }
69281 unsafe impl ExtendsPhysicalDeviceFeatures2
69282     for PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'_>
69283 {
69284 }
69285 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelinePropertiesFeaturesEXT {}
69286 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'_> {}
69287 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelinePropertiesFeaturesEXT {}
69288 impl<'a> ::std::ops::Deref for PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> {
69289     type Target = PhysicalDevicePipelinePropertiesFeaturesEXT;
deref(&self) -> &Self::Target69290     fn deref(&self) -> &Self::Target {
69291         &self.inner
69292     }
69293 }
69294 impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target69295     fn deref_mut(&mut self) -> &mut Self::Target {
69296         &mut self.inner
69297     }
69298 }
69299 impl<'a> PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> {
69300     #[inline]
pipeline_properties_identifier(mut self, pipeline_properties_identifier: bool) -> Self69301     pub fn pipeline_properties_identifier(mut self, pipeline_properties_identifier: bool) -> Self {
69302         self.inner.pipeline_properties_identifier = pipeline_properties_identifier.into();
69303         self
69304     }
69305     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
69306     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
69307     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePipelinePropertiesFeaturesEXT69308     pub fn build(self) -> PhysicalDevicePipelinePropertiesFeaturesEXT {
69309         self.inner
69310     }
69311 }
69312 #[repr(C)]
69313 #[cfg_attr(feature = "debug", derive(Debug))]
69314 #[derive(Copy, Clone)]
69315 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.html>"]
69316 pub struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {
69317     pub s_type: StructureType,
69318     pub p_next: *mut c_void,
69319     pub shader_early_and_late_fragment_tests: Bool32,
69320 }
69321 impl ::std::default::Default for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {
69322     #[inline]
default() -> Self69323     fn default() -> Self {
69324         Self {
69325             s_type: Self::STRUCTURE_TYPE,
69326             p_next: ::std::ptr::null_mut(),
69327             shader_early_and_late_fragment_tests: Bool32::default(),
69328         }
69329     }
69330 }
69331 unsafe impl TaggedStructure for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {
69332     const STRUCTURE_TYPE: StructureType =
69333         StructureType::PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
69334 }
69335 impl PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {
builder<'a>() -> PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a>69336     pub fn builder<'a>() -> PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a> {
69337         PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder {
69338             inner: Self::default(),
69339             marker: ::std::marker::PhantomData,
69340         }
69341     }
69342 }
69343 #[repr(transparent)]
69344 pub struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a> {
69345     inner: PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD,
69346     marker: ::std::marker::PhantomData<&'a ()>,
69347 }
69348 unsafe impl ExtendsPhysicalDeviceFeatures2
69349     for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'_>
69350 {
69351 }
69352 unsafe impl ExtendsPhysicalDeviceFeatures2
69353     for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD
69354 {
69355 }
69356 unsafe impl ExtendsDeviceCreateInfo
69357     for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'_>
69358 {
69359 }
69360 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {}
69361 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a> {
69362     type Target = PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD;
deref(&self) -> &Self::Target69363     fn deref(&self) -> &Self::Target {
69364         &self.inner
69365     }
69366 }
69367 impl<'a> ::std::ops::DerefMut
69368     for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a>
69369 {
deref_mut(&mut self) -> &mut Self::Target69370     fn deref_mut(&mut self) -> &mut Self::Target {
69371         &mut self.inner
69372     }
69373 }
69374 impl<'a> PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a> {
69375     #[inline]
shader_early_and_late_fragment_tests( mut self, shader_early_and_late_fragment_tests: bool, ) -> Self69376     pub fn shader_early_and_late_fragment_tests(
69377         mut self,
69378         shader_early_and_late_fragment_tests: bool,
69379     ) -> Self {
69380         self.inner.shader_early_and_late_fragment_tests =
69381             shader_early_and_late_fragment_tests.into();
69382         self
69383     }
69384     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
69385     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
69386     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD69387     pub fn build(self) -> PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {
69388         self.inner
69389     }
69390 }
69391 #[repr(C)]
69392 #[cfg_attr(feature = "debug", derive(Debug))]
69393 #[derive(Copy, Clone)]
69394 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMetalObjectCreateInfoEXT.html>"]
69395 pub struct ExportMetalObjectCreateInfoEXT {
69396     pub s_type: StructureType,
69397     pub p_next: *const c_void,
69398     pub export_object_type: ExportMetalObjectTypeFlagsEXT,
69399 }
69400 impl ::std::default::Default for ExportMetalObjectCreateInfoEXT {
69401     #[inline]
default() -> Self69402     fn default() -> Self {
69403         Self {
69404             s_type: Self::STRUCTURE_TYPE,
69405             p_next: ::std::ptr::null(),
69406             export_object_type: ExportMetalObjectTypeFlagsEXT::default(),
69407         }
69408     }
69409 }
69410 unsafe impl TaggedStructure for ExportMetalObjectCreateInfoEXT {
69411     const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_OBJECT_CREATE_INFO_EXT;
69412 }
69413 impl ExportMetalObjectCreateInfoEXT {
builder<'a>() -> ExportMetalObjectCreateInfoEXTBuilder<'a>69414     pub fn builder<'a>() -> ExportMetalObjectCreateInfoEXTBuilder<'a> {
69415         ExportMetalObjectCreateInfoEXTBuilder {
69416             inner: Self::default(),
69417             marker: ::std::marker::PhantomData,
69418         }
69419     }
69420 }
69421 #[repr(transparent)]
69422 pub struct ExportMetalObjectCreateInfoEXTBuilder<'a> {
69423     inner: ExportMetalObjectCreateInfoEXT,
69424     marker: ::std::marker::PhantomData<&'a ()>,
69425 }
69426 unsafe impl ExtendsInstanceCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {}
69427 unsafe impl ExtendsInstanceCreateInfo for ExportMetalObjectCreateInfoEXT {}
69428 unsafe impl ExtendsMemoryAllocateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {}
69429 unsafe impl ExtendsMemoryAllocateInfo for ExportMetalObjectCreateInfoEXT {}
69430 unsafe impl ExtendsImageCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {}
69431 unsafe impl ExtendsImageCreateInfo for ExportMetalObjectCreateInfoEXT {}
69432 unsafe impl ExtendsImageViewCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {}
69433 unsafe impl ExtendsImageViewCreateInfo for ExportMetalObjectCreateInfoEXT {}
69434 unsafe impl ExtendsBufferViewCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {}
69435 unsafe impl ExtendsBufferViewCreateInfo for ExportMetalObjectCreateInfoEXT {}
69436 unsafe impl ExtendsSemaphoreCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {}
69437 unsafe impl ExtendsSemaphoreCreateInfo for ExportMetalObjectCreateInfoEXT {}
69438 unsafe impl ExtendsEventCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {}
69439 unsafe impl ExtendsEventCreateInfo for ExportMetalObjectCreateInfoEXT {}
69440 impl<'a> ::std::ops::Deref for ExportMetalObjectCreateInfoEXTBuilder<'a> {
69441     type Target = ExportMetalObjectCreateInfoEXT;
deref(&self) -> &Self::Target69442     fn deref(&self) -> &Self::Target {
69443         &self.inner
69444     }
69445 }
69446 impl<'a> ::std::ops::DerefMut for ExportMetalObjectCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target69447     fn deref_mut(&mut self) -> &mut Self::Target {
69448         &mut self.inner
69449     }
69450 }
69451 impl<'a> ExportMetalObjectCreateInfoEXTBuilder<'a> {
69452     #[inline]
export_object_type(mut self, export_object_type: ExportMetalObjectTypeFlagsEXT) -> Self69453     pub fn export_object_type(mut self, export_object_type: ExportMetalObjectTypeFlagsEXT) -> Self {
69454         self.inner.export_object_type = export_object_type;
69455         self
69456     }
69457     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
69458     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
69459     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExportMetalObjectCreateInfoEXT69460     pub fn build(self) -> ExportMetalObjectCreateInfoEXT {
69461         self.inner
69462     }
69463 }
69464 #[repr(C)]
69465 #[cfg_attr(feature = "debug", derive(Debug))]
69466 #[derive(Copy, Clone)]
69467 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMetalObjectsInfoEXT.html>"]
69468 pub struct ExportMetalObjectsInfoEXT {
69469     pub s_type: StructureType,
69470     pub p_next: *const c_void,
69471 }
69472 impl ::std::default::Default for ExportMetalObjectsInfoEXT {
69473     #[inline]
default() -> Self69474     fn default() -> Self {
69475         Self {
69476             s_type: Self::STRUCTURE_TYPE,
69477             p_next: ::std::ptr::null(),
69478         }
69479     }
69480 }
69481 unsafe impl TaggedStructure for ExportMetalObjectsInfoEXT {
69482     const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_OBJECTS_INFO_EXT;
69483 }
69484 impl ExportMetalObjectsInfoEXT {
builder<'a>() -> ExportMetalObjectsInfoEXTBuilder<'a>69485     pub fn builder<'a>() -> ExportMetalObjectsInfoEXTBuilder<'a> {
69486         ExportMetalObjectsInfoEXTBuilder {
69487             inner: Self::default(),
69488             marker: ::std::marker::PhantomData,
69489         }
69490     }
69491 }
69492 #[repr(transparent)]
69493 pub struct ExportMetalObjectsInfoEXTBuilder<'a> {
69494     inner: ExportMetalObjectsInfoEXT,
69495     marker: ::std::marker::PhantomData<&'a ()>,
69496 }
69497 pub unsafe trait ExtendsExportMetalObjectsInfoEXT {}
69498 impl<'a> ::std::ops::Deref for ExportMetalObjectsInfoEXTBuilder<'a> {
69499     type Target = ExportMetalObjectsInfoEXT;
deref(&self) -> &Self::Target69500     fn deref(&self) -> &Self::Target {
69501         &self.inner
69502     }
69503 }
69504 impl<'a> ::std::ops::DerefMut for ExportMetalObjectsInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target69505     fn deref_mut(&mut self) -> &mut Self::Target {
69506         &mut self.inner
69507     }
69508 }
69509 impl<'a> ExportMetalObjectsInfoEXTBuilder<'a> {
69510     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
69511     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
69512     #[doc = r" valid extension structs can be pushed into the chain."]
69513     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
69514     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsExportMetalObjectsInfoEXT>(mut self, next: &'a mut T) -> Self69515     pub fn push_next<T: ExtendsExportMetalObjectsInfoEXT>(mut self, next: &'a mut T) -> Self {
69516         unsafe {
69517             let next_ptr = <*const T>::cast(next);
69518             let last_next = ptr_chain_iter(next).last().unwrap();
69519             (*last_next).p_next = self.inner.p_next as _;
69520             self.inner.p_next = next_ptr;
69521         }
69522         self
69523     }
69524     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
69525     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
69526     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExportMetalObjectsInfoEXT69527     pub fn build(self) -> ExportMetalObjectsInfoEXT {
69528         self.inner
69529     }
69530 }
69531 #[repr(C)]
69532 #[cfg_attr(feature = "debug", derive(Debug))]
69533 #[derive(Copy, Clone)]
69534 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMetalDeviceInfoEXT.html>"]
69535 pub struct ExportMetalDeviceInfoEXT {
69536     pub s_type: StructureType,
69537     pub p_next: *const c_void,
69538     pub mtl_device: MTLDevice_id,
69539 }
69540 impl ::std::default::Default for ExportMetalDeviceInfoEXT {
69541     #[inline]
default() -> Self69542     fn default() -> Self {
69543         Self {
69544             s_type: Self::STRUCTURE_TYPE,
69545             p_next: ::std::ptr::null(),
69546             mtl_device: unsafe { ::std::mem::zeroed() },
69547         }
69548     }
69549 }
69550 unsafe impl TaggedStructure for ExportMetalDeviceInfoEXT {
69551     const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_DEVICE_INFO_EXT;
69552 }
69553 impl ExportMetalDeviceInfoEXT {
builder<'a>() -> ExportMetalDeviceInfoEXTBuilder<'a>69554     pub fn builder<'a>() -> ExportMetalDeviceInfoEXTBuilder<'a> {
69555         ExportMetalDeviceInfoEXTBuilder {
69556             inner: Self::default(),
69557             marker: ::std::marker::PhantomData,
69558         }
69559     }
69560 }
69561 #[repr(transparent)]
69562 pub struct ExportMetalDeviceInfoEXTBuilder<'a> {
69563     inner: ExportMetalDeviceInfoEXT,
69564     marker: ::std::marker::PhantomData<&'a ()>,
69565 }
69566 unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalDeviceInfoEXTBuilder<'_> {}
69567 unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalDeviceInfoEXT {}
69568 impl<'a> ::std::ops::Deref for ExportMetalDeviceInfoEXTBuilder<'a> {
69569     type Target = ExportMetalDeviceInfoEXT;
deref(&self) -> &Self::Target69570     fn deref(&self) -> &Self::Target {
69571         &self.inner
69572     }
69573 }
69574 impl<'a> ::std::ops::DerefMut for ExportMetalDeviceInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target69575     fn deref_mut(&mut self) -> &mut Self::Target {
69576         &mut self.inner
69577     }
69578 }
69579 impl<'a> ExportMetalDeviceInfoEXTBuilder<'a> {
69580     #[inline]
mtl_device(mut self, mtl_device: MTLDevice_id) -> Self69581     pub fn mtl_device(mut self, mtl_device: MTLDevice_id) -> Self {
69582         self.inner.mtl_device = mtl_device;
69583         self
69584     }
69585     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
69586     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
69587     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExportMetalDeviceInfoEXT69588     pub fn build(self) -> ExportMetalDeviceInfoEXT {
69589         self.inner
69590     }
69591 }
69592 #[repr(C)]
69593 #[cfg_attr(feature = "debug", derive(Debug))]
69594 #[derive(Copy, Clone)]
69595 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMetalCommandQueueInfoEXT.html>"]
69596 pub struct ExportMetalCommandQueueInfoEXT {
69597     pub s_type: StructureType,
69598     pub p_next: *const c_void,
69599     pub queue: Queue,
69600     pub mtl_command_queue: MTLCommandQueue_id,
69601 }
69602 impl ::std::default::Default for ExportMetalCommandQueueInfoEXT {
69603     #[inline]
default() -> Self69604     fn default() -> Self {
69605         Self {
69606             s_type: Self::STRUCTURE_TYPE,
69607             p_next: ::std::ptr::null(),
69608             queue: Queue::default(),
69609             mtl_command_queue: unsafe { ::std::mem::zeroed() },
69610         }
69611     }
69612 }
69613 unsafe impl TaggedStructure for ExportMetalCommandQueueInfoEXT {
69614     const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_COMMAND_QUEUE_INFO_EXT;
69615 }
69616 impl ExportMetalCommandQueueInfoEXT {
builder<'a>() -> ExportMetalCommandQueueInfoEXTBuilder<'a>69617     pub fn builder<'a>() -> ExportMetalCommandQueueInfoEXTBuilder<'a> {
69618         ExportMetalCommandQueueInfoEXTBuilder {
69619             inner: Self::default(),
69620             marker: ::std::marker::PhantomData,
69621         }
69622     }
69623 }
69624 #[repr(transparent)]
69625 pub struct ExportMetalCommandQueueInfoEXTBuilder<'a> {
69626     inner: ExportMetalCommandQueueInfoEXT,
69627     marker: ::std::marker::PhantomData<&'a ()>,
69628 }
69629 unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalCommandQueueInfoEXTBuilder<'_> {}
69630 unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalCommandQueueInfoEXT {}
69631 impl<'a> ::std::ops::Deref for ExportMetalCommandQueueInfoEXTBuilder<'a> {
69632     type Target = ExportMetalCommandQueueInfoEXT;
deref(&self) -> &Self::Target69633     fn deref(&self) -> &Self::Target {
69634         &self.inner
69635     }
69636 }
69637 impl<'a> ::std::ops::DerefMut for ExportMetalCommandQueueInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target69638     fn deref_mut(&mut self) -> &mut Self::Target {
69639         &mut self.inner
69640     }
69641 }
69642 impl<'a> ExportMetalCommandQueueInfoEXTBuilder<'a> {
69643     #[inline]
queue(mut self, queue: Queue) -> Self69644     pub fn queue(mut self, queue: Queue) -> Self {
69645         self.inner.queue = queue;
69646         self
69647     }
69648     #[inline]
mtl_command_queue(mut self, mtl_command_queue: MTLCommandQueue_id) -> Self69649     pub fn mtl_command_queue(mut self, mtl_command_queue: MTLCommandQueue_id) -> Self {
69650         self.inner.mtl_command_queue = mtl_command_queue;
69651         self
69652     }
69653     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
69654     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
69655     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExportMetalCommandQueueInfoEXT69656     pub fn build(self) -> ExportMetalCommandQueueInfoEXT {
69657         self.inner
69658     }
69659 }
69660 #[repr(C)]
69661 #[cfg_attr(feature = "debug", derive(Debug))]
69662 #[derive(Copy, Clone)]
69663 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMetalBufferInfoEXT.html>"]
69664 pub struct ExportMetalBufferInfoEXT {
69665     pub s_type: StructureType,
69666     pub p_next: *const c_void,
69667     pub memory: DeviceMemory,
69668     pub mtl_buffer: MTLBuffer_id,
69669 }
69670 impl ::std::default::Default for ExportMetalBufferInfoEXT {
69671     #[inline]
default() -> Self69672     fn default() -> Self {
69673         Self {
69674             s_type: Self::STRUCTURE_TYPE,
69675             p_next: ::std::ptr::null(),
69676             memory: DeviceMemory::default(),
69677             mtl_buffer: unsafe { ::std::mem::zeroed() },
69678         }
69679     }
69680 }
69681 unsafe impl TaggedStructure for ExportMetalBufferInfoEXT {
69682     const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_BUFFER_INFO_EXT;
69683 }
69684 impl ExportMetalBufferInfoEXT {
builder<'a>() -> ExportMetalBufferInfoEXTBuilder<'a>69685     pub fn builder<'a>() -> ExportMetalBufferInfoEXTBuilder<'a> {
69686         ExportMetalBufferInfoEXTBuilder {
69687             inner: Self::default(),
69688             marker: ::std::marker::PhantomData,
69689         }
69690     }
69691 }
69692 #[repr(transparent)]
69693 pub struct ExportMetalBufferInfoEXTBuilder<'a> {
69694     inner: ExportMetalBufferInfoEXT,
69695     marker: ::std::marker::PhantomData<&'a ()>,
69696 }
69697 unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalBufferInfoEXTBuilder<'_> {}
69698 unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalBufferInfoEXT {}
69699 impl<'a> ::std::ops::Deref for ExportMetalBufferInfoEXTBuilder<'a> {
69700     type Target = ExportMetalBufferInfoEXT;
deref(&self) -> &Self::Target69701     fn deref(&self) -> &Self::Target {
69702         &self.inner
69703     }
69704 }
69705 impl<'a> ::std::ops::DerefMut for ExportMetalBufferInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target69706     fn deref_mut(&mut self) -> &mut Self::Target {
69707         &mut self.inner
69708     }
69709 }
69710 impl<'a> ExportMetalBufferInfoEXTBuilder<'a> {
69711     #[inline]
memory(mut self, memory: DeviceMemory) -> Self69712     pub fn memory(mut self, memory: DeviceMemory) -> Self {
69713         self.inner.memory = memory;
69714         self
69715     }
69716     #[inline]
mtl_buffer(mut self, mtl_buffer: MTLBuffer_id) -> Self69717     pub fn mtl_buffer(mut self, mtl_buffer: MTLBuffer_id) -> Self {
69718         self.inner.mtl_buffer = mtl_buffer;
69719         self
69720     }
69721     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
69722     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
69723     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExportMetalBufferInfoEXT69724     pub fn build(self) -> ExportMetalBufferInfoEXT {
69725         self.inner
69726     }
69727 }
69728 #[repr(C)]
69729 #[cfg_attr(feature = "debug", derive(Debug))]
69730 #[derive(Copy, Clone)]
69731 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMetalBufferInfoEXT.html>"]
69732 pub struct ImportMetalBufferInfoEXT {
69733     pub s_type: StructureType,
69734     pub p_next: *const c_void,
69735     pub mtl_buffer: MTLBuffer_id,
69736 }
69737 impl ::std::default::Default for ImportMetalBufferInfoEXT {
69738     #[inline]
default() -> Self69739     fn default() -> Self {
69740         Self {
69741             s_type: Self::STRUCTURE_TYPE,
69742             p_next: ::std::ptr::null(),
69743             mtl_buffer: unsafe { ::std::mem::zeroed() },
69744         }
69745     }
69746 }
69747 unsafe impl TaggedStructure for ImportMetalBufferInfoEXT {
69748     const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_METAL_BUFFER_INFO_EXT;
69749 }
69750 impl ImportMetalBufferInfoEXT {
builder<'a>() -> ImportMetalBufferInfoEXTBuilder<'a>69751     pub fn builder<'a>() -> ImportMetalBufferInfoEXTBuilder<'a> {
69752         ImportMetalBufferInfoEXTBuilder {
69753             inner: Self::default(),
69754             marker: ::std::marker::PhantomData,
69755         }
69756     }
69757 }
69758 #[repr(transparent)]
69759 pub struct ImportMetalBufferInfoEXTBuilder<'a> {
69760     inner: ImportMetalBufferInfoEXT,
69761     marker: ::std::marker::PhantomData<&'a ()>,
69762 }
69763 unsafe impl ExtendsMemoryAllocateInfo for ImportMetalBufferInfoEXTBuilder<'_> {}
69764 unsafe impl ExtendsMemoryAllocateInfo for ImportMetalBufferInfoEXT {}
69765 impl<'a> ::std::ops::Deref for ImportMetalBufferInfoEXTBuilder<'a> {
69766     type Target = ImportMetalBufferInfoEXT;
deref(&self) -> &Self::Target69767     fn deref(&self) -> &Self::Target {
69768         &self.inner
69769     }
69770 }
69771 impl<'a> ::std::ops::DerefMut for ImportMetalBufferInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target69772     fn deref_mut(&mut self) -> &mut Self::Target {
69773         &mut self.inner
69774     }
69775 }
69776 impl<'a> ImportMetalBufferInfoEXTBuilder<'a> {
69777     #[inline]
mtl_buffer(mut self, mtl_buffer: MTLBuffer_id) -> Self69778     pub fn mtl_buffer(mut self, mtl_buffer: MTLBuffer_id) -> Self {
69779         self.inner.mtl_buffer = mtl_buffer;
69780         self
69781     }
69782     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
69783     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
69784     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImportMetalBufferInfoEXT69785     pub fn build(self) -> ImportMetalBufferInfoEXT {
69786         self.inner
69787     }
69788 }
69789 #[repr(C)]
69790 #[cfg_attr(feature = "debug", derive(Debug))]
69791 #[derive(Copy, Clone)]
69792 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMetalTextureInfoEXT.html>"]
69793 pub struct ExportMetalTextureInfoEXT {
69794     pub s_type: StructureType,
69795     pub p_next: *const c_void,
69796     pub image: Image,
69797     pub image_view: ImageView,
69798     pub buffer_view: BufferView,
69799     pub plane: ImageAspectFlags,
69800     pub mtl_texture: MTLTexture_id,
69801 }
69802 impl ::std::default::Default for ExportMetalTextureInfoEXT {
69803     #[inline]
default() -> Self69804     fn default() -> Self {
69805         Self {
69806             s_type: Self::STRUCTURE_TYPE,
69807             p_next: ::std::ptr::null(),
69808             image: Image::default(),
69809             image_view: ImageView::default(),
69810             buffer_view: BufferView::default(),
69811             plane: ImageAspectFlags::default(),
69812             mtl_texture: unsafe { ::std::mem::zeroed() },
69813         }
69814     }
69815 }
69816 unsafe impl TaggedStructure for ExportMetalTextureInfoEXT {
69817     const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_TEXTURE_INFO_EXT;
69818 }
69819 impl ExportMetalTextureInfoEXT {
builder<'a>() -> ExportMetalTextureInfoEXTBuilder<'a>69820     pub fn builder<'a>() -> ExportMetalTextureInfoEXTBuilder<'a> {
69821         ExportMetalTextureInfoEXTBuilder {
69822             inner: Self::default(),
69823             marker: ::std::marker::PhantomData,
69824         }
69825     }
69826 }
69827 #[repr(transparent)]
69828 pub struct ExportMetalTextureInfoEXTBuilder<'a> {
69829     inner: ExportMetalTextureInfoEXT,
69830     marker: ::std::marker::PhantomData<&'a ()>,
69831 }
69832 unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalTextureInfoEXTBuilder<'_> {}
69833 unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalTextureInfoEXT {}
69834 impl<'a> ::std::ops::Deref for ExportMetalTextureInfoEXTBuilder<'a> {
69835     type Target = ExportMetalTextureInfoEXT;
deref(&self) -> &Self::Target69836     fn deref(&self) -> &Self::Target {
69837         &self.inner
69838     }
69839 }
69840 impl<'a> ::std::ops::DerefMut for ExportMetalTextureInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target69841     fn deref_mut(&mut self) -> &mut Self::Target {
69842         &mut self.inner
69843     }
69844 }
69845 impl<'a> ExportMetalTextureInfoEXTBuilder<'a> {
69846     #[inline]
image(mut self, image: Image) -> Self69847     pub fn image(mut self, image: Image) -> Self {
69848         self.inner.image = image;
69849         self
69850     }
69851     #[inline]
image_view(mut self, image_view: ImageView) -> Self69852     pub fn image_view(mut self, image_view: ImageView) -> Self {
69853         self.inner.image_view = image_view;
69854         self
69855     }
69856     #[inline]
buffer_view(mut self, buffer_view: BufferView) -> Self69857     pub fn buffer_view(mut self, buffer_view: BufferView) -> Self {
69858         self.inner.buffer_view = buffer_view;
69859         self
69860     }
69861     #[inline]
plane(mut self, plane: ImageAspectFlags) -> Self69862     pub fn plane(mut self, plane: ImageAspectFlags) -> Self {
69863         self.inner.plane = plane;
69864         self
69865     }
69866     #[inline]
mtl_texture(mut self, mtl_texture: MTLTexture_id) -> Self69867     pub fn mtl_texture(mut self, mtl_texture: MTLTexture_id) -> Self {
69868         self.inner.mtl_texture = mtl_texture;
69869         self
69870     }
69871     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
69872     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
69873     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExportMetalTextureInfoEXT69874     pub fn build(self) -> ExportMetalTextureInfoEXT {
69875         self.inner
69876     }
69877 }
69878 #[repr(C)]
69879 #[cfg_attr(feature = "debug", derive(Debug))]
69880 #[derive(Copy, Clone)]
69881 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMetalTextureInfoEXT.html>"]
69882 pub struct ImportMetalTextureInfoEXT {
69883     pub s_type: StructureType,
69884     pub p_next: *const c_void,
69885     pub plane: ImageAspectFlags,
69886     pub mtl_texture: MTLTexture_id,
69887 }
69888 impl ::std::default::Default for ImportMetalTextureInfoEXT {
69889     #[inline]
default() -> Self69890     fn default() -> Self {
69891         Self {
69892             s_type: Self::STRUCTURE_TYPE,
69893             p_next: ::std::ptr::null(),
69894             plane: ImageAspectFlags::default(),
69895             mtl_texture: unsafe { ::std::mem::zeroed() },
69896         }
69897     }
69898 }
69899 unsafe impl TaggedStructure for ImportMetalTextureInfoEXT {
69900     const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_METAL_TEXTURE_INFO_EXT;
69901 }
69902 impl ImportMetalTextureInfoEXT {
builder<'a>() -> ImportMetalTextureInfoEXTBuilder<'a>69903     pub fn builder<'a>() -> ImportMetalTextureInfoEXTBuilder<'a> {
69904         ImportMetalTextureInfoEXTBuilder {
69905             inner: Self::default(),
69906             marker: ::std::marker::PhantomData,
69907         }
69908     }
69909 }
69910 #[repr(transparent)]
69911 pub struct ImportMetalTextureInfoEXTBuilder<'a> {
69912     inner: ImportMetalTextureInfoEXT,
69913     marker: ::std::marker::PhantomData<&'a ()>,
69914 }
69915 unsafe impl ExtendsImageCreateInfo for ImportMetalTextureInfoEXTBuilder<'_> {}
69916 unsafe impl ExtendsImageCreateInfo for ImportMetalTextureInfoEXT {}
69917 impl<'a> ::std::ops::Deref for ImportMetalTextureInfoEXTBuilder<'a> {
69918     type Target = ImportMetalTextureInfoEXT;
deref(&self) -> &Self::Target69919     fn deref(&self) -> &Self::Target {
69920         &self.inner
69921     }
69922 }
69923 impl<'a> ::std::ops::DerefMut for ImportMetalTextureInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target69924     fn deref_mut(&mut self) -> &mut Self::Target {
69925         &mut self.inner
69926     }
69927 }
69928 impl<'a> ImportMetalTextureInfoEXTBuilder<'a> {
69929     #[inline]
plane(mut self, plane: ImageAspectFlags) -> Self69930     pub fn plane(mut self, plane: ImageAspectFlags) -> Self {
69931         self.inner.plane = plane;
69932         self
69933     }
69934     #[inline]
mtl_texture(mut self, mtl_texture: MTLTexture_id) -> Self69935     pub fn mtl_texture(mut self, mtl_texture: MTLTexture_id) -> Self {
69936         self.inner.mtl_texture = mtl_texture;
69937         self
69938     }
69939     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
69940     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
69941     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImportMetalTextureInfoEXT69942     pub fn build(self) -> ImportMetalTextureInfoEXT {
69943         self.inner
69944     }
69945 }
69946 #[repr(C)]
69947 #[cfg_attr(feature = "debug", derive(Debug))]
69948 #[derive(Copy, Clone)]
69949 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMetalIOSurfaceInfoEXT.html>"]
69950 pub struct ExportMetalIOSurfaceInfoEXT {
69951     pub s_type: StructureType,
69952     pub p_next: *const c_void,
69953     pub image: Image,
69954     pub io_surface: IOSurfaceRef,
69955 }
69956 impl ::std::default::Default for ExportMetalIOSurfaceInfoEXT {
69957     #[inline]
default() -> Self69958     fn default() -> Self {
69959         Self {
69960             s_type: Self::STRUCTURE_TYPE,
69961             p_next: ::std::ptr::null(),
69962             image: Image::default(),
69963             io_surface: unsafe { ::std::mem::zeroed() },
69964         }
69965     }
69966 }
69967 unsafe impl TaggedStructure for ExportMetalIOSurfaceInfoEXT {
69968     const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_IO_SURFACE_INFO_EXT;
69969 }
69970 impl ExportMetalIOSurfaceInfoEXT {
builder<'a>() -> ExportMetalIOSurfaceInfoEXTBuilder<'a>69971     pub fn builder<'a>() -> ExportMetalIOSurfaceInfoEXTBuilder<'a> {
69972         ExportMetalIOSurfaceInfoEXTBuilder {
69973             inner: Self::default(),
69974             marker: ::std::marker::PhantomData,
69975         }
69976     }
69977 }
69978 #[repr(transparent)]
69979 pub struct ExportMetalIOSurfaceInfoEXTBuilder<'a> {
69980     inner: ExportMetalIOSurfaceInfoEXT,
69981     marker: ::std::marker::PhantomData<&'a ()>,
69982 }
69983 unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalIOSurfaceInfoEXTBuilder<'_> {}
69984 unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalIOSurfaceInfoEXT {}
69985 impl<'a> ::std::ops::Deref for ExportMetalIOSurfaceInfoEXTBuilder<'a> {
69986     type Target = ExportMetalIOSurfaceInfoEXT;
deref(&self) -> &Self::Target69987     fn deref(&self) -> &Self::Target {
69988         &self.inner
69989     }
69990 }
69991 impl<'a> ::std::ops::DerefMut for ExportMetalIOSurfaceInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target69992     fn deref_mut(&mut self) -> &mut Self::Target {
69993         &mut self.inner
69994     }
69995 }
69996 impl<'a> ExportMetalIOSurfaceInfoEXTBuilder<'a> {
69997     #[inline]
image(mut self, image: Image) -> Self69998     pub fn image(mut self, image: Image) -> Self {
69999         self.inner.image = image;
70000         self
70001     }
70002     #[inline]
io_surface(mut self, io_surface: IOSurfaceRef) -> Self70003     pub fn io_surface(mut self, io_surface: IOSurfaceRef) -> Self {
70004         self.inner.io_surface = io_surface;
70005         self
70006     }
70007     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
70008     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
70009     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExportMetalIOSurfaceInfoEXT70010     pub fn build(self) -> ExportMetalIOSurfaceInfoEXT {
70011         self.inner
70012     }
70013 }
70014 #[repr(C)]
70015 #[cfg_attr(feature = "debug", derive(Debug))]
70016 #[derive(Copy, Clone)]
70017 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMetalIOSurfaceInfoEXT.html>"]
70018 pub struct ImportMetalIOSurfaceInfoEXT {
70019     pub s_type: StructureType,
70020     pub p_next: *const c_void,
70021     pub io_surface: IOSurfaceRef,
70022 }
70023 impl ::std::default::Default for ImportMetalIOSurfaceInfoEXT {
70024     #[inline]
default() -> Self70025     fn default() -> Self {
70026         Self {
70027             s_type: Self::STRUCTURE_TYPE,
70028             p_next: ::std::ptr::null(),
70029             io_surface: unsafe { ::std::mem::zeroed() },
70030         }
70031     }
70032 }
70033 unsafe impl TaggedStructure for ImportMetalIOSurfaceInfoEXT {
70034     const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_METAL_IO_SURFACE_INFO_EXT;
70035 }
70036 impl ImportMetalIOSurfaceInfoEXT {
builder<'a>() -> ImportMetalIOSurfaceInfoEXTBuilder<'a>70037     pub fn builder<'a>() -> ImportMetalIOSurfaceInfoEXTBuilder<'a> {
70038         ImportMetalIOSurfaceInfoEXTBuilder {
70039             inner: Self::default(),
70040             marker: ::std::marker::PhantomData,
70041         }
70042     }
70043 }
70044 #[repr(transparent)]
70045 pub struct ImportMetalIOSurfaceInfoEXTBuilder<'a> {
70046     inner: ImportMetalIOSurfaceInfoEXT,
70047     marker: ::std::marker::PhantomData<&'a ()>,
70048 }
70049 unsafe impl ExtendsImageCreateInfo for ImportMetalIOSurfaceInfoEXTBuilder<'_> {}
70050 unsafe impl ExtendsImageCreateInfo for ImportMetalIOSurfaceInfoEXT {}
70051 impl<'a> ::std::ops::Deref for ImportMetalIOSurfaceInfoEXTBuilder<'a> {
70052     type Target = ImportMetalIOSurfaceInfoEXT;
deref(&self) -> &Self::Target70053     fn deref(&self) -> &Self::Target {
70054         &self.inner
70055     }
70056 }
70057 impl<'a> ::std::ops::DerefMut for ImportMetalIOSurfaceInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target70058     fn deref_mut(&mut self) -> &mut Self::Target {
70059         &mut self.inner
70060     }
70061 }
70062 impl<'a> ImportMetalIOSurfaceInfoEXTBuilder<'a> {
70063     #[inline]
io_surface(mut self, io_surface: IOSurfaceRef) -> Self70064     pub fn io_surface(mut self, io_surface: IOSurfaceRef) -> Self {
70065         self.inner.io_surface = io_surface;
70066         self
70067     }
70068     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
70069     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
70070     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImportMetalIOSurfaceInfoEXT70071     pub fn build(self) -> ImportMetalIOSurfaceInfoEXT {
70072         self.inner
70073     }
70074 }
70075 #[repr(C)]
70076 #[cfg_attr(feature = "debug", derive(Debug))]
70077 #[derive(Copy, Clone)]
70078 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMetalSharedEventInfoEXT.html>"]
70079 pub struct ExportMetalSharedEventInfoEXT {
70080     pub s_type: StructureType,
70081     pub p_next: *const c_void,
70082     pub semaphore: Semaphore,
70083     pub event: Event,
70084     pub mtl_shared_event: MTLSharedEvent_id,
70085 }
70086 impl ::std::default::Default for ExportMetalSharedEventInfoEXT {
70087     #[inline]
default() -> Self70088     fn default() -> Self {
70089         Self {
70090             s_type: Self::STRUCTURE_TYPE,
70091             p_next: ::std::ptr::null(),
70092             semaphore: Semaphore::default(),
70093             event: Event::default(),
70094             mtl_shared_event: unsafe { ::std::mem::zeroed() },
70095         }
70096     }
70097 }
70098 unsafe impl TaggedStructure for ExportMetalSharedEventInfoEXT {
70099     const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_SHARED_EVENT_INFO_EXT;
70100 }
70101 impl ExportMetalSharedEventInfoEXT {
builder<'a>() -> ExportMetalSharedEventInfoEXTBuilder<'a>70102     pub fn builder<'a>() -> ExportMetalSharedEventInfoEXTBuilder<'a> {
70103         ExportMetalSharedEventInfoEXTBuilder {
70104             inner: Self::default(),
70105             marker: ::std::marker::PhantomData,
70106         }
70107     }
70108 }
70109 #[repr(transparent)]
70110 pub struct ExportMetalSharedEventInfoEXTBuilder<'a> {
70111     inner: ExportMetalSharedEventInfoEXT,
70112     marker: ::std::marker::PhantomData<&'a ()>,
70113 }
70114 unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalSharedEventInfoEXTBuilder<'_> {}
70115 unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalSharedEventInfoEXT {}
70116 impl<'a> ::std::ops::Deref for ExportMetalSharedEventInfoEXTBuilder<'a> {
70117     type Target = ExportMetalSharedEventInfoEXT;
deref(&self) -> &Self::Target70118     fn deref(&self) -> &Self::Target {
70119         &self.inner
70120     }
70121 }
70122 impl<'a> ::std::ops::DerefMut for ExportMetalSharedEventInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target70123     fn deref_mut(&mut self) -> &mut Self::Target {
70124         &mut self.inner
70125     }
70126 }
70127 impl<'a> ExportMetalSharedEventInfoEXTBuilder<'a> {
70128     #[inline]
semaphore(mut self, semaphore: Semaphore) -> Self70129     pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
70130         self.inner.semaphore = semaphore;
70131         self
70132     }
70133     #[inline]
event(mut self, event: Event) -> Self70134     pub fn event(mut self, event: Event) -> Self {
70135         self.inner.event = event;
70136         self
70137     }
70138     #[inline]
mtl_shared_event(mut self, mtl_shared_event: MTLSharedEvent_id) -> Self70139     pub fn mtl_shared_event(mut self, mtl_shared_event: MTLSharedEvent_id) -> Self {
70140         self.inner.mtl_shared_event = mtl_shared_event;
70141         self
70142     }
70143     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
70144     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
70145     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExportMetalSharedEventInfoEXT70146     pub fn build(self) -> ExportMetalSharedEventInfoEXT {
70147         self.inner
70148     }
70149 }
70150 #[repr(C)]
70151 #[cfg_attr(feature = "debug", derive(Debug))]
70152 #[derive(Copy, Clone)]
70153 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMetalSharedEventInfoEXT.html>"]
70154 pub struct ImportMetalSharedEventInfoEXT {
70155     pub s_type: StructureType,
70156     pub p_next: *const c_void,
70157     pub mtl_shared_event: MTLSharedEvent_id,
70158 }
70159 impl ::std::default::Default for ImportMetalSharedEventInfoEXT {
70160     #[inline]
default() -> Self70161     fn default() -> Self {
70162         Self {
70163             s_type: Self::STRUCTURE_TYPE,
70164             p_next: ::std::ptr::null(),
70165             mtl_shared_event: unsafe { ::std::mem::zeroed() },
70166         }
70167     }
70168 }
70169 unsafe impl TaggedStructure for ImportMetalSharedEventInfoEXT {
70170     const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_METAL_SHARED_EVENT_INFO_EXT;
70171 }
70172 impl ImportMetalSharedEventInfoEXT {
builder<'a>() -> ImportMetalSharedEventInfoEXTBuilder<'a>70173     pub fn builder<'a>() -> ImportMetalSharedEventInfoEXTBuilder<'a> {
70174         ImportMetalSharedEventInfoEXTBuilder {
70175             inner: Self::default(),
70176             marker: ::std::marker::PhantomData,
70177         }
70178     }
70179 }
70180 #[repr(transparent)]
70181 pub struct ImportMetalSharedEventInfoEXTBuilder<'a> {
70182     inner: ImportMetalSharedEventInfoEXT,
70183     marker: ::std::marker::PhantomData<&'a ()>,
70184 }
70185 unsafe impl ExtendsSemaphoreCreateInfo for ImportMetalSharedEventInfoEXTBuilder<'_> {}
70186 unsafe impl ExtendsSemaphoreCreateInfo for ImportMetalSharedEventInfoEXT {}
70187 unsafe impl ExtendsEventCreateInfo for ImportMetalSharedEventInfoEXTBuilder<'_> {}
70188 unsafe impl ExtendsEventCreateInfo for ImportMetalSharedEventInfoEXT {}
70189 impl<'a> ::std::ops::Deref for ImportMetalSharedEventInfoEXTBuilder<'a> {
70190     type Target = ImportMetalSharedEventInfoEXT;
deref(&self) -> &Self::Target70191     fn deref(&self) -> &Self::Target {
70192         &self.inner
70193     }
70194 }
70195 impl<'a> ::std::ops::DerefMut for ImportMetalSharedEventInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target70196     fn deref_mut(&mut self) -> &mut Self::Target {
70197         &mut self.inner
70198     }
70199 }
70200 impl<'a> ImportMetalSharedEventInfoEXTBuilder<'a> {
70201     #[inline]
mtl_shared_event(mut self, mtl_shared_event: MTLSharedEvent_id) -> Self70202     pub fn mtl_shared_event(mut self, mtl_shared_event: MTLSharedEvent_id) -> Self {
70203         self.inner.mtl_shared_event = mtl_shared_event;
70204         self
70205     }
70206     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
70207     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
70208     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImportMetalSharedEventInfoEXT70209     pub fn build(self) -> ImportMetalSharedEventInfoEXT {
70210         self.inner
70211     }
70212 }
70213 #[repr(C)]
70214 #[cfg_attr(feature = "debug", derive(Debug))]
70215 #[derive(Copy, Clone)]
70216 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT.html>"]
70217 pub struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXT {
70218     pub s_type: StructureType,
70219     pub p_next: *mut c_void,
70220     pub non_seamless_cube_map: Bool32,
70221 }
70222 impl ::std::default::Default for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT {
70223     #[inline]
default() -> Self70224     fn default() -> Self {
70225         Self {
70226             s_type: Self::STRUCTURE_TYPE,
70227             p_next: ::std::ptr::null_mut(),
70228             non_seamless_cube_map: Bool32::default(),
70229         }
70230     }
70231 }
70232 unsafe impl TaggedStructure for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT {
70233     const STRUCTURE_TYPE: StructureType =
70234         StructureType::PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
70235 }
70236 impl PhysicalDeviceNonSeamlessCubeMapFeaturesEXT {
builder<'a>() -> PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a>70237     pub fn builder<'a>() -> PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> {
70238         PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder {
70239             inner: Self::default(),
70240             marker: ::std::marker::PhantomData,
70241         }
70242     }
70243 }
70244 #[repr(transparent)]
70245 pub struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> {
70246     inner: PhysicalDeviceNonSeamlessCubeMapFeaturesEXT,
70247     marker: ::std::marker::PhantomData<&'a ()>,
70248 }
70249 unsafe impl ExtendsPhysicalDeviceFeatures2
70250     for PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'_>
70251 {
70252 }
70253 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT {}
70254 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'_> {}
70255 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT {}
70256 impl<'a> ::std::ops::Deref for PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> {
70257     type Target = PhysicalDeviceNonSeamlessCubeMapFeaturesEXT;
deref(&self) -> &Self::Target70258     fn deref(&self) -> &Self::Target {
70259         &self.inner
70260     }
70261 }
70262 impl<'a> ::std::ops::DerefMut for PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target70263     fn deref_mut(&mut self) -> &mut Self::Target {
70264         &mut self.inner
70265     }
70266 }
70267 impl<'a> PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> {
70268     #[inline]
non_seamless_cube_map(mut self, non_seamless_cube_map: bool) -> Self70269     pub fn non_seamless_cube_map(mut self, non_seamless_cube_map: bool) -> Self {
70270         self.inner.non_seamless_cube_map = non_seamless_cube_map.into();
70271         self
70272     }
70273     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
70274     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
70275     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceNonSeamlessCubeMapFeaturesEXT70276     pub fn build(self) -> PhysicalDeviceNonSeamlessCubeMapFeaturesEXT {
70277         self.inner
70278     }
70279 }
70280 #[repr(C)]
70281 #[cfg_attr(feature = "debug", derive(Debug))]
70282 #[derive(Copy, Clone)]
70283 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePipelineRobustnessFeaturesEXT.html>"]
70284 pub struct PhysicalDevicePipelineRobustnessFeaturesEXT {
70285     pub s_type: StructureType,
70286     pub p_next: *mut c_void,
70287     pub pipeline_robustness: Bool32,
70288 }
70289 impl ::std::default::Default for PhysicalDevicePipelineRobustnessFeaturesEXT {
70290     #[inline]
default() -> Self70291     fn default() -> Self {
70292         Self {
70293             s_type: Self::STRUCTURE_TYPE,
70294             p_next: ::std::ptr::null_mut(),
70295             pipeline_robustness: Bool32::default(),
70296         }
70297     }
70298 }
70299 unsafe impl TaggedStructure for PhysicalDevicePipelineRobustnessFeaturesEXT {
70300     const STRUCTURE_TYPE: StructureType =
70301         StructureType::PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT;
70302 }
70303 impl PhysicalDevicePipelineRobustnessFeaturesEXT {
builder<'a>() -> PhysicalDevicePipelineRobustnessFeaturesEXTBuilder<'a>70304     pub fn builder<'a>() -> PhysicalDevicePipelineRobustnessFeaturesEXTBuilder<'a> {
70305         PhysicalDevicePipelineRobustnessFeaturesEXTBuilder {
70306             inner: Self::default(),
70307             marker: ::std::marker::PhantomData,
70308         }
70309     }
70310 }
70311 #[repr(transparent)]
70312 pub struct PhysicalDevicePipelineRobustnessFeaturesEXTBuilder<'a> {
70313     inner: PhysicalDevicePipelineRobustnessFeaturesEXT,
70314     marker: ::std::marker::PhantomData<&'a ()>,
70315 }
70316 unsafe impl ExtendsPhysicalDeviceFeatures2
70317     for PhysicalDevicePipelineRobustnessFeaturesEXTBuilder<'_>
70318 {
70319 }
70320 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelineRobustnessFeaturesEXT {}
70321 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineRobustnessFeaturesEXTBuilder<'_> {}
70322 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineRobustnessFeaturesEXT {}
70323 impl<'a> ::std::ops::Deref for PhysicalDevicePipelineRobustnessFeaturesEXTBuilder<'a> {
70324     type Target = PhysicalDevicePipelineRobustnessFeaturesEXT;
deref(&self) -> &Self::Target70325     fn deref(&self) -> &Self::Target {
70326         &self.inner
70327     }
70328 }
70329 impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineRobustnessFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target70330     fn deref_mut(&mut self) -> &mut Self::Target {
70331         &mut self.inner
70332     }
70333 }
70334 impl<'a> PhysicalDevicePipelineRobustnessFeaturesEXTBuilder<'a> {
70335     #[inline]
pipeline_robustness(mut self, pipeline_robustness: bool) -> Self70336     pub fn pipeline_robustness(mut self, pipeline_robustness: bool) -> Self {
70337         self.inner.pipeline_robustness = pipeline_robustness.into();
70338         self
70339     }
70340     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
70341     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
70342     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePipelineRobustnessFeaturesEXT70343     pub fn build(self) -> PhysicalDevicePipelineRobustnessFeaturesEXT {
70344         self.inner
70345     }
70346 }
70347 #[repr(C)]
70348 #[cfg_attr(feature = "debug", derive(Debug))]
70349 #[derive(Copy, Clone)]
70350 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRobustnessCreateInfoEXT.html>"]
70351 pub struct PipelineRobustnessCreateInfoEXT {
70352     pub s_type: StructureType,
70353     pub p_next: *const c_void,
70354     pub storage_buffers: PipelineRobustnessBufferBehaviorEXT,
70355     pub uniform_buffers: PipelineRobustnessBufferBehaviorEXT,
70356     pub vertex_inputs: PipelineRobustnessBufferBehaviorEXT,
70357     pub images: PipelineRobustnessImageBehaviorEXT,
70358 }
70359 impl ::std::default::Default for PipelineRobustnessCreateInfoEXT {
70360     #[inline]
default() -> Self70361     fn default() -> Self {
70362         Self {
70363             s_type: Self::STRUCTURE_TYPE,
70364             p_next: ::std::ptr::null(),
70365             storage_buffers: PipelineRobustnessBufferBehaviorEXT::default(),
70366             uniform_buffers: PipelineRobustnessBufferBehaviorEXT::default(),
70367             vertex_inputs: PipelineRobustnessBufferBehaviorEXT::default(),
70368             images: PipelineRobustnessImageBehaviorEXT::default(),
70369         }
70370     }
70371 }
70372 unsafe impl TaggedStructure for PipelineRobustnessCreateInfoEXT {
70373     const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
70374 }
70375 impl PipelineRobustnessCreateInfoEXT {
builder<'a>() -> PipelineRobustnessCreateInfoEXTBuilder<'a>70376     pub fn builder<'a>() -> PipelineRobustnessCreateInfoEXTBuilder<'a> {
70377         PipelineRobustnessCreateInfoEXTBuilder {
70378             inner: Self::default(),
70379             marker: ::std::marker::PhantomData,
70380         }
70381     }
70382 }
70383 #[repr(transparent)]
70384 pub struct PipelineRobustnessCreateInfoEXTBuilder<'a> {
70385     inner: PipelineRobustnessCreateInfoEXT,
70386     marker: ::std::marker::PhantomData<&'a ()>,
70387 }
70388 unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRobustnessCreateInfoEXTBuilder<'_> {}
70389 unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRobustnessCreateInfoEXT {}
70390 unsafe impl ExtendsComputePipelineCreateInfo for PipelineRobustnessCreateInfoEXTBuilder<'_> {}
70391 unsafe impl ExtendsComputePipelineCreateInfo for PipelineRobustnessCreateInfoEXT {}
70392 unsafe impl ExtendsPipelineShaderStageCreateInfo for PipelineRobustnessCreateInfoEXTBuilder<'_> {}
70393 unsafe impl ExtendsPipelineShaderStageCreateInfo for PipelineRobustnessCreateInfoEXT {}
70394 unsafe impl ExtendsRayTracingPipelineCreateInfoKHR for PipelineRobustnessCreateInfoEXTBuilder<'_> {}
70395 unsafe impl ExtendsRayTracingPipelineCreateInfoKHR for PipelineRobustnessCreateInfoEXT {}
70396 impl<'a> ::std::ops::Deref for PipelineRobustnessCreateInfoEXTBuilder<'a> {
70397     type Target = PipelineRobustnessCreateInfoEXT;
deref(&self) -> &Self::Target70398     fn deref(&self) -> &Self::Target {
70399         &self.inner
70400     }
70401 }
70402 impl<'a> ::std::ops::DerefMut for PipelineRobustnessCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target70403     fn deref_mut(&mut self) -> &mut Self::Target {
70404         &mut self.inner
70405     }
70406 }
70407 impl<'a> PipelineRobustnessCreateInfoEXTBuilder<'a> {
70408     #[inline]
storage_buffers(mut self, storage_buffers: PipelineRobustnessBufferBehaviorEXT) -> Self70409     pub fn storage_buffers(mut self, storage_buffers: PipelineRobustnessBufferBehaviorEXT) -> Self {
70410         self.inner.storage_buffers = storage_buffers;
70411         self
70412     }
70413     #[inline]
uniform_buffers(mut self, uniform_buffers: PipelineRobustnessBufferBehaviorEXT) -> Self70414     pub fn uniform_buffers(mut self, uniform_buffers: PipelineRobustnessBufferBehaviorEXT) -> Self {
70415         self.inner.uniform_buffers = uniform_buffers;
70416         self
70417     }
70418     #[inline]
vertex_inputs(mut self, vertex_inputs: PipelineRobustnessBufferBehaviorEXT) -> Self70419     pub fn vertex_inputs(mut self, vertex_inputs: PipelineRobustnessBufferBehaviorEXT) -> Self {
70420         self.inner.vertex_inputs = vertex_inputs;
70421         self
70422     }
70423     #[inline]
images(mut self, images: PipelineRobustnessImageBehaviorEXT) -> Self70424     pub fn images(mut self, images: PipelineRobustnessImageBehaviorEXT) -> Self {
70425         self.inner.images = images;
70426         self
70427     }
70428     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
70429     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
70430     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineRobustnessCreateInfoEXT70431     pub fn build(self) -> PipelineRobustnessCreateInfoEXT {
70432         self.inner
70433     }
70434 }
70435 #[repr(C)]
70436 #[cfg_attr(feature = "debug", derive(Debug))]
70437 #[derive(Copy, Clone)]
70438 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePipelineRobustnessPropertiesEXT.html>"]
70439 pub struct PhysicalDevicePipelineRobustnessPropertiesEXT {
70440     pub s_type: StructureType,
70441     pub p_next: *mut c_void,
70442     pub default_robustness_storage_buffers: PipelineRobustnessBufferBehaviorEXT,
70443     pub default_robustness_uniform_buffers: PipelineRobustnessBufferBehaviorEXT,
70444     pub default_robustness_vertex_inputs: PipelineRobustnessBufferBehaviorEXT,
70445     pub default_robustness_images: PipelineRobustnessImageBehaviorEXT,
70446 }
70447 impl ::std::default::Default for PhysicalDevicePipelineRobustnessPropertiesEXT {
70448     #[inline]
default() -> Self70449     fn default() -> Self {
70450         Self {
70451             s_type: Self::STRUCTURE_TYPE,
70452             p_next: ::std::ptr::null_mut(),
70453             default_robustness_storage_buffers: PipelineRobustnessBufferBehaviorEXT::default(),
70454             default_robustness_uniform_buffers: PipelineRobustnessBufferBehaviorEXT::default(),
70455             default_robustness_vertex_inputs: PipelineRobustnessBufferBehaviorEXT::default(),
70456             default_robustness_images: PipelineRobustnessImageBehaviorEXT::default(),
70457         }
70458     }
70459 }
70460 unsafe impl TaggedStructure for PhysicalDevicePipelineRobustnessPropertiesEXT {
70461     const STRUCTURE_TYPE: StructureType =
70462         StructureType::PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT;
70463 }
70464 impl PhysicalDevicePipelineRobustnessPropertiesEXT {
builder<'a>() -> PhysicalDevicePipelineRobustnessPropertiesEXTBuilder<'a>70465     pub fn builder<'a>() -> PhysicalDevicePipelineRobustnessPropertiesEXTBuilder<'a> {
70466         PhysicalDevicePipelineRobustnessPropertiesEXTBuilder {
70467             inner: Self::default(),
70468             marker: ::std::marker::PhantomData,
70469         }
70470     }
70471 }
70472 #[repr(transparent)]
70473 pub struct PhysicalDevicePipelineRobustnessPropertiesEXTBuilder<'a> {
70474     inner: PhysicalDevicePipelineRobustnessPropertiesEXT,
70475     marker: ::std::marker::PhantomData<&'a ()>,
70476 }
70477 unsafe impl ExtendsPhysicalDeviceProperties2
70478     for PhysicalDevicePipelineRobustnessPropertiesEXTBuilder<'_>
70479 {
70480 }
70481 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePipelineRobustnessPropertiesEXT {}
70482 impl<'a> ::std::ops::Deref for PhysicalDevicePipelineRobustnessPropertiesEXTBuilder<'a> {
70483     type Target = PhysicalDevicePipelineRobustnessPropertiesEXT;
deref(&self) -> &Self::Target70484     fn deref(&self) -> &Self::Target {
70485         &self.inner
70486     }
70487 }
70488 impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineRobustnessPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target70489     fn deref_mut(&mut self) -> &mut Self::Target {
70490         &mut self.inner
70491     }
70492 }
70493 impl<'a> PhysicalDevicePipelineRobustnessPropertiesEXTBuilder<'a> {
70494     #[inline]
default_robustness_storage_buffers( mut self, default_robustness_storage_buffers: PipelineRobustnessBufferBehaviorEXT, ) -> Self70495     pub fn default_robustness_storage_buffers(
70496         mut self,
70497         default_robustness_storage_buffers: PipelineRobustnessBufferBehaviorEXT,
70498     ) -> Self {
70499         self.inner.default_robustness_storage_buffers = default_robustness_storage_buffers;
70500         self
70501     }
70502     #[inline]
default_robustness_uniform_buffers( mut self, default_robustness_uniform_buffers: PipelineRobustnessBufferBehaviorEXT, ) -> Self70503     pub fn default_robustness_uniform_buffers(
70504         mut self,
70505         default_robustness_uniform_buffers: PipelineRobustnessBufferBehaviorEXT,
70506     ) -> Self {
70507         self.inner.default_robustness_uniform_buffers = default_robustness_uniform_buffers;
70508         self
70509     }
70510     #[inline]
default_robustness_vertex_inputs( mut self, default_robustness_vertex_inputs: PipelineRobustnessBufferBehaviorEXT, ) -> Self70511     pub fn default_robustness_vertex_inputs(
70512         mut self,
70513         default_robustness_vertex_inputs: PipelineRobustnessBufferBehaviorEXT,
70514     ) -> Self {
70515         self.inner.default_robustness_vertex_inputs = default_robustness_vertex_inputs;
70516         self
70517     }
70518     #[inline]
default_robustness_images( mut self, default_robustness_images: PipelineRobustnessImageBehaviorEXT, ) -> Self70519     pub fn default_robustness_images(
70520         mut self,
70521         default_robustness_images: PipelineRobustnessImageBehaviorEXT,
70522     ) -> Self {
70523         self.inner.default_robustness_images = default_robustness_images;
70524         self
70525     }
70526     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
70527     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
70528     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePipelineRobustnessPropertiesEXT70529     pub fn build(self) -> PhysicalDevicePipelineRobustnessPropertiesEXT {
70530         self.inner
70531     }
70532 }
70533 #[repr(C)]
70534 #[cfg_attr(feature = "debug", derive(Debug))]
70535 #[derive(Copy, Clone)]
70536 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewSampleWeightCreateInfoQCOM.html>"]
70537 pub struct ImageViewSampleWeightCreateInfoQCOM {
70538     pub s_type: StructureType,
70539     pub p_next: *const c_void,
70540     pub filter_center: Offset2D,
70541     pub filter_size: Extent2D,
70542     pub num_phases: u32,
70543 }
70544 impl ::std::default::Default for ImageViewSampleWeightCreateInfoQCOM {
70545     #[inline]
default() -> Self70546     fn default() -> Self {
70547         Self {
70548             s_type: Self::STRUCTURE_TYPE,
70549             p_next: ::std::ptr::null(),
70550             filter_center: Offset2D::default(),
70551             filter_size: Extent2D::default(),
70552             num_phases: u32::default(),
70553         }
70554     }
70555 }
70556 unsafe impl TaggedStructure for ImageViewSampleWeightCreateInfoQCOM {
70557     const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM;
70558 }
70559 impl ImageViewSampleWeightCreateInfoQCOM {
builder<'a>() -> ImageViewSampleWeightCreateInfoQCOMBuilder<'a>70560     pub fn builder<'a>() -> ImageViewSampleWeightCreateInfoQCOMBuilder<'a> {
70561         ImageViewSampleWeightCreateInfoQCOMBuilder {
70562             inner: Self::default(),
70563             marker: ::std::marker::PhantomData,
70564         }
70565     }
70566 }
70567 #[repr(transparent)]
70568 pub struct ImageViewSampleWeightCreateInfoQCOMBuilder<'a> {
70569     inner: ImageViewSampleWeightCreateInfoQCOM,
70570     marker: ::std::marker::PhantomData<&'a ()>,
70571 }
70572 unsafe impl ExtendsImageViewCreateInfo for ImageViewSampleWeightCreateInfoQCOMBuilder<'_> {}
70573 unsafe impl ExtendsImageViewCreateInfo for ImageViewSampleWeightCreateInfoQCOM {}
70574 impl<'a> ::std::ops::Deref for ImageViewSampleWeightCreateInfoQCOMBuilder<'a> {
70575     type Target = ImageViewSampleWeightCreateInfoQCOM;
deref(&self) -> &Self::Target70576     fn deref(&self) -> &Self::Target {
70577         &self.inner
70578     }
70579 }
70580 impl<'a> ::std::ops::DerefMut for ImageViewSampleWeightCreateInfoQCOMBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target70581     fn deref_mut(&mut self) -> &mut Self::Target {
70582         &mut self.inner
70583     }
70584 }
70585 impl<'a> ImageViewSampleWeightCreateInfoQCOMBuilder<'a> {
70586     #[inline]
filter_center(mut self, filter_center: Offset2D) -> Self70587     pub fn filter_center(mut self, filter_center: Offset2D) -> Self {
70588         self.inner.filter_center = filter_center;
70589         self
70590     }
70591     #[inline]
filter_size(mut self, filter_size: Extent2D) -> Self70592     pub fn filter_size(mut self, filter_size: Extent2D) -> Self {
70593         self.inner.filter_size = filter_size;
70594         self
70595     }
70596     #[inline]
num_phases(mut self, num_phases: u32) -> Self70597     pub fn num_phases(mut self, num_phases: u32) -> Self {
70598         self.inner.num_phases = num_phases;
70599         self
70600     }
70601     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
70602     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
70603     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageViewSampleWeightCreateInfoQCOM70604     pub fn build(self) -> ImageViewSampleWeightCreateInfoQCOM {
70605         self.inner
70606     }
70607 }
70608 #[repr(C)]
70609 #[cfg_attr(feature = "debug", derive(Debug))]
70610 #[derive(Copy, Clone)]
70611 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageProcessingFeaturesQCOM.html>"]
70612 pub struct PhysicalDeviceImageProcessingFeaturesQCOM {
70613     pub s_type: StructureType,
70614     pub p_next: *mut c_void,
70615     pub texture_sample_weighted: Bool32,
70616     pub texture_box_filter: Bool32,
70617     pub texture_block_match: Bool32,
70618 }
70619 impl ::std::default::Default for PhysicalDeviceImageProcessingFeaturesQCOM {
70620     #[inline]
default() -> Self70621     fn default() -> Self {
70622         Self {
70623             s_type: Self::STRUCTURE_TYPE,
70624             p_next: ::std::ptr::null_mut(),
70625             texture_sample_weighted: Bool32::default(),
70626             texture_box_filter: Bool32::default(),
70627             texture_block_match: Bool32::default(),
70628         }
70629     }
70630 }
70631 unsafe impl TaggedStructure for PhysicalDeviceImageProcessingFeaturesQCOM {
70632     const STRUCTURE_TYPE: StructureType =
70633         StructureType::PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
70634 }
70635 impl PhysicalDeviceImageProcessingFeaturesQCOM {
builder<'a>() -> PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'a>70636     pub fn builder<'a>() -> PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'a> {
70637         PhysicalDeviceImageProcessingFeaturesQCOMBuilder {
70638             inner: Self::default(),
70639             marker: ::std::marker::PhantomData,
70640         }
70641     }
70642 }
70643 #[repr(transparent)]
70644 pub struct PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'a> {
70645     inner: PhysicalDeviceImageProcessingFeaturesQCOM,
70646     marker: ::std::marker::PhantomData<&'a ()>,
70647 }
70648 unsafe impl ExtendsPhysicalDeviceFeatures2
70649     for PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'_>
70650 {
70651 }
70652 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageProcessingFeaturesQCOM {}
70653 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'_> {}
70654 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageProcessingFeaturesQCOM {}
70655 impl<'a> ::std::ops::Deref for PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'a> {
70656     type Target = PhysicalDeviceImageProcessingFeaturesQCOM;
deref(&self) -> &Self::Target70657     fn deref(&self) -> &Self::Target {
70658         &self.inner
70659     }
70660 }
70661 impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target70662     fn deref_mut(&mut self) -> &mut Self::Target {
70663         &mut self.inner
70664     }
70665 }
70666 impl<'a> PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'a> {
70667     #[inline]
texture_sample_weighted(mut self, texture_sample_weighted: bool) -> Self70668     pub fn texture_sample_weighted(mut self, texture_sample_weighted: bool) -> Self {
70669         self.inner.texture_sample_weighted = texture_sample_weighted.into();
70670         self
70671     }
70672     #[inline]
texture_box_filter(mut self, texture_box_filter: bool) -> Self70673     pub fn texture_box_filter(mut self, texture_box_filter: bool) -> Self {
70674         self.inner.texture_box_filter = texture_box_filter.into();
70675         self
70676     }
70677     #[inline]
texture_block_match(mut self, texture_block_match: bool) -> Self70678     pub fn texture_block_match(mut self, texture_block_match: bool) -> Self {
70679         self.inner.texture_block_match = texture_block_match.into();
70680         self
70681     }
70682     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
70683     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
70684     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceImageProcessingFeaturesQCOM70685     pub fn build(self) -> PhysicalDeviceImageProcessingFeaturesQCOM {
70686         self.inner
70687     }
70688 }
70689 #[repr(C)]
70690 #[cfg_attr(feature = "debug", derive(Debug))]
70691 #[derive(Copy, Clone)]
70692 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageProcessingPropertiesQCOM.html>"]
70693 pub struct PhysicalDeviceImageProcessingPropertiesQCOM {
70694     pub s_type: StructureType,
70695     pub p_next: *mut c_void,
70696     pub max_weight_filter_phases: u32,
70697     pub max_weight_filter_dimension: Extent2D,
70698     pub max_block_match_region: Extent2D,
70699     pub max_box_filter_block_size: Extent2D,
70700 }
70701 impl ::std::default::Default for PhysicalDeviceImageProcessingPropertiesQCOM {
70702     #[inline]
default() -> Self70703     fn default() -> Self {
70704         Self {
70705             s_type: Self::STRUCTURE_TYPE,
70706             p_next: ::std::ptr::null_mut(),
70707             max_weight_filter_phases: u32::default(),
70708             max_weight_filter_dimension: Extent2D::default(),
70709             max_block_match_region: Extent2D::default(),
70710             max_box_filter_block_size: Extent2D::default(),
70711         }
70712     }
70713 }
70714 unsafe impl TaggedStructure for PhysicalDeviceImageProcessingPropertiesQCOM {
70715     const STRUCTURE_TYPE: StructureType =
70716         StructureType::PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM;
70717 }
70718 impl PhysicalDeviceImageProcessingPropertiesQCOM {
builder<'a>() -> PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'a>70719     pub fn builder<'a>() -> PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'a> {
70720         PhysicalDeviceImageProcessingPropertiesQCOMBuilder {
70721             inner: Self::default(),
70722             marker: ::std::marker::PhantomData,
70723         }
70724     }
70725 }
70726 #[repr(transparent)]
70727 pub struct PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'a> {
70728     inner: PhysicalDeviceImageProcessingPropertiesQCOM,
70729     marker: ::std::marker::PhantomData<&'a ()>,
70730 }
70731 unsafe impl ExtendsPhysicalDeviceProperties2
70732     for PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'_>
70733 {
70734 }
70735 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceImageProcessingPropertiesQCOM {}
70736 impl<'a> ::std::ops::Deref for PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'a> {
70737     type Target = PhysicalDeviceImageProcessingPropertiesQCOM;
deref(&self) -> &Self::Target70738     fn deref(&self) -> &Self::Target {
70739         &self.inner
70740     }
70741 }
70742 impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target70743     fn deref_mut(&mut self) -> &mut Self::Target {
70744         &mut self.inner
70745     }
70746 }
70747 impl<'a> PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'a> {
70748     #[inline]
max_weight_filter_phases(mut self, max_weight_filter_phases: u32) -> Self70749     pub fn max_weight_filter_phases(mut self, max_weight_filter_phases: u32) -> Self {
70750         self.inner.max_weight_filter_phases = max_weight_filter_phases;
70751         self
70752     }
70753     #[inline]
max_weight_filter_dimension(mut self, max_weight_filter_dimension: Extent2D) -> Self70754     pub fn max_weight_filter_dimension(mut self, max_weight_filter_dimension: Extent2D) -> Self {
70755         self.inner.max_weight_filter_dimension = max_weight_filter_dimension;
70756         self
70757     }
70758     #[inline]
max_block_match_region(mut self, max_block_match_region: Extent2D) -> Self70759     pub fn max_block_match_region(mut self, max_block_match_region: Extent2D) -> Self {
70760         self.inner.max_block_match_region = max_block_match_region;
70761         self
70762     }
70763     #[inline]
max_box_filter_block_size(mut self, max_box_filter_block_size: Extent2D) -> Self70764     pub fn max_box_filter_block_size(mut self, max_box_filter_block_size: Extent2D) -> Self {
70765         self.inner.max_box_filter_block_size = max_box_filter_block_size;
70766         self
70767     }
70768     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
70769     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
70770     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceImageProcessingPropertiesQCOM70771     pub fn build(self) -> PhysicalDeviceImageProcessingPropertiesQCOM {
70772         self.inner
70773     }
70774 }
70775 #[repr(C)]
70776 #[cfg_attr(feature = "debug", derive(Debug))]
70777 #[derive(Copy, Clone)]
70778 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTilePropertiesFeaturesQCOM.html>"]
70779 pub struct PhysicalDeviceTilePropertiesFeaturesQCOM {
70780     pub s_type: StructureType,
70781     pub p_next: *mut c_void,
70782     pub tile_properties: Bool32,
70783 }
70784 impl ::std::default::Default for PhysicalDeviceTilePropertiesFeaturesQCOM {
70785     #[inline]
default() -> Self70786     fn default() -> Self {
70787         Self {
70788             s_type: Self::STRUCTURE_TYPE,
70789             p_next: ::std::ptr::null_mut(),
70790             tile_properties: Bool32::default(),
70791         }
70792     }
70793 }
70794 unsafe impl TaggedStructure for PhysicalDeviceTilePropertiesFeaturesQCOM {
70795     const STRUCTURE_TYPE: StructureType =
70796         StructureType::PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
70797 }
70798 impl PhysicalDeviceTilePropertiesFeaturesQCOM {
builder<'a>() -> PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'a>70799     pub fn builder<'a>() -> PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'a> {
70800         PhysicalDeviceTilePropertiesFeaturesQCOMBuilder {
70801             inner: Self::default(),
70802             marker: ::std::marker::PhantomData,
70803         }
70804     }
70805 }
70806 #[repr(transparent)]
70807 pub struct PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'a> {
70808     inner: PhysicalDeviceTilePropertiesFeaturesQCOM,
70809     marker: ::std::marker::PhantomData<&'a ()>,
70810 }
70811 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'_> {}
70812 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTilePropertiesFeaturesQCOM {}
70813 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'_> {}
70814 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTilePropertiesFeaturesQCOM {}
70815 impl<'a> ::std::ops::Deref for PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'a> {
70816     type Target = PhysicalDeviceTilePropertiesFeaturesQCOM;
deref(&self) -> &Self::Target70817     fn deref(&self) -> &Self::Target {
70818         &self.inner
70819     }
70820 }
70821 impl<'a> ::std::ops::DerefMut for PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target70822     fn deref_mut(&mut self) -> &mut Self::Target {
70823         &mut self.inner
70824     }
70825 }
70826 impl<'a> PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'a> {
70827     #[inline]
tile_properties(mut self, tile_properties: bool) -> Self70828     pub fn tile_properties(mut self, tile_properties: bool) -> Self {
70829         self.inner.tile_properties = tile_properties.into();
70830         self
70831     }
70832     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
70833     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
70834     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceTilePropertiesFeaturesQCOM70835     pub fn build(self) -> PhysicalDeviceTilePropertiesFeaturesQCOM {
70836         self.inner
70837     }
70838 }
70839 #[repr(C)]
70840 #[cfg_attr(feature = "debug", derive(Debug))]
70841 #[derive(Copy, Clone)]
70842 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkTilePropertiesQCOM.html>"]
70843 pub struct TilePropertiesQCOM {
70844     pub s_type: StructureType,
70845     pub p_next: *mut c_void,
70846     pub tile_size: Extent3D,
70847     pub apron_size: Extent2D,
70848     pub origin: Offset2D,
70849 }
70850 impl ::std::default::Default for TilePropertiesQCOM {
70851     #[inline]
default() -> Self70852     fn default() -> Self {
70853         Self {
70854             s_type: Self::STRUCTURE_TYPE,
70855             p_next: ::std::ptr::null_mut(),
70856             tile_size: Extent3D::default(),
70857             apron_size: Extent2D::default(),
70858             origin: Offset2D::default(),
70859         }
70860     }
70861 }
70862 unsafe impl TaggedStructure for TilePropertiesQCOM {
70863     const STRUCTURE_TYPE: StructureType = StructureType::TILE_PROPERTIES_QCOM;
70864 }
70865 impl TilePropertiesQCOM {
builder<'a>() -> TilePropertiesQCOMBuilder<'a>70866     pub fn builder<'a>() -> TilePropertiesQCOMBuilder<'a> {
70867         TilePropertiesQCOMBuilder {
70868             inner: Self::default(),
70869             marker: ::std::marker::PhantomData,
70870         }
70871     }
70872 }
70873 #[repr(transparent)]
70874 pub struct TilePropertiesQCOMBuilder<'a> {
70875     inner: TilePropertiesQCOM,
70876     marker: ::std::marker::PhantomData<&'a ()>,
70877 }
70878 impl<'a> ::std::ops::Deref for TilePropertiesQCOMBuilder<'a> {
70879     type Target = TilePropertiesQCOM;
deref(&self) -> &Self::Target70880     fn deref(&self) -> &Self::Target {
70881         &self.inner
70882     }
70883 }
70884 impl<'a> ::std::ops::DerefMut for TilePropertiesQCOMBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target70885     fn deref_mut(&mut self) -> &mut Self::Target {
70886         &mut self.inner
70887     }
70888 }
70889 impl<'a> TilePropertiesQCOMBuilder<'a> {
70890     #[inline]
tile_size(mut self, tile_size: Extent3D) -> Self70891     pub fn tile_size(mut self, tile_size: Extent3D) -> Self {
70892         self.inner.tile_size = tile_size;
70893         self
70894     }
70895     #[inline]
apron_size(mut self, apron_size: Extent2D) -> Self70896     pub fn apron_size(mut self, apron_size: Extent2D) -> Self {
70897         self.inner.apron_size = apron_size;
70898         self
70899     }
70900     #[inline]
origin(mut self, origin: Offset2D) -> Self70901     pub fn origin(mut self, origin: Offset2D) -> Self {
70902         self.inner.origin = origin;
70903         self
70904     }
70905     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
70906     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
70907     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> TilePropertiesQCOM70908     pub fn build(self) -> TilePropertiesQCOM {
70909         self.inner
70910     }
70911 }
70912 #[repr(C)]
70913 #[cfg_attr(feature = "debug", derive(Debug))]
70914 #[derive(Copy, Clone)]
70915 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceAmigoProfilingFeaturesSEC.html>"]
70916 pub struct PhysicalDeviceAmigoProfilingFeaturesSEC {
70917     pub s_type: StructureType,
70918     pub p_next: *mut c_void,
70919     pub amigo_profiling: Bool32,
70920 }
70921 impl ::std::default::Default for PhysicalDeviceAmigoProfilingFeaturesSEC {
70922     #[inline]
default() -> Self70923     fn default() -> Self {
70924         Self {
70925             s_type: Self::STRUCTURE_TYPE,
70926             p_next: ::std::ptr::null_mut(),
70927             amigo_profiling: Bool32::default(),
70928         }
70929     }
70930 }
70931 unsafe impl TaggedStructure for PhysicalDeviceAmigoProfilingFeaturesSEC {
70932     const STRUCTURE_TYPE: StructureType =
70933         StructureType::PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC;
70934 }
70935 impl PhysicalDeviceAmigoProfilingFeaturesSEC {
builder<'a>() -> PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'a>70936     pub fn builder<'a>() -> PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'a> {
70937         PhysicalDeviceAmigoProfilingFeaturesSECBuilder {
70938             inner: Self::default(),
70939             marker: ::std::marker::PhantomData,
70940         }
70941     }
70942 }
70943 #[repr(transparent)]
70944 pub struct PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'a> {
70945     inner: PhysicalDeviceAmigoProfilingFeaturesSEC,
70946     marker: ::std::marker::PhantomData<&'a ()>,
70947 }
70948 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'_> {}
70949 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceAmigoProfilingFeaturesSEC {}
70950 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'_> {}
70951 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAmigoProfilingFeaturesSEC {}
70952 impl<'a> ::std::ops::Deref for PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'a> {
70953     type Target = PhysicalDeviceAmigoProfilingFeaturesSEC;
deref(&self) -> &Self::Target70954     fn deref(&self) -> &Self::Target {
70955         &self.inner
70956     }
70957 }
70958 impl<'a> ::std::ops::DerefMut for PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target70959     fn deref_mut(&mut self) -> &mut Self::Target {
70960         &mut self.inner
70961     }
70962 }
70963 impl<'a> PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'a> {
70964     #[inline]
amigo_profiling(mut self, amigo_profiling: bool) -> Self70965     pub fn amigo_profiling(mut self, amigo_profiling: bool) -> Self {
70966         self.inner.amigo_profiling = amigo_profiling.into();
70967         self
70968     }
70969     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
70970     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
70971     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceAmigoProfilingFeaturesSEC70972     pub fn build(self) -> PhysicalDeviceAmigoProfilingFeaturesSEC {
70973         self.inner
70974     }
70975 }
70976 #[repr(C)]
70977 #[cfg_attr(feature = "debug", derive(Debug))]
70978 #[derive(Copy, Clone)]
70979 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAmigoProfilingSubmitInfoSEC.html>"]
70980 pub struct AmigoProfilingSubmitInfoSEC {
70981     pub s_type: StructureType,
70982     pub p_next: *const c_void,
70983     pub first_draw_timestamp: u64,
70984     pub swap_buffer_timestamp: u64,
70985 }
70986 impl ::std::default::Default for AmigoProfilingSubmitInfoSEC {
70987     #[inline]
default() -> Self70988     fn default() -> Self {
70989         Self {
70990             s_type: Self::STRUCTURE_TYPE,
70991             p_next: ::std::ptr::null(),
70992             first_draw_timestamp: u64::default(),
70993             swap_buffer_timestamp: u64::default(),
70994         }
70995     }
70996 }
70997 unsafe impl TaggedStructure for AmigoProfilingSubmitInfoSEC {
70998     const STRUCTURE_TYPE: StructureType = StructureType::AMIGO_PROFILING_SUBMIT_INFO_SEC;
70999 }
71000 impl AmigoProfilingSubmitInfoSEC {
builder<'a>() -> AmigoProfilingSubmitInfoSECBuilder<'a>71001     pub fn builder<'a>() -> AmigoProfilingSubmitInfoSECBuilder<'a> {
71002         AmigoProfilingSubmitInfoSECBuilder {
71003             inner: Self::default(),
71004             marker: ::std::marker::PhantomData,
71005         }
71006     }
71007 }
71008 #[repr(transparent)]
71009 pub struct AmigoProfilingSubmitInfoSECBuilder<'a> {
71010     inner: AmigoProfilingSubmitInfoSEC,
71011     marker: ::std::marker::PhantomData<&'a ()>,
71012 }
71013 unsafe impl ExtendsSubmitInfo for AmigoProfilingSubmitInfoSECBuilder<'_> {}
71014 unsafe impl ExtendsSubmitInfo for AmigoProfilingSubmitInfoSEC {}
71015 impl<'a> ::std::ops::Deref for AmigoProfilingSubmitInfoSECBuilder<'a> {
71016     type Target = AmigoProfilingSubmitInfoSEC;
deref(&self) -> &Self::Target71017     fn deref(&self) -> &Self::Target {
71018         &self.inner
71019     }
71020 }
71021 impl<'a> ::std::ops::DerefMut for AmigoProfilingSubmitInfoSECBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target71022     fn deref_mut(&mut self) -> &mut Self::Target {
71023         &mut self.inner
71024     }
71025 }
71026 impl<'a> AmigoProfilingSubmitInfoSECBuilder<'a> {
71027     #[inline]
first_draw_timestamp(mut self, first_draw_timestamp: u64) -> Self71028     pub fn first_draw_timestamp(mut self, first_draw_timestamp: u64) -> Self {
71029         self.inner.first_draw_timestamp = first_draw_timestamp;
71030         self
71031     }
71032     #[inline]
swap_buffer_timestamp(mut self, swap_buffer_timestamp: u64) -> Self71033     pub fn swap_buffer_timestamp(mut self, swap_buffer_timestamp: u64) -> Self {
71034         self.inner.swap_buffer_timestamp = swap_buffer_timestamp;
71035         self
71036     }
71037     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
71038     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
71039     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AmigoProfilingSubmitInfoSEC71040     pub fn build(self) -> AmigoProfilingSubmitInfoSEC {
71041         self.inner
71042     }
71043 }
71044 #[repr(C)]
71045 #[cfg_attr(feature = "debug", derive(Debug))]
71046 #[derive(Copy, Clone)]
71047 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.html>"]
71048 pub struct PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT {
71049     pub s_type: StructureType,
71050     pub p_next: *mut c_void,
71051     pub attachment_feedback_loop_layout: Bool32,
71052 }
71053 impl ::std::default::Default for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT {
71054     #[inline]
default() -> Self71055     fn default() -> Self {
71056         Self {
71057             s_type: Self::STRUCTURE_TYPE,
71058             p_next: ::std::ptr::null_mut(),
71059             attachment_feedback_loop_layout: Bool32::default(),
71060         }
71061     }
71062 }
71063 unsafe impl TaggedStructure for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT {
71064     const STRUCTURE_TYPE: StructureType =
71065         StructureType::PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
71066 }
71067 impl PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT {
builder<'a>() -> PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'a>71068     pub fn builder<'a>() -> PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'a> {
71069         PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder {
71070             inner: Self::default(),
71071             marker: ::std::marker::PhantomData,
71072         }
71073     }
71074 }
71075 #[repr(transparent)]
71076 pub struct PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'a> {
71077     inner: PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT,
71078     marker: ::std::marker::PhantomData<&'a ()>,
71079 }
71080 unsafe impl ExtendsPhysicalDeviceFeatures2
71081     for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'_>
71082 {
71083 }
71084 unsafe impl ExtendsPhysicalDeviceFeatures2
71085     for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT
71086 {
71087 }
71088 unsafe impl ExtendsDeviceCreateInfo
71089     for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'_>
71090 {
71091 }
71092 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT {}
71093 impl<'a> ::std::ops::Deref for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'a> {
71094     type Target = PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT;
deref(&self) -> &Self::Target71095     fn deref(&self) -> &Self::Target {
71096         &self.inner
71097     }
71098 }
71099 impl<'a> ::std::ops::DerefMut for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target71100     fn deref_mut(&mut self) -> &mut Self::Target {
71101         &mut self.inner
71102     }
71103 }
71104 impl<'a> PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'a> {
71105     #[inline]
attachment_feedback_loop_layout( mut self, attachment_feedback_loop_layout: bool, ) -> Self71106     pub fn attachment_feedback_loop_layout(
71107         mut self,
71108         attachment_feedback_loop_layout: bool,
71109     ) -> Self {
71110         self.inner.attachment_feedback_loop_layout = attachment_feedback_loop_layout.into();
71111         self
71112     }
71113     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
71114     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
71115     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT71116     pub fn build(self) -> PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT {
71117         self.inner
71118     }
71119 }
71120 #[repr(C)]
71121 #[cfg_attr(feature = "debug", derive(Debug))]
71122 #[derive(Copy, Clone)]
71123 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDepthClampZeroOneFeaturesEXT.html>"]
71124 pub struct PhysicalDeviceDepthClampZeroOneFeaturesEXT {
71125     pub s_type: StructureType,
71126     pub p_next: *mut c_void,
71127     pub depth_clamp_zero_one: Bool32,
71128 }
71129 impl ::std::default::Default for PhysicalDeviceDepthClampZeroOneFeaturesEXT {
71130     #[inline]
default() -> Self71131     fn default() -> Self {
71132         Self {
71133             s_type: Self::STRUCTURE_TYPE,
71134             p_next: ::std::ptr::null_mut(),
71135             depth_clamp_zero_one: Bool32::default(),
71136         }
71137     }
71138 }
71139 unsafe impl TaggedStructure for PhysicalDeviceDepthClampZeroOneFeaturesEXT {
71140     const STRUCTURE_TYPE: StructureType =
71141         StructureType::PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT;
71142 }
71143 impl PhysicalDeviceDepthClampZeroOneFeaturesEXT {
builder<'a>() -> PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder<'a>71144     pub fn builder<'a>() -> PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder<'a> {
71145         PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder {
71146             inner: Self::default(),
71147             marker: ::std::marker::PhantomData,
71148         }
71149     }
71150 }
71151 #[repr(transparent)]
71152 pub struct PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder<'a> {
71153     inner: PhysicalDeviceDepthClampZeroOneFeaturesEXT,
71154     marker: ::std::marker::PhantomData<&'a ()>,
71155 }
71156 unsafe impl ExtendsPhysicalDeviceFeatures2
71157     for PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder<'_>
71158 {
71159 }
71160 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClampZeroOneFeaturesEXT {}
71161 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder<'_> {}
71162 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClampZeroOneFeaturesEXT {}
71163 impl<'a> ::std::ops::Deref for PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder<'a> {
71164     type Target = PhysicalDeviceDepthClampZeroOneFeaturesEXT;
deref(&self) -> &Self::Target71165     fn deref(&self) -> &Self::Target {
71166         &self.inner
71167     }
71168 }
71169 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target71170     fn deref_mut(&mut self) -> &mut Self::Target {
71171         &mut self.inner
71172     }
71173 }
71174 impl<'a> PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder<'a> {
71175     #[inline]
depth_clamp_zero_one(mut self, depth_clamp_zero_one: bool) -> Self71176     pub fn depth_clamp_zero_one(mut self, depth_clamp_zero_one: bool) -> Self {
71177         self.inner.depth_clamp_zero_one = depth_clamp_zero_one.into();
71178         self
71179     }
71180     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
71181     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
71182     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDepthClampZeroOneFeaturesEXT71183     pub fn build(self) -> PhysicalDeviceDepthClampZeroOneFeaturesEXT {
71184         self.inner
71185     }
71186 }
71187 #[repr(C)]
71188 #[cfg_attr(feature = "debug", derive(Debug))]
71189 #[derive(Copy, Clone)]
71190 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceAddressBindingReportFeaturesEXT.html>"]
71191 pub struct PhysicalDeviceAddressBindingReportFeaturesEXT {
71192     pub s_type: StructureType,
71193     pub p_next: *mut c_void,
71194     pub report_address_binding: Bool32,
71195 }
71196 impl ::std::default::Default for PhysicalDeviceAddressBindingReportFeaturesEXT {
71197     #[inline]
default() -> Self71198     fn default() -> Self {
71199         Self {
71200             s_type: Self::STRUCTURE_TYPE,
71201             p_next: ::std::ptr::null_mut(),
71202             report_address_binding: Bool32::default(),
71203         }
71204     }
71205 }
71206 unsafe impl TaggedStructure for PhysicalDeviceAddressBindingReportFeaturesEXT {
71207     const STRUCTURE_TYPE: StructureType =
71208         StructureType::PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
71209 }
71210 impl PhysicalDeviceAddressBindingReportFeaturesEXT {
builder<'a>() -> PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'a>71211     pub fn builder<'a>() -> PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'a> {
71212         PhysicalDeviceAddressBindingReportFeaturesEXTBuilder {
71213             inner: Self::default(),
71214             marker: ::std::marker::PhantomData,
71215         }
71216     }
71217 }
71218 #[repr(transparent)]
71219 pub struct PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'a> {
71220     inner: PhysicalDeviceAddressBindingReportFeaturesEXT,
71221     marker: ::std::marker::PhantomData<&'a ()>,
71222 }
71223 unsafe impl ExtendsPhysicalDeviceFeatures2
71224     for PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'_>
71225 {
71226 }
71227 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceAddressBindingReportFeaturesEXT {}
71228 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'_> {}
71229 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAddressBindingReportFeaturesEXT {}
71230 impl<'a> ::std::ops::Deref for PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'a> {
71231     type Target = PhysicalDeviceAddressBindingReportFeaturesEXT;
deref(&self) -> &Self::Target71232     fn deref(&self) -> &Self::Target {
71233         &self.inner
71234     }
71235 }
71236 impl<'a> ::std::ops::DerefMut for PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target71237     fn deref_mut(&mut self) -> &mut Self::Target {
71238         &mut self.inner
71239     }
71240 }
71241 impl<'a> PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'a> {
71242     #[inline]
report_address_binding(mut self, report_address_binding: bool) -> Self71243     pub fn report_address_binding(mut self, report_address_binding: bool) -> Self {
71244         self.inner.report_address_binding = report_address_binding.into();
71245         self
71246     }
71247     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
71248     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
71249     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceAddressBindingReportFeaturesEXT71250     pub fn build(self) -> PhysicalDeviceAddressBindingReportFeaturesEXT {
71251         self.inner
71252     }
71253 }
71254 #[repr(C)]
71255 #[cfg_attr(feature = "debug", derive(Debug))]
71256 #[derive(Copy, Clone)]
71257 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceAddressBindingCallbackDataEXT.html>"]
71258 pub struct DeviceAddressBindingCallbackDataEXT {
71259     pub s_type: StructureType,
71260     pub p_next: *mut c_void,
71261     pub flags: DeviceAddressBindingFlagsEXT,
71262     pub base_address: DeviceAddress,
71263     pub size: DeviceSize,
71264     pub binding_type: DeviceAddressBindingTypeEXT,
71265 }
71266 impl ::std::default::Default for DeviceAddressBindingCallbackDataEXT {
71267     #[inline]
default() -> Self71268     fn default() -> Self {
71269         Self {
71270             s_type: Self::STRUCTURE_TYPE,
71271             p_next: ::std::ptr::null_mut(),
71272             flags: DeviceAddressBindingFlagsEXT::default(),
71273             base_address: DeviceAddress::default(),
71274             size: DeviceSize::default(),
71275             binding_type: DeviceAddressBindingTypeEXT::default(),
71276         }
71277     }
71278 }
71279 unsafe impl TaggedStructure for DeviceAddressBindingCallbackDataEXT {
71280     const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT;
71281 }
71282 impl DeviceAddressBindingCallbackDataEXT {
builder<'a>() -> DeviceAddressBindingCallbackDataEXTBuilder<'a>71283     pub fn builder<'a>() -> DeviceAddressBindingCallbackDataEXTBuilder<'a> {
71284         DeviceAddressBindingCallbackDataEXTBuilder {
71285             inner: Self::default(),
71286             marker: ::std::marker::PhantomData,
71287         }
71288     }
71289 }
71290 #[repr(transparent)]
71291 pub struct DeviceAddressBindingCallbackDataEXTBuilder<'a> {
71292     inner: DeviceAddressBindingCallbackDataEXT,
71293     marker: ::std::marker::PhantomData<&'a ()>,
71294 }
71295 unsafe impl ExtendsDebugUtilsMessengerCallbackDataEXT
71296     for DeviceAddressBindingCallbackDataEXTBuilder<'_>
71297 {
71298 }
71299 unsafe impl ExtendsDebugUtilsMessengerCallbackDataEXT for DeviceAddressBindingCallbackDataEXT {}
71300 impl<'a> ::std::ops::Deref for DeviceAddressBindingCallbackDataEXTBuilder<'a> {
71301     type Target = DeviceAddressBindingCallbackDataEXT;
deref(&self) -> &Self::Target71302     fn deref(&self) -> &Self::Target {
71303         &self.inner
71304     }
71305 }
71306 impl<'a> ::std::ops::DerefMut for DeviceAddressBindingCallbackDataEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target71307     fn deref_mut(&mut self) -> &mut Self::Target {
71308         &mut self.inner
71309     }
71310 }
71311 impl<'a> DeviceAddressBindingCallbackDataEXTBuilder<'a> {
71312     #[inline]
flags(mut self, flags: DeviceAddressBindingFlagsEXT) -> Self71313     pub fn flags(mut self, flags: DeviceAddressBindingFlagsEXT) -> Self {
71314         self.inner.flags = flags;
71315         self
71316     }
71317     #[inline]
base_address(mut self, base_address: DeviceAddress) -> Self71318     pub fn base_address(mut self, base_address: DeviceAddress) -> Self {
71319         self.inner.base_address = base_address;
71320         self
71321     }
71322     #[inline]
size(mut self, size: DeviceSize) -> Self71323     pub fn size(mut self, size: DeviceSize) -> Self {
71324         self.inner.size = size;
71325         self
71326     }
71327     #[inline]
binding_type(mut self, binding_type: DeviceAddressBindingTypeEXT) -> Self71328     pub fn binding_type(mut self, binding_type: DeviceAddressBindingTypeEXT) -> Self {
71329         self.inner.binding_type = binding_type;
71330         self
71331     }
71332     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
71333     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
71334     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceAddressBindingCallbackDataEXT71335     pub fn build(self) -> DeviceAddressBindingCallbackDataEXT {
71336         self.inner
71337     }
71338 }
71339 #[repr(C)]
71340 #[cfg_attr(feature = "debug", derive(Debug))]
71341 #[derive(Copy, Clone)]
71342 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceOpticalFlowFeaturesNV.html>"]
71343 pub struct PhysicalDeviceOpticalFlowFeaturesNV {
71344     pub s_type: StructureType,
71345     pub p_next: *mut c_void,
71346     pub optical_flow: Bool32,
71347 }
71348 impl ::std::default::Default for PhysicalDeviceOpticalFlowFeaturesNV {
71349     #[inline]
default() -> Self71350     fn default() -> Self {
71351         Self {
71352             s_type: Self::STRUCTURE_TYPE,
71353             p_next: ::std::ptr::null_mut(),
71354             optical_flow: Bool32::default(),
71355         }
71356     }
71357 }
71358 unsafe impl TaggedStructure for PhysicalDeviceOpticalFlowFeaturesNV {
71359     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
71360 }
71361 impl PhysicalDeviceOpticalFlowFeaturesNV {
builder<'a>() -> PhysicalDeviceOpticalFlowFeaturesNVBuilder<'a>71362     pub fn builder<'a>() -> PhysicalDeviceOpticalFlowFeaturesNVBuilder<'a> {
71363         PhysicalDeviceOpticalFlowFeaturesNVBuilder {
71364             inner: Self::default(),
71365             marker: ::std::marker::PhantomData,
71366         }
71367     }
71368 }
71369 #[repr(transparent)]
71370 pub struct PhysicalDeviceOpticalFlowFeaturesNVBuilder<'a> {
71371     inner: PhysicalDeviceOpticalFlowFeaturesNV,
71372     marker: ::std::marker::PhantomData<&'a ()>,
71373 }
71374 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceOpticalFlowFeaturesNVBuilder<'_> {}
71375 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceOpticalFlowFeaturesNV {}
71376 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceOpticalFlowFeaturesNVBuilder<'_> {}
71377 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceOpticalFlowFeaturesNV {}
71378 impl<'a> ::std::ops::Deref for PhysicalDeviceOpticalFlowFeaturesNVBuilder<'a> {
71379     type Target = PhysicalDeviceOpticalFlowFeaturesNV;
deref(&self) -> &Self::Target71380     fn deref(&self) -> &Self::Target {
71381         &self.inner
71382     }
71383 }
71384 impl<'a> ::std::ops::DerefMut for PhysicalDeviceOpticalFlowFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target71385     fn deref_mut(&mut self) -> &mut Self::Target {
71386         &mut self.inner
71387     }
71388 }
71389 impl<'a> PhysicalDeviceOpticalFlowFeaturesNVBuilder<'a> {
71390     #[inline]
optical_flow(mut self, optical_flow: bool) -> Self71391     pub fn optical_flow(mut self, optical_flow: bool) -> Self {
71392         self.inner.optical_flow = optical_flow.into();
71393         self
71394     }
71395     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
71396     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
71397     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceOpticalFlowFeaturesNV71398     pub fn build(self) -> PhysicalDeviceOpticalFlowFeaturesNV {
71399         self.inner
71400     }
71401 }
71402 #[repr(C)]
71403 #[cfg_attr(feature = "debug", derive(Debug))]
71404 #[derive(Copy, Clone)]
71405 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceOpticalFlowPropertiesNV.html>"]
71406 pub struct PhysicalDeviceOpticalFlowPropertiesNV {
71407     pub s_type: StructureType,
71408     pub p_next: *mut c_void,
71409     pub supported_output_grid_sizes: OpticalFlowGridSizeFlagsNV,
71410     pub supported_hint_grid_sizes: OpticalFlowGridSizeFlagsNV,
71411     pub hint_supported: Bool32,
71412     pub cost_supported: Bool32,
71413     pub bidirectional_flow_supported: Bool32,
71414     pub global_flow_supported: Bool32,
71415     pub min_width: u32,
71416     pub min_height: u32,
71417     pub max_width: u32,
71418     pub max_height: u32,
71419     pub max_num_regions_of_interest: u32,
71420 }
71421 impl ::std::default::Default for PhysicalDeviceOpticalFlowPropertiesNV {
71422     #[inline]
default() -> Self71423     fn default() -> Self {
71424         Self {
71425             s_type: Self::STRUCTURE_TYPE,
71426             p_next: ::std::ptr::null_mut(),
71427             supported_output_grid_sizes: OpticalFlowGridSizeFlagsNV::default(),
71428             supported_hint_grid_sizes: OpticalFlowGridSizeFlagsNV::default(),
71429             hint_supported: Bool32::default(),
71430             cost_supported: Bool32::default(),
71431             bidirectional_flow_supported: Bool32::default(),
71432             global_flow_supported: Bool32::default(),
71433             min_width: u32::default(),
71434             min_height: u32::default(),
71435             max_width: u32::default(),
71436             max_height: u32::default(),
71437             max_num_regions_of_interest: u32::default(),
71438         }
71439     }
71440 }
71441 unsafe impl TaggedStructure for PhysicalDeviceOpticalFlowPropertiesNV {
71442     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV;
71443 }
71444 impl PhysicalDeviceOpticalFlowPropertiesNV {
builder<'a>() -> PhysicalDeviceOpticalFlowPropertiesNVBuilder<'a>71445     pub fn builder<'a>() -> PhysicalDeviceOpticalFlowPropertiesNVBuilder<'a> {
71446         PhysicalDeviceOpticalFlowPropertiesNVBuilder {
71447             inner: Self::default(),
71448             marker: ::std::marker::PhantomData,
71449         }
71450     }
71451 }
71452 #[repr(transparent)]
71453 pub struct PhysicalDeviceOpticalFlowPropertiesNVBuilder<'a> {
71454     inner: PhysicalDeviceOpticalFlowPropertiesNV,
71455     marker: ::std::marker::PhantomData<&'a ()>,
71456 }
71457 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceOpticalFlowPropertiesNVBuilder<'_> {}
71458 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceOpticalFlowPropertiesNV {}
71459 impl<'a> ::std::ops::Deref for PhysicalDeviceOpticalFlowPropertiesNVBuilder<'a> {
71460     type Target = PhysicalDeviceOpticalFlowPropertiesNV;
deref(&self) -> &Self::Target71461     fn deref(&self) -> &Self::Target {
71462         &self.inner
71463     }
71464 }
71465 impl<'a> ::std::ops::DerefMut for PhysicalDeviceOpticalFlowPropertiesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target71466     fn deref_mut(&mut self) -> &mut Self::Target {
71467         &mut self.inner
71468     }
71469 }
71470 impl<'a> PhysicalDeviceOpticalFlowPropertiesNVBuilder<'a> {
71471     #[inline]
supported_output_grid_sizes( mut self, supported_output_grid_sizes: OpticalFlowGridSizeFlagsNV, ) -> Self71472     pub fn supported_output_grid_sizes(
71473         mut self,
71474         supported_output_grid_sizes: OpticalFlowGridSizeFlagsNV,
71475     ) -> Self {
71476         self.inner.supported_output_grid_sizes = supported_output_grid_sizes;
71477         self
71478     }
71479     #[inline]
supported_hint_grid_sizes( mut self, supported_hint_grid_sizes: OpticalFlowGridSizeFlagsNV, ) -> Self71480     pub fn supported_hint_grid_sizes(
71481         mut self,
71482         supported_hint_grid_sizes: OpticalFlowGridSizeFlagsNV,
71483     ) -> Self {
71484         self.inner.supported_hint_grid_sizes = supported_hint_grid_sizes;
71485         self
71486     }
71487     #[inline]
hint_supported(mut self, hint_supported: bool) -> Self71488     pub fn hint_supported(mut self, hint_supported: bool) -> Self {
71489         self.inner.hint_supported = hint_supported.into();
71490         self
71491     }
71492     #[inline]
cost_supported(mut self, cost_supported: bool) -> Self71493     pub fn cost_supported(mut self, cost_supported: bool) -> Self {
71494         self.inner.cost_supported = cost_supported.into();
71495         self
71496     }
71497     #[inline]
bidirectional_flow_supported(mut self, bidirectional_flow_supported: bool) -> Self71498     pub fn bidirectional_flow_supported(mut self, bidirectional_flow_supported: bool) -> Self {
71499         self.inner.bidirectional_flow_supported = bidirectional_flow_supported.into();
71500         self
71501     }
71502     #[inline]
global_flow_supported(mut self, global_flow_supported: bool) -> Self71503     pub fn global_flow_supported(mut self, global_flow_supported: bool) -> Self {
71504         self.inner.global_flow_supported = global_flow_supported.into();
71505         self
71506     }
71507     #[inline]
min_width(mut self, min_width: u32) -> Self71508     pub fn min_width(mut self, min_width: u32) -> Self {
71509         self.inner.min_width = min_width;
71510         self
71511     }
71512     #[inline]
min_height(mut self, min_height: u32) -> Self71513     pub fn min_height(mut self, min_height: u32) -> Self {
71514         self.inner.min_height = min_height;
71515         self
71516     }
71517     #[inline]
max_width(mut self, max_width: u32) -> Self71518     pub fn max_width(mut self, max_width: u32) -> Self {
71519         self.inner.max_width = max_width;
71520         self
71521     }
71522     #[inline]
max_height(mut self, max_height: u32) -> Self71523     pub fn max_height(mut self, max_height: u32) -> Self {
71524         self.inner.max_height = max_height;
71525         self
71526     }
71527     #[inline]
max_num_regions_of_interest(mut self, max_num_regions_of_interest: u32) -> Self71528     pub fn max_num_regions_of_interest(mut self, max_num_regions_of_interest: u32) -> Self {
71529         self.inner.max_num_regions_of_interest = max_num_regions_of_interest;
71530         self
71531     }
71532     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
71533     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
71534     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceOpticalFlowPropertiesNV71535     pub fn build(self) -> PhysicalDeviceOpticalFlowPropertiesNV {
71536         self.inner
71537     }
71538 }
71539 #[repr(C)]
71540 #[cfg_attr(feature = "debug", derive(Debug))]
71541 #[derive(Copy, Clone)]
71542 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowImageFormatInfoNV.html>"]
71543 pub struct OpticalFlowImageFormatInfoNV {
71544     pub s_type: StructureType,
71545     pub p_next: *const c_void,
71546     pub usage: OpticalFlowUsageFlagsNV,
71547 }
71548 impl ::std::default::Default for OpticalFlowImageFormatInfoNV {
71549     #[inline]
default() -> Self71550     fn default() -> Self {
71551         Self {
71552             s_type: Self::STRUCTURE_TYPE,
71553             p_next: ::std::ptr::null(),
71554             usage: OpticalFlowUsageFlagsNV::default(),
71555         }
71556     }
71557 }
71558 unsafe impl TaggedStructure for OpticalFlowImageFormatInfoNV {
71559     const STRUCTURE_TYPE: StructureType = StructureType::OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV;
71560 }
71561 impl OpticalFlowImageFormatInfoNV {
builder<'a>() -> OpticalFlowImageFormatInfoNVBuilder<'a>71562     pub fn builder<'a>() -> OpticalFlowImageFormatInfoNVBuilder<'a> {
71563         OpticalFlowImageFormatInfoNVBuilder {
71564             inner: Self::default(),
71565             marker: ::std::marker::PhantomData,
71566         }
71567     }
71568 }
71569 #[repr(transparent)]
71570 pub struct OpticalFlowImageFormatInfoNVBuilder<'a> {
71571     inner: OpticalFlowImageFormatInfoNV,
71572     marker: ::std::marker::PhantomData<&'a ()>,
71573 }
71574 unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for OpticalFlowImageFormatInfoNVBuilder<'_> {}
71575 unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for OpticalFlowImageFormatInfoNV {}
71576 unsafe impl ExtendsImageCreateInfo for OpticalFlowImageFormatInfoNVBuilder<'_> {}
71577 unsafe impl ExtendsImageCreateInfo for OpticalFlowImageFormatInfoNV {}
71578 impl<'a> ::std::ops::Deref for OpticalFlowImageFormatInfoNVBuilder<'a> {
71579     type Target = OpticalFlowImageFormatInfoNV;
deref(&self) -> &Self::Target71580     fn deref(&self) -> &Self::Target {
71581         &self.inner
71582     }
71583 }
71584 impl<'a> ::std::ops::DerefMut for OpticalFlowImageFormatInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target71585     fn deref_mut(&mut self) -> &mut Self::Target {
71586         &mut self.inner
71587     }
71588 }
71589 impl<'a> OpticalFlowImageFormatInfoNVBuilder<'a> {
71590     #[inline]
usage(mut self, usage: OpticalFlowUsageFlagsNV) -> Self71591     pub fn usage(mut self, usage: OpticalFlowUsageFlagsNV) -> Self {
71592         self.inner.usage = usage;
71593         self
71594     }
71595     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
71596     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
71597     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> OpticalFlowImageFormatInfoNV71598     pub fn build(self) -> OpticalFlowImageFormatInfoNV {
71599         self.inner
71600     }
71601 }
71602 #[repr(C)]
71603 #[cfg_attr(feature = "debug", derive(Debug))]
71604 #[derive(Copy, Clone)]
71605 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowImageFormatPropertiesNV.html>"]
71606 pub struct OpticalFlowImageFormatPropertiesNV {
71607     pub s_type: StructureType,
71608     pub p_next: *const c_void,
71609     pub format: Format,
71610 }
71611 impl ::std::default::Default for OpticalFlowImageFormatPropertiesNV {
71612     #[inline]
default() -> Self71613     fn default() -> Self {
71614         Self {
71615             s_type: Self::STRUCTURE_TYPE,
71616             p_next: ::std::ptr::null(),
71617             format: Format::default(),
71618         }
71619     }
71620 }
71621 unsafe impl TaggedStructure for OpticalFlowImageFormatPropertiesNV {
71622     const STRUCTURE_TYPE: StructureType = StructureType::OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV;
71623 }
71624 impl OpticalFlowImageFormatPropertiesNV {
builder<'a>() -> OpticalFlowImageFormatPropertiesNVBuilder<'a>71625     pub fn builder<'a>() -> OpticalFlowImageFormatPropertiesNVBuilder<'a> {
71626         OpticalFlowImageFormatPropertiesNVBuilder {
71627             inner: Self::default(),
71628             marker: ::std::marker::PhantomData,
71629         }
71630     }
71631 }
71632 #[repr(transparent)]
71633 pub struct OpticalFlowImageFormatPropertiesNVBuilder<'a> {
71634     inner: OpticalFlowImageFormatPropertiesNV,
71635     marker: ::std::marker::PhantomData<&'a ()>,
71636 }
71637 impl<'a> ::std::ops::Deref for OpticalFlowImageFormatPropertiesNVBuilder<'a> {
71638     type Target = OpticalFlowImageFormatPropertiesNV;
deref(&self) -> &Self::Target71639     fn deref(&self) -> &Self::Target {
71640         &self.inner
71641     }
71642 }
71643 impl<'a> ::std::ops::DerefMut for OpticalFlowImageFormatPropertiesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target71644     fn deref_mut(&mut self) -> &mut Self::Target {
71645         &mut self.inner
71646     }
71647 }
71648 impl<'a> OpticalFlowImageFormatPropertiesNVBuilder<'a> {
71649     #[inline]
format(mut self, format: Format) -> Self71650     pub fn format(mut self, format: Format) -> Self {
71651         self.inner.format = format;
71652         self
71653     }
71654     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
71655     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
71656     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> OpticalFlowImageFormatPropertiesNV71657     pub fn build(self) -> OpticalFlowImageFormatPropertiesNV {
71658         self.inner
71659     }
71660 }
71661 #[repr(C)]
71662 #[cfg_attr(feature = "debug", derive(Debug))]
71663 #[derive(Copy, Clone)]
71664 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowSessionCreateInfoNV.html>"]
71665 pub struct OpticalFlowSessionCreateInfoNV {
71666     pub s_type: StructureType,
71667     pub p_next: *mut c_void,
71668     pub width: u32,
71669     pub height: u32,
71670     pub image_format: Format,
71671     pub flow_vector_format: Format,
71672     pub cost_format: Format,
71673     pub output_grid_size: OpticalFlowGridSizeFlagsNV,
71674     pub hint_grid_size: OpticalFlowGridSizeFlagsNV,
71675     pub performance_level: OpticalFlowPerformanceLevelNV,
71676     pub flags: OpticalFlowSessionCreateFlagsNV,
71677 }
71678 impl ::std::default::Default for OpticalFlowSessionCreateInfoNV {
71679     #[inline]
default() -> Self71680     fn default() -> Self {
71681         Self {
71682             s_type: Self::STRUCTURE_TYPE,
71683             p_next: ::std::ptr::null_mut(),
71684             width: u32::default(),
71685             height: u32::default(),
71686             image_format: Format::default(),
71687             flow_vector_format: Format::default(),
71688             cost_format: Format::default(),
71689             output_grid_size: OpticalFlowGridSizeFlagsNV::default(),
71690             hint_grid_size: OpticalFlowGridSizeFlagsNV::default(),
71691             performance_level: OpticalFlowPerformanceLevelNV::default(),
71692             flags: OpticalFlowSessionCreateFlagsNV::default(),
71693         }
71694     }
71695 }
71696 unsafe impl TaggedStructure for OpticalFlowSessionCreateInfoNV {
71697     const STRUCTURE_TYPE: StructureType = StructureType::OPTICAL_FLOW_SESSION_CREATE_INFO_NV;
71698 }
71699 impl OpticalFlowSessionCreateInfoNV {
builder<'a>() -> OpticalFlowSessionCreateInfoNVBuilder<'a>71700     pub fn builder<'a>() -> OpticalFlowSessionCreateInfoNVBuilder<'a> {
71701         OpticalFlowSessionCreateInfoNVBuilder {
71702             inner: Self::default(),
71703             marker: ::std::marker::PhantomData,
71704         }
71705     }
71706 }
71707 #[repr(transparent)]
71708 pub struct OpticalFlowSessionCreateInfoNVBuilder<'a> {
71709     inner: OpticalFlowSessionCreateInfoNV,
71710     marker: ::std::marker::PhantomData<&'a ()>,
71711 }
71712 pub unsafe trait ExtendsOpticalFlowSessionCreateInfoNV {}
71713 impl<'a> ::std::ops::Deref for OpticalFlowSessionCreateInfoNVBuilder<'a> {
71714     type Target = OpticalFlowSessionCreateInfoNV;
deref(&self) -> &Self::Target71715     fn deref(&self) -> &Self::Target {
71716         &self.inner
71717     }
71718 }
71719 impl<'a> ::std::ops::DerefMut for OpticalFlowSessionCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target71720     fn deref_mut(&mut self) -> &mut Self::Target {
71721         &mut self.inner
71722     }
71723 }
71724 impl<'a> OpticalFlowSessionCreateInfoNVBuilder<'a> {
71725     #[inline]
width(mut self, width: u32) -> Self71726     pub fn width(mut self, width: u32) -> Self {
71727         self.inner.width = width;
71728         self
71729     }
71730     #[inline]
height(mut self, height: u32) -> Self71731     pub fn height(mut self, height: u32) -> Self {
71732         self.inner.height = height;
71733         self
71734     }
71735     #[inline]
image_format(mut self, image_format: Format) -> Self71736     pub fn image_format(mut self, image_format: Format) -> Self {
71737         self.inner.image_format = image_format;
71738         self
71739     }
71740     #[inline]
flow_vector_format(mut self, flow_vector_format: Format) -> Self71741     pub fn flow_vector_format(mut self, flow_vector_format: Format) -> Self {
71742         self.inner.flow_vector_format = flow_vector_format;
71743         self
71744     }
71745     #[inline]
cost_format(mut self, cost_format: Format) -> Self71746     pub fn cost_format(mut self, cost_format: Format) -> Self {
71747         self.inner.cost_format = cost_format;
71748         self
71749     }
71750     #[inline]
output_grid_size(mut self, output_grid_size: OpticalFlowGridSizeFlagsNV) -> Self71751     pub fn output_grid_size(mut self, output_grid_size: OpticalFlowGridSizeFlagsNV) -> Self {
71752         self.inner.output_grid_size = output_grid_size;
71753         self
71754     }
71755     #[inline]
hint_grid_size(mut self, hint_grid_size: OpticalFlowGridSizeFlagsNV) -> Self71756     pub fn hint_grid_size(mut self, hint_grid_size: OpticalFlowGridSizeFlagsNV) -> Self {
71757         self.inner.hint_grid_size = hint_grid_size;
71758         self
71759     }
71760     #[inline]
performance_level(mut self, performance_level: OpticalFlowPerformanceLevelNV) -> Self71761     pub fn performance_level(mut self, performance_level: OpticalFlowPerformanceLevelNV) -> Self {
71762         self.inner.performance_level = performance_level;
71763         self
71764     }
71765     #[inline]
flags(mut self, flags: OpticalFlowSessionCreateFlagsNV) -> Self71766     pub fn flags(mut self, flags: OpticalFlowSessionCreateFlagsNV) -> Self {
71767         self.inner.flags = flags;
71768         self
71769     }
71770     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
71771     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
71772     #[doc = r" valid extension structs can be pushed into the chain."]
71773     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
71774     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsOpticalFlowSessionCreateInfoNV>(mut self, next: &'a mut T) -> Self71775     pub fn push_next<T: ExtendsOpticalFlowSessionCreateInfoNV>(mut self, next: &'a mut T) -> Self {
71776         unsafe {
71777             let next_ptr = <*mut T>::cast(next);
71778             let last_next = ptr_chain_iter(next).last().unwrap();
71779             (*last_next).p_next = self.inner.p_next as _;
71780             self.inner.p_next = next_ptr;
71781         }
71782         self
71783     }
71784     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
71785     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
71786     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> OpticalFlowSessionCreateInfoNV71787     pub fn build(self) -> OpticalFlowSessionCreateInfoNV {
71788         self.inner
71789     }
71790 }
71791 #[repr(C)]
71792 #[cfg_attr(feature = "debug", derive(Debug))]
71793 #[derive(Copy, Clone)]
71794 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowSessionCreatePrivateDataInfoNV.html>"]
71795 pub struct OpticalFlowSessionCreatePrivateDataInfoNV {
71796     pub s_type: StructureType,
71797     pub p_next: *mut c_void,
71798     pub id: u32,
71799     pub size: u32,
71800     pub p_private_data: *const c_void,
71801 }
71802 impl ::std::default::Default for OpticalFlowSessionCreatePrivateDataInfoNV {
71803     #[inline]
default() -> Self71804     fn default() -> Self {
71805         Self {
71806             s_type: Self::STRUCTURE_TYPE,
71807             p_next: ::std::ptr::null_mut(),
71808             id: u32::default(),
71809             size: u32::default(),
71810             p_private_data: ::std::ptr::null(),
71811         }
71812     }
71813 }
71814 unsafe impl TaggedStructure for OpticalFlowSessionCreatePrivateDataInfoNV {
71815     const STRUCTURE_TYPE: StructureType =
71816         StructureType::OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV;
71817 }
71818 impl OpticalFlowSessionCreatePrivateDataInfoNV {
builder<'a>() -> OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'a>71819     pub fn builder<'a>() -> OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'a> {
71820         OpticalFlowSessionCreatePrivateDataInfoNVBuilder {
71821             inner: Self::default(),
71822             marker: ::std::marker::PhantomData,
71823         }
71824     }
71825 }
71826 #[repr(transparent)]
71827 pub struct OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'a> {
71828     inner: OpticalFlowSessionCreatePrivateDataInfoNV,
71829     marker: ::std::marker::PhantomData<&'a ()>,
71830 }
71831 unsafe impl ExtendsOpticalFlowSessionCreateInfoNV
71832     for OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'_>
71833 {
71834 }
71835 unsafe impl ExtendsOpticalFlowSessionCreateInfoNV for OpticalFlowSessionCreatePrivateDataInfoNV {}
71836 impl<'a> ::std::ops::Deref for OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'a> {
71837     type Target = OpticalFlowSessionCreatePrivateDataInfoNV;
deref(&self) -> &Self::Target71838     fn deref(&self) -> &Self::Target {
71839         &self.inner
71840     }
71841 }
71842 impl<'a> ::std::ops::DerefMut for OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target71843     fn deref_mut(&mut self) -> &mut Self::Target {
71844         &mut self.inner
71845     }
71846 }
71847 impl<'a> OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'a> {
71848     #[inline]
id(mut self, id: u32) -> Self71849     pub fn id(mut self, id: u32) -> Self {
71850         self.inner.id = id;
71851         self
71852     }
71853     #[inline]
size(mut self, size: u32) -> Self71854     pub fn size(mut self, size: u32) -> Self {
71855         self.inner.size = size;
71856         self
71857     }
71858     #[inline]
private_data(mut self, private_data: *const c_void) -> Self71859     pub fn private_data(mut self, private_data: *const c_void) -> Self {
71860         self.inner.p_private_data = private_data;
71861         self
71862     }
71863     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
71864     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
71865     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> OpticalFlowSessionCreatePrivateDataInfoNV71866     pub fn build(self) -> OpticalFlowSessionCreatePrivateDataInfoNV {
71867         self.inner
71868     }
71869 }
71870 #[repr(C)]
71871 #[cfg_attr(feature = "debug", derive(Debug))]
71872 #[derive(Copy, Clone)]
71873 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowExecuteInfoNV.html>"]
71874 pub struct OpticalFlowExecuteInfoNV {
71875     pub s_type: StructureType,
71876     pub p_next: *mut c_void,
71877     pub flags: OpticalFlowExecuteFlagsNV,
71878     pub region_count: u32,
71879     pub p_regions: *const Rect2D,
71880 }
71881 impl ::std::default::Default for OpticalFlowExecuteInfoNV {
71882     #[inline]
default() -> Self71883     fn default() -> Self {
71884         Self {
71885             s_type: Self::STRUCTURE_TYPE,
71886             p_next: ::std::ptr::null_mut(),
71887             flags: OpticalFlowExecuteFlagsNV::default(),
71888             region_count: u32::default(),
71889             p_regions: ::std::ptr::null(),
71890         }
71891     }
71892 }
71893 unsafe impl TaggedStructure for OpticalFlowExecuteInfoNV {
71894     const STRUCTURE_TYPE: StructureType = StructureType::OPTICAL_FLOW_EXECUTE_INFO_NV;
71895 }
71896 impl OpticalFlowExecuteInfoNV {
builder<'a>() -> OpticalFlowExecuteInfoNVBuilder<'a>71897     pub fn builder<'a>() -> OpticalFlowExecuteInfoNVBuilder<'a> {
71898         OpticalFlowExecuteInfoNVBuilder {
71899             inner: Self::default(),
71900             marker: ::std::marker::PhantomData,
71901         }
71902     }
71903 }
71904 #[repr(transparent)]
71905 pub struct OpticalFlowExecuteInfoNVBuilder<'a> {
71906     inner: OpticalFlowExecuteInfoNV,
71907     marker: ::std::marker::PhantomData<&'a ()>,
71908 }
71909 impl<'a> ::std::ops::Deref for OpticalFlowExecuteInfoNVBuilder<'a> {
71910     type Target = OpticalFlowExecuteInfoNV;
deref(&self) -> &Self::Target71911     fn deref(&self) -> &Self::Target {
71912         &self.inner
71913     }
71914 }
71915 impl<'a> ::std::ops::DerefMut for OpticalFlowExecuteInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target71916     fn deref_mut(&mut self) -> &mut Self::Target {
71917         &mut self.inner
71918     }
71919 }
71920 impl<'a> OpticalFlowExecuteInfoNVBuilder<'a> {
71921     #[inline]
flags(mut self, flags: OpticalFlowExecuteFlagsNV) -> Self71922     pub fn flags(mut self, flags: OpticalFlowExecuteFlagsNV) -> Self {
71923         self.inner.flags = flags;
71924         self
71925     }
71926     #[inline]
regions(mut self, regions: &'a [Rect2D]) -> Self71927     pub fn regions(mut self, regions: &'a [Rect2D]) -> Self {
71928         self.inner.region_count = regions.len() as _;
71929         self.inner.p_regions = regions.as_ptr();
71930         self
71931     }
71932     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
71933     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
71934     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> OpticalFlowExecuteInfoNV71935     pub fn build(self) -> OpticalFlowExecuteInfoNV {
71936         self.inner
71937     }
71938 }
71939 #[repr(C)]
71940 #[cfg_attr(feature = "debug", derive(Debug))]
71941 #[derive(Copy, Clone)]
71942 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFaultFeaturesEXT.html>"]
71943 pub struct PhysicalDeviceFaultFeaturesEXT {
71944     pub s_type: StructureType,
71945     pub p_next: *mut c_void,
71946     pub device_fault: Bool32,
71947     pub device_fault_vendor_binary: Bool32,
71948 }
71949 impl ::std::default::Default for PhysicalDeviceFaultFeaturesEXT {
71950     #[inline]
default() -> Self71951     fn default() -> Self {
71952         Self {
71953             s_type: Self::STRUCTURE_TYPE,
71954             p_next: ::std::ptr::null_mut(),
71955             device_fault: Bool32::default(),
71956             device_fault_vendor_binary: Bool32::default(),
71957         }
71958     }
71959 }
71960 unsafe impl TaggedStructure for PhysicalDeviceFaultFeaturesEXT {
71961     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
71962 }
71963 impl PhysicalDeviceFaultFeaturesEXT {
builder<'a>() -> PhysicalDeviceFaultFeaturesEXTBuilder<'a>71964     pub fn builder<'a>() -> PhysicalDeviceFaultFeaturesEXTBuilder<'a> {
71965         PhysicalDeviceFaultFeaturesEXTBuilder {
71966             inner: Self::default(),
71967             marker: ::std::marker::PhantomData,
71968         }
71969     }
71970 }
71971 #[repr(transparent)]
71972 pub struct PhysicalDeviceFaultFeaturesEXTBuilder<'a> {
71973     inner: PhysicalDeviceFaultFeaturesEXT,
71974     marker: ::std::marker::PhantomData<&'a ()>,
71975 }
71976 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFaultFeaturesEXTBuilder<'_> {}
71977 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFaultFeaturesEXT {}
71978 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFaultFeaturesEXTBuilder<'_> {}
71979 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFaultFeaturesEXT {}
71980 impl<'a> ::std::ops::Deref for PhysicalDeviceFaultFeaturesEXTBuilder<'a> {
71981     type Target = PhysicalDeviceFaultFeaturesEXT;
deref(&self) -> &Self::Target71982     fn deref(&self) -> &Self::Target {
71983         &self.inner
71984     }
71985 }
71986 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFaultFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target71987     fn deref_mut(&mut self) -> &mut Self::Target {
71988         &mut self.inner
71989     }
71990 }
71991 impl<'a> PhysicalDeviceFaultFeaturesEXTBuilder<'a> {
71992     #[inline]
device_fault(mut self, device_fault: bool) -> Self71993     pub fn device_fault(mut self, device_fault: bool) -> Self {
71994         self.inner.device_fault = device_fault.into();
71995         self
71996     }
71997     #[inline]
device_fault_vendor_binary(mut self, device_fault_vendor_binary: bool) -> Self71998     pub fn device_fault_vendor_binary(mut self, device_fault_vendor_binary: bool) -> Self {
71999         self.inner.device_fault_vendor_binary = device_fault_vendor_binary.into();
72000         self
72001     }
72002     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
72003     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
72004     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFaultFeaturesEXT72005     pub fn build(self) -> PhysicalDeviceFaultFeaturesEXT {
72006         self.inner
72007     }
72008 }
72009 #[repr(C)]
72010 #[cfg_attr(feature = "debug", derive(Debug))]
72011 #[derive(Copy, Clone, Default)]
72012 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceFaultAddressInfoEXT.html>"]
72013 pub struct DeviceFaultAddressInfoEXT {
72014     pub address_type: DeviceFaultAddressTypeEXT,
72015     pub reported_address: DeviceAddress,
72016     pub address_precision: DeviceSize,
72017 }
72018 impl DeviceFaultAddressInfoEXT {
builder<'a>() -> DeviceFaultAddressInfoEXTBuilder<'a>72019     pub fn builder<'a>() -> DeviceFaultAddressInfoEXTBuilder<'a> {
72020         DeviceFaultAddressInfoEXTBuilder {
72021             inner: Self::default(),
72022             marker: ::std::marker::PhantomData,
72023         }
72024     }
72025 }
72026 #[repr(transparent)]
72027 pub struct DeviceFaultAddressInfoEXTBuilder<'a> {
72028     inner: DeviceFaultAddressInfoEXT,
72029     marker: ::std::marker::PhantomData<&'a ()>,
72030 }
72031 impl<'a> ::std::ops::Deref for DeviceFaultAddressInfoEXTBuilder<'a> {
72032     type Target = DeviceFaultAddressInfoEXT;
deref(&self) -> &Self::Target72033     fn deref(&self) -> &Self::Target {
72034         &self.inner
72035     }
72036 }
72037 impl<'a> ::std::ops::DerefMut for DeviceFaultAddressInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target72038     fn deref_mut(&mut self) -> &mut Self::Target {
72039         &mut self.inner
72040     }
72041 }
72042 impl<'a> DeviceFaultAddressInfoEXTBuilder<'a> {
72043     #[inline]
address_type(mut self, address_type: DeviceFaultAddressTypeEXT) -> Self72044     pub fn address_type(mut self, address_type: DeviceFaultAddressTypeEXT) -> Self {
72045         self.inner.address_type = address_type;
72046         self
72047     }
72048     #[inline]
reported_address(mut self, reported_address: DeviceAddress) -> Self72049     pub fn reported_address(mut self, reported_address: DeviceAddress) -> Self {
72050         self.inner.reported_address = reported_address;
72051         self
72052     }
72053     #[inline]
address_precision(mut self, address_precision: DeviceSize) -> Self72054     pub fn address_precision(mut self, address_precision: DeviceSize) -> Self {
72055         self.inner.address_precision = address_precision;
72056         self
72057     }
72058     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
72059     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
72060     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceFaultAddressInfoEXT72061     pub fn build(self) -> DeviceFaultAddressInfoEXT {
72062         self.inner
72063     }
72064 }
72065 #[repr(C)]
72066 #[derive(Copy, Clone)]
72067 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceFaultVendorInfoEXT.html>"]
72068 pub struct DeviceFaultVendorInfoEXT {
72069     pub description: [c_char; MAX_DESCRIPTION_SIZE],
72070     pub vendor_fault_code: u64,
72071     pub vendor_fault_data: u64,
72072 }
72073 #[cfg(feature = "debug")]
72074 impl fmt::Debug for DeviceFaultVendorInfoEXT {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result72075     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
72076         fmt.debug_struct("DeviceFaultVendorInfoEXT")
72077             .field("description", &unsafe {
72078                 ::std::ffi::CStr::from_ptr(self.description.as_ptr())
72079             })
72080             .field("vendor_fault_code", &self.vendor_fault_code)
72081             .field("vendor_fault_data", &self.vendor_fault_data)
72082             .finish()
72083     }
72084 }
72085 impl ::std::default::Default for DeviceFaultVendorInfoEXT {
72086     #[inline]
default() -> Self72087     fn default() -> Self {
72088         Self {
72089             description: unsafe { ::std::mem::zeroed() },
72090             vendor_fault_code: u64::default(),
72091             vendor_fault_data: u64::default(),
72092         }
72093     }
72094 }
72095 impl DeviceFaultVendorInfoEXT {
builder<'a>() -> DeviceFaultVendorInfoEXTBuilder<'a>72096     pub fn builder<'a>() -> DeviceFaultVendorInfoEXTBuilder<'a> {
72097         DeviceFaultVendorInfoEXTBuilder {
72098             inner: Self::default(),
72099             marker: ::std::marker::PhantomData,
72100         }
72101     }
72102 }
72103 #[repr(transparent)]
72104 pub struct DeviceFaultVendorInfoEXTBuilder<'a> {
72105     inner: DeviceFaultVendorInfoEXT,
72106     marker: ::std::marker::PhantomData<&'a ()>,
72107 }
72108 impl<'a> ::std::ops::Deref for DeviceFaultVendorInfoEXTBuilder<'a> {
72109     type Target = DeviceFaultVendorInfoEXT;
deref(&self) -> &Self::Target72110     fn deref(&self) -> &Self::Target {
72111         &self.inner
72112     }
72113 }
72114 impl<'a> ::std::ops::DerefMut for DeviceFaultVendorInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target72115     fn deref_mut(&mut self) -> &mut Self::Target {
72116         &mut self.inner
72117     }
72118 }
72119 impl<'a> DeviceFaultVendorInfoEXTBuilder<'a> {
72120     #[inline]
description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self72121     pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
72122         self.inner.description = description;
72123         self
72124     }
72125     #[inline]
vendor_fault_code(mut self, vendor_fault_code: u64) -> Self72126     pub fn vendor_fault_code(mut self, vendor_fault_code: u64) -> Self {
72127         self.inner.vendor_fault_code = vendor_fault_code;
72128         self
72129     }
72130     #[inline]
vendor_fault_data(mut self, vendor_fault_data: u64) -> Self72131     pub fn vendor_fault_data(mut self, vendor_fault_data: u64) -> Self {
72132         self.inner.vendor_fault_data = vendor_fault_data;
72133         self
72134     }
72135     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
72136     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
72137     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceFaultVendorInfoEXT72138     pub fn build(self) -> DeviceFaultVendorInfoEXT {
72139         self.inner
72140     }
72141 }
72142 #[repr(C)]
72143 #[cfg_attr(feature = "debug", derive(Debug))]
72144 #[derive(Copy, Clone)]
72145 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceFaultCountsEXT.html>"]
72146 pub struct DeviceFaultCountsEXT {
72147     pub s_type: StructureType,
72148     pub p_next: *mut c_void,
72149     pub address_info_count: u32,
72150     pub vendor_info_count: u32,
72151     pub vendor_binary_size: DeviceSize,
72152 }
72153 impl ::std::default::Default for DeviceFaultCountsEXT {
72154     #[inline]
default() -> Self72155     fn default() -> Self {
72156         Self {
72157             s_type: Self::STRUCTURE_TYPE,
72158             p_next: ::std::ptr::null_mut(),
72159             address_info_count: u32::default(),
72160             vendor_info_count: u32::default(),
72161             vendor_binary_size: DeviceSize::default(),
72162         }
72163     }
72164 }
72165 unsafe impl TaggedStructure for DeviceFaultCountsEXT {
72166     const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_FAULT_COUNTS_EXT;
72167 }
72168 impl DeviceFaultCountsEXT {
builder<'a>() -> DeviceFaultCountsEXTBuilder<'a>72169     pub fn builder<'a>() -> DeviceFaultCountsEXTBuilder<'a> {
72170         DeviceFaultCountsEXTBuilder {
72171             inner: Self::default(),
72172             marker: ::std::marker::PhantomData,
72173         }
72174     }
72175 }
72176 #[repr(transparent)]
72177 pub struct DeviceFaultCountsEXTBuilder<'a> {
72178     inner: DeviceFaultCountsEXT,
72179     marker: ::std::marker::PhantomData<&'a ()>,
72180 }
72181 impl<'a> ::std::ops::Deref for DeviceFaultCountsEXTBuilder<'a> {
72182     type Target = DeviceFaultCountsEXT;
deref(&self) -> &Self::Target72183     fn deref(&self) -> &Self::Target {
72184         &self.inner
72185     }
72186 }
72187 impl<'a> ::std::ops::DerefMut for DeviceFaultCountsEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target72188     fn deref_mut(&mut self) -> &mut Self::Target {
72189         &mut self.inner
72190     }
72191 }
72192 impl<'a> DeviceFaultCountsEXTBuilder<'a> {
72193     #[inline]
address_info_count(mut self, address_info_count: u32) -> Self72194     pub fn address_info_count(mut self, address_info_count: u32) -> Self {
72195         self.inner.address_info_count = address_info_count;
72196         self
72197     }
72198     #[inline]
vendor_info_count(mut self, vendor_info_count: u32) -> Self72199     pub fn vendor_info_count(mut self, vendor_info_count: u32) -> Self {
72200         self.inner.vendor_info_count = vendor_info_count;
72201         self
72202     }
72203     #[inline]
vendor_binary_size(mut self, vendor_binary_size: DeviceSize) -> Self72204     pub fn vendor_binary_size(mut self, vendor_binary_size: DeviceSize) -> Self {
72205         self.inner.vendor_binary_size = vendor_binary_size;
72206         self
72207     }
72208     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
72209     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
72210     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceFaultCountsEXT72211     pub fn build(self) -> DeviceFaultCountsEXT {
72212         self.inner
72213     }
72214 }
72215 #[repr(C)]
72216 #[derive(Copy, Clone)]
72217 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceFaultInfoEXT.html>"]
72218 pub struct DeviceFaultInfoEXT {
72219     pub s_type: StructureType,
72220     pub p_next: *mut c_void,
72221     pub description: [c_char; MAX_DESCRIPTION_SIZE],
72222     pub p_address_infos: *mut DeviceFaultAddressInfoEXT,
72223     pub p_vendor_infos: *mut DeviceFaultVendorInfoEXT,
72224     pub p_vendor_binary_data: *mut c_void,
72225 }
72226 #[cfg(feature = "debug")]
72227 impl fmt::Debug for DeviceFaultInfoEXT {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result72228     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
72229         fmt.debug_struct("DeviceFaultInfoEXT")
72230             .field("s_type", &self.s_type)
72231             .field("p_next", &self.p_next)
72232             .field("description", &unsafe {
72233                 ::std::ffi::CStr::from_ptr(self.description.as_ptr())
72234             })
72235             .field("p_address_infos", &self.p_address_infos)
72236             .field("p_vendor_infos", &self.p_vendor_infos)
72237             .field("p_vendor_binary_data", &self.p_vendor_binary_data)
72238             .finish()
72239     }
72240 }
72241 impl ::std::default::Default for DeviceFaultInfoEXT {
72242     #[inline]
default() -> Self72243     fn default() -> Self {
72244         Self {
72245             s_type: Self::STRUCTURE_TYPE,
72246             p_next: ::std::ptr::null_mut(),
72247             description: unsafe { ::std::mem::zeroed() },
72248             p_address_infos: ::std::ptr::null_mut(),
72249             p_vendor_infos: ::std::ptr::null_mut(),
72250             p_vendor_binary_data: ::std::ptr::null_mut(),
72251         }
72252     }
72253 }
72254 unsafe impl TaggedStructure for DeviceFaultInfoEXT {
72255     const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_FAULT_INFO_EXT;
72256 }
72257 impl DeviceFaultInfoEXT {
builder<'a>() -> DeviceFaultInfoEXTBuilder<'a>72258     pub fn builder<'a>() -> DeviceFaultInfoEXTBuilder<'a> {
72259         DeviceFaultInfoEXTBuilder {
72260             inner: Self::default(),
72261             marker: ::std::marker::PhantomData,
72262         }
72263     }
72264 }
72265 #[repr(transparent)]
72266 pub struct DeviceFaultInfoEXTBuilder<'a> {
72267     inner: DeviceFaultInfoEXT,
72268     marker: ::std::marker::PhantomData<&'a ()>,
72269 }
72270 impl<'a> ::std::ops::Deref for DeviceFaultInfoEXTBuilder<'a> {
72271     type Target = DeviceFaultInfoEXT;
deref(&self) -> &Self::Target72272     fn deref(&self) -> &Self::Target {
72273         &self.inner
72274     }
72275 }
72276 impl<'a> ::std::ops::DerefMut for DeviceFaultInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target72277     fn deref_mut(&mut self) -> &mut Self::Target {
72278         &mut self.inner
72279     }
72280 }
72281 impl<'a> DeviceFaultInfoEXTBuilder<'a> {
72282     #[inline]
description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self72283     pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
72284         self.inner.description = description;
72285         self
72286     }
72287     #[inline]
address_infos(mut self, address_infos: &'a mut DeviceFaultAddressInfoEXT) -> Self72288     pub fn address_infos(mut self, address_infos: &'a mut DeviceFaultAddressInfoEXT) -> Self {
72289         self.inner.p_address_infos = address_infos;
72290         self
72291     }
72292     #[inline]
vendor_infos(mut self, vendor_infos: &'a mut DeviceFaultVendorInfoEXT) -> Self72293     pub fn vendor_infos(mut self, vendor_infos: &'a mut DeviceFaultVendorInfoEXT) -> Self {
72294         self.inner.p_vendor_infos = vendor_infos;
72295         self
72296     }
72297     #[inline]
vendor_binary_data(mut self, vendor_binary_data: *mut c_void) -> Self72298     pub fn vendor_binary_data(mut self, vendor_binary_data: *mut c_void) -> Self {
72299         self.inner.p_vendor_binary_data = vendor_binary_data;
72300         self
72301     }
72302     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
72303     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
72304     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceFaultInfoEXT72305     pub fn build(self) -> DeviceFaultInfoEXT {
72306         self.inner
72307     }
72308 }
72309 #[repr(C)]
72310 #[cfg_attr(feature = "debug", derive(Debug))]
72311 #[derive(Copy, Clone)]
72312 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceFaultVendorBinaryHeaderVersionOneEXT.html>"]
72313 pub struct DeviceFaultVendorBinaryHeaderVersionOneEXT {
72314     pub header_size: u32,
72315     pub header_version: DeviceFaultVendorBinaryHeaderVersionEXT,
72316     pub vendor_id: u32,
72317     pub device_id: u32,
72318     pub driver_version: u32,
72319     pub pipeline_cache_uuid: [u8; UUID_SIZE],
72320     pub application_name_offset: u32,
72321     pub application_version: u32,
72322     pub engine_name_offset: u32,
72323     pub engine_version: u32,
72324     pub api_version: u32,
72325 }
72326 impl ::std::default::Default for DeviceFaultVendorBinaryHeaderVersionOneEXT {
72327     #[inline]
default() -> Self72328     fn default() -> Self {
72329         Self {
72330             header_size: u32::default(),
72331             header_version: DeviceFaultVendorBinaryHeaderVersionEXT::default(),
72332             vendor_id: u32::default(),
72333             device_id: u32::default(),
72334             driver_version: u32::default(),
72335             pipeline_cache_uuid: unsafe { ::std::mem::zeroed() },
72336             application_name_offset: u32::default(),
72337             application_version: u32::default(),
72338             engine_name_offset: u32::default(),
72339             engine_version: u32::default(),
72340             api_version: u32::default(),
72341         }
72342     }
72343 }
72344 impl DeviceFaultVendorBinaryHeaderVersionOneEXT {
builder<'a>() -> DeviceFaultVendorBinaryHeaderVersionOneEXTBuilder<'a>72345     pub fn builder<'a>() -> DeviceFaultVendorBinaryHeaderVersionOneEXTBuilder<'a> {
72346         DeviceFaultVendorBinaryHeaderVersionOneEXTBuilder {
72347             inner: Self::default(),
72348             marker: ::std::marker::PhantomData,
72349         }
72350     }
72351 }
72352 #[repr(transparent)]
72353 pub struct DeviceFaultVendorBinaryHeaderVersionOneEXTBuilder<'a> {
72354     inner: DeviceFaultVendorBinaryHeaderVersionOneEXT,
72355     marker: ::std::marker::PhantomData<&'a ()>,
72356 }
72357 impl<'a> ::std::ops::Deref for DeviceFaultVendorBinaryHeaderVersionOneEXTBuilder<'a> {
72358     type Target = DeviceFaultVendorBinaryHeaderVersionOneEXT;
deref(&self) -> &Self::Target72359     fn deref(&self) -> &Self::Target {
72360         &self.inner
72361     }
72362 }
72363 impl<'a> ::std::ops::DerefMut for DeviceFaultVendorBinaryHeaderVersionOneEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target72364     fn deref_mut(&mut self) -> &mut Self::Target {
72365         &mut self.inner
72366     }
72367 }
72368 impl<'a> DeviceFaultVendorBinaryHeaderVersionOneEXTBuilder<'a> {
72369     #[inline]
header_size(mut self, header_size: u32) -> Self72370     pub fn header_size(mut self, header_size: u32) -> Self {
72371         self.inner.header_size = header_size;
72372         self
72373     }
72374     #[inline]
header_version( mut self, header_version: DeviceFaultVendorBinaryHeaderVersionEXT, ) -> Self72375     pub fn header_version(
72376         mut self,
72377         header_version: DeviceFaultVendorBinaryHeaderVersionEXT,
72378     ) -> Self {
72379         self.inner.header_version = header_version;
72380         self
72381     }
72382     #[inline]
vendor_id(mut self, vendor_id: u32) -> Self72383     pub fn vendor_id(mut self, vendor_id: u32) -> Self {
72384         self.inner.vendor_id = vendor_id;
72385         self
72386     }
72387     #[inline]
device_id(mut self, device_id: u32) -> Self72388     pub fn device_id(mut self, device_id: u32) -> Self {
72389         self.inner.device_id = device_id;
72390         self
72391     }
72392     #[inline]
driver_version(mut self, driver_version: u32) -> Self72393     pub fn driver_version(mut self, driver_version: u32) -> Self {
72394         self.inner.driver_version = driver_version;
72395         self
72396     }
72397     #[inline]
pipeline_cache_uuid(mut self, pipeline_cache_uuid: [u8; UUID_SIZE]) -> Self72398     pub fn pipeline_cache_uuid(mut self, pipeline_cache_uuid: [u8; UUID_SIZE]) -> Self {
72399         self.inner.pipeline_cache_uuid = pipeline_cache_uuid;
72400         self
72401     }
72402     #[inline]
application_name_offset(mut self, application_name_offset: u32) -> Self72403     pub fn application_name_offset(mut self, application_name_offset: u32) -> Self {
72404         self.inner.application_name_offset = application_name_offset;
72405         self
72406     }
72407     #[inline]
application_version(mut self, application_version: u32) -> Self72408     pub fn application_version(mut self, application_version: u32) -> Self {
72409         self.inner.application_version = application_version;
72410         self
72411     }
72412     #[inline]
engine_name_offset(mut self, engine_name_offset: u32) -> Self72413     pub fn engine_name_offset(mut self, engine_name_offset: u32) -> Self {
72414         self.inner.engine_name_offset = engine_name_offset;
72415         self
72416     }
72417     #[inline]
engine_version(mut self, engine_version: u32) -> Self72418     pub fn engine_version(mut self, engine_version: u32) -> Self {
72419         self.inner.engine_version = engine_version;
72420         self
72421     }
72422     #[inline]
api_version(mut self, api_version: u32) -> Self72423     pub fn api_version(mut self, api_version: u32) -> Self {
72424         self.inner.api_version = api_version;
72425         self
72426     }
72427     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
72428     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
72429     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceFaultVendorBinaryHeaderVersionOneEXT72430     pub fn build(self) -> DeviceFaultVendorBinaryHeaderVersionOneEXT {
72431         self.inner
72432     }
72433 }
72434 #[repr(C)]
72435 #[cfg_attr(feature = "debug", derive(Debug))]
72436 #[derive(Copy, Clone)]
72437 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT.html>"]
72438 pub struct PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT {
72439     pub s_type: StructureType,
72440     pub p_next: *mut c_void,
72441     pub pipeline_library_group_handles: Bool32,
72442 }
72443 impl ::std::default::Default for PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT {
72444     #[inline]
default() -> Self72445     fn default() -> Self {
72446         Self {
72447             s_type: Self::STRUCTURE_TYPE,
72448             p_next: ::std::ptr::null_mut(),
72449             pipeline_library_group_handles: Bool32::default(),
72450         }
72451     }
72452 }
72453 unsafe impl TaggedStructure for PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT {
72454     const STRUCTURE_TYPE: StructureType =
72455         StructureType::PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT;
72456 }
72457 impl PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT {
builder<'a>() -> PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXTBuilder<'a>72458     pub fn builder<'a>() -> PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXTBuilder<'a> {
72459         PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXTBuilder {
72460             inner: Self::default(),
72461             marker: ::std::marker::PhantomData,
72462         }
72463     }
72464 }
72465 #[repr(transparent)]
72466 pub struct PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXTBuilder<'a> {
72467     inner: PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT,
72468     marker: ::std::marker::PhantomData<&'a ()>,
72469 }
72470 unsafe impl ExtendsPhysicalDeviceFeatures2
72471     for PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXTBuilder<'_>
72472 {
72473 }
72474 unsafe impl ExtendsPhysicalDeviceFeatures2
72475     for PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT
72476 {
72477 }
72478 unsafe impl ExtendsDeviceCreateInfo
72479     for PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXTBuilder<'_>
72480 {
72481 }
72482 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT {}
72483 impl<'a> ::std::ops::Deref for PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXTBuilder<'a> {
72484     type Target = PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT;
deref(&self) -> &Self::Target72485     fn deref(&self) -> &Self::Target {
72486         &self.inner
72487     }
72488 }
72489 impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target72490     fn deref_mut(&mut self) -> &mut Self::Target {
72491         &mut self.inner
72492     }
72493 }
72494 impl<'a> PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXTBuilder<'a> {
72495     #[inline]
pipeline_library_group_handles(mut self, pipeline_library_group_handles: bool) -> Self72496     pub fn pipeline_library_group_handles(mut self, pipeline_library_group_handles: bool) -> Self {
72497         self.inner.pipeline_library_group_handles = pipeline_library_group_handles.into();
72498         self
72499     }
72500     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
72501     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
72502     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT72503     pub fn build(self) -> PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT {
72504         self.inner
72505     }
72506 }
72507 #[repr(C)]
72508 #[cfg_attr(feature = "debug", derive(Debug))]
72509 #[derive(Copy, Clone, Default)]
72510 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDecompressMemoryRegionNV.html>"]
72511 pub struct DecompressMemoryRegionNV {
72512     pub src_address: DeviceAddress,
72513     pub dst_address: DeviceAddress,
72514     pub compressed_size: DeviceSize,
72515     pub decompressed_size: DeviceSize,
72516     pub decompression_method: MemoryDecompressionMethodFlagsNV,
72517 }
72518 impl DecompressMemoryRegionNV {
builder<'a>() -> DecompressMemoryRegionNVBuilder<'a>72519     pub fn builder<'a>() -> DecompressMemoryRegionNVBuilder<'a> {
72520         DecompressMemoryRegionNVBuilder {
72521             inner: Self::default(),
72522             marker: ::std::marker::PhantomData,
72523         }
72524     }
72525 }
72526 #[repr(transparent)]
72527 pub struct DecompressMemoryRegionNVBuilder<'a> {
72528     inner: DecompressMemoryRegionNV,
72529     marker: ::std::marker::PhantomData<&'a ()>,
72530 }
72531 impl<'a> ::std::ops::Deref for DecompressMemoryRegionNVBuilder<'a> {
72532     type Target = DecompressMemoryRegionNV;
deref(&self) -> &Self::Target72533     fn deref(&self) -> &Self::Target {
72534         &self.inner
72535     }
72536 }
72537 impl<'a> ::std::ops::DerefMut for DecompressMemoryRegionNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target72538     fn deref_mut(&mut self) -> &mut Self::Target {
72539         &mut self.inner
72540     }
72541 }
72542 impl<'a> DecompressMemoryRegionNVBuilder<'a> {
72543     #[inline]
src_address(mut self, src_address: DeviceAddress) -> Self72544     pub fn src_address(mut self, src_address: DeviceAddress) -> Self {
72545         self.inner.src_address = src_address;
72546         self
72547     }
72548     #[inline]
dst_address(mut self, dst_address: DeviceAddress) -> Self72549     pub fn dst_address(mut self, dst_address: DeviceAddress) -> Self {
72550         self.inner.dst_address = dst_address;
72551         self
72552     }
72553     #[inline]
compressed_size(mut self, compressed_size: DeviceSize) -> Self72554     pub fn compressed_size(mut self, compressed_size: DeviceSize) -> Self {
72555         self.inner.compressed_size = compressed_size;
72556         self
72557     }
72558     #[inline]
decompressed_size(mut self, decompressed_size: DeviceSize) -> Self72559     pub fn decompressed_size(mut self, decompressed_size: DeviceSize) -> Self {
72560         self.inner.decompressed_size = decompressed_size;
72561         self
72562     }
72563     #[inline]
decompression_method( mut self, decompression_method: MemoryDecompressionMethodFlagsNV, ) -> Self72564     pub fn decompression_method(
72565         mut self,
72566         decompression_method: MemoryDecompressionMethodFlagsNV,
72567     ) -> Self {
72568         self.inner.decompression_method = decompression_method;
72569         self
72570     }
72571     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
72572     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
72573     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DecompressMemoryRegionNV72574     pub fn build(self) -> DecompressMemoryRegionNV {
72575         self.inner
72576     }
72577 }
72578 #[repr(C)]
72579 #[cfg_attr(feature = "debug", derive(Debug))]
72580 #[derive(Copy, Clone)]
72581 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM.html>"]
72582 pub struct PhysicalDeviceShaderCoreBuiltinsPropertiesARM {
72583     pub s_type: StructureType,
72584     pub p_next: *mut c_void,
72585     pub shader_core_mask: u64,
72586     pub shader_core_count: u32,
72587     pub shader_warps_per_core: u32,
72588 }
72589 impl ::std::default::Default for PhysicalDeviceShaderCoreBuiltinsPropertiesARM {
72590     #[inline]
default() -> Self72591     fn default() -> Self {
72592         Self {
72593             s_type: Self::STRUCTURE_TYPE,
72594             p_next: ::std::ptr::null_mut(),
72595             shader_core_mask: u64::default(),
72596             shader_core_count: u32::default(),
72597             shader_warps_per_core: u32::default(),
72598         }
72599     }
72600 }
72601 unsafe impl TaggedStructure for PhysicalDeviceShaderCoreBuiltinsPropertiesARM {
72602     const STRUCTURE_TYPE: StructureType =
72603         StructureType::PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM;
72604 }
72605 impl PhysicalDeviceShaderCoreBuiltinsPropertiesARM {
builder<'a>() -> PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'a>72606     pub fn builder<'a>() -> PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'a> {
72607         PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder {
72608             inner: Self::default(),
72609             marker: ::std::marker::PhantomData,
72610         }
72611     }
72612 }
72613 #[repr(transparent)]
72614 pub struct PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'a> {
72615     inner: PhysicalDeviceShaderCoreBuiltinsPropertiesARM,
72616     marker: ::std::marker::PhantomData<&'a ()>,
72617 }
72618 unsafe impl ExtendsPhysicalDeviceProperties2
72619     for PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'_>
72620 {
72621 }
72622 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCoreBuiltinsPropertiesARM {}
72623 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'a> {
72624     type Target = PhysicalDeviceShaderCoreBuiltinsPropertiesARM;
deref(&self) -> &Self::Target72625     fn deref(&self) -> &Self::Target {
72626         &self.inner
72627     }
72628 }
72629 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target72630     fn deref_mut(&mut self) -> &mut Self::Target {
72631         &mut self.inner
72632     }
72633 }
72634 impl<'a> PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'a> {
72635     #[inline]
shader_core_mask(mut self, shader_core_mask: u64) -> Self72636     pub fn shader_core_mask(mut self, shader_core_mask: u64) -> Self {
72637         self.inner.shader_core_mask = shader_core_mask;
72638         self
72639     }
72640     #[inline]
shader_core_count(mut self, shader_core_count: u32) -> Self72641     pub fn shader_core_count(mut self, shader_core_count: u32) -> Self {
72642         self.inner.shader_core_count = shader_core_count;
72643         self
72644     }
72645     #[inline]
shader_warps_per_core(mut self, shader_warps_per_core: u32) -> Self72646     pub fn shader_warps_per_core(mut self, shader_warps_per_core: u32) -> Self {
72647         self.inner.shader_warps_per_core = shader_warps_per_core;
72648         self
72649     }
72650     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
72651     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
72652     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderCoreBuiltinsPropertiesARM72653     pub fn build(self) -> PhysicalDeviceShaderCoreBuiltinsPropertiesARM {
72654         self.inner
72655     }
72656 }
72657 #[repr(C)]
72658 #[cfg_attr(feature = "debug", derive(Debug))]
72659 #[derive(Copy, Clone)]
72660 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM.html>"]
72661 pub struct PhysicalDeviceShaderCoreBuiltinsFeaturesARM {
72662     pub s_type: StructureType,
72663     pub p_next: *mut c_void,
72664     pub shader_core_builtins: Bool32,
72665 }
72666 impl ::std::default::Default for PhysicalDeviceShaderCoreBuiltinsFeaturesARM {
72667     #[inline]
default() -> Self72668     fn default() -> Self {
72669         Self {
72670             s_type: Self::STRUCTURE_TYPE,
72671             p_next: ::std::ptr::null_mut(),
72672             shader_core_builtins: Bool32::default(),
72673         }
72674     }
72675 }
72676 unsafe impl TaggedStructure for PhysicalDeviceShaderCoreBuiltinsFeaturesARM {
72677     const STRUCTURE_TYPE: StructureType =
72678         StructureType::PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
72679 }
72680 impl PhysicalDeviceShaderCoreBuiltinsFeaturesARM {
builder<'a>() -> PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'a>72681     pub fn builder<'a>() -> PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'a> {
72682         PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder {
72683             inner: Self::default(),
72684             marker: ::std::marker::PhantomData,
72685         }
72686     }
72687 }
72688 #[repr(transparent)]
72689 pub struct PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'a> {
72690     inner: PhysicalDeviceShaderCoreBuiltinsFeaturesARM,
72691     marker: ::std::marker::PhantomData<&'a ()>,
72692 }
72693 unsafe impl ExtendsPhysicalDeviceFeatures2
72694     for PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'_>
72695 {
72696 }
72697 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderCoreBuiltinsFeaturesARM {}
72698 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'_> {}
72699 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderCoreBuiltinsFeaturesARM {}
72700 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'a> {
72701     type Target = PhysicalDeviceShaderCoreBuiltinsFeaturesARM;
deref(&self) -> &Self::Target72702     fn deref(&self) -> &Self::Target {
72703         &self.inner
72704     }
72705 }
72706 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target72707     fn deref_mut(&mut self) -> &mut Self::Target {
72708         &mut self.inner
72709     }
72710 }
72711 impl<'a> PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'a> {
72712     #[inline]
shader_core_builtins(mut self, shader_core_builtins: bool) -> Self72713     pub fn shader_core_builtins(mut self, shader_core_builtins: bool) -> Self {
72714         self.inner.shader_core_builtins = shader_core_builtins.into();
72715         self
72716     }
72717     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
72718     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
72719     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderCoreBuiltinsFeaturesARM72720     pub fn build(self) -> PhysicalDeviceShaderCoreBuiltinsFeaturesARM {
72721         self.inner
72722     }
72723 }
72724 #[repr(C)]
72725 #[cfg_attr(feature = "debug", derive(Debug))]
72726 #[derive(Copy, Clone)]
72727 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.html>"]
72728 pub struct PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {
72729     pub s_type: StructureType,
72730     pub p_next: *mut c_void,
72731     pub dynamic_rendering_unused_attachments: Bool32,
72732 }
72733 impl ::std::default::Default for PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {
72734     #[inline]
default() -> Self72735     fn default() -> Self {
72736         Self {
72737             s_type: Self::STRUCTURE_TYPE,
72738             p_next: ::std::ptr::null_mut(),
72739             dynamic_rendering_unused_attachments: Bool32::default(),
72740         }
72741     }
72742 }
72743 unsafe impl TaggedStructure for PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {
72744     const STRUCTURE_TYPE: StructureType =
72745         StructureType::PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT;
72746 }
72747 impl PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {
builder<'a>() -> PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXTBuilder<'a>72748     pub fn builder<'a>() -> PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXTBuilder<'a> {
72749         PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXTBuilder {
72750             inner: Self::default(),
72751             marker: ::std::marker::PhantomData,
72752         }
72753     }
72754 }
72755 #[repr(transparent)]
72756 pub struct PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXTBuilder<'a> {
72757     inner: PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT,
72758     marker: ::std::marker::PhantomData<&'a ()>,
72759 }
72760 unsafe impl ExtendsPhysicalDeviceFeatures2
72761     for PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXTBuilder<'_>
72762 {
72763 }
72764 unsafe impl ExtendsPhysicalDeviceFeatures2
72765     for PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT
72766 {
72767 }
72768 unsafe impl ExtendsDeviceCreateInfo
72769     for PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXTBuilder<'_>
72770 {
72771 }
72772 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {}
72773 impl<'a> ::std::ops::Deref
72774     for PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXTBuilder<'a>
72775 {
72776     type Target = PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT;
deref(&self) -> &Self::Target72777     fn deref(&self) -> &Self::Target {
72778         &self.inner
72779     }
72780 }
72781 impl<'a> ::std::ops::DerefMut
72782     for PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXTBuilder<'a>
72783 {
deref_mut(&mut self) -> &mut Self::Target72784     fn deref_mut(&mut self) -> &mut Self::Target {
72785         &mut self.inner
72786     }
72787 }
72788 impl<'a> PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXTBuilder<'a> {
72789     #[inline]
dynamic_rendering_unused_attachments( mut self, dynamic_rendering_unused_attachments: bool, ) -> Self72790     pub fn dynamic_rendering_unused_attachments(
72791         mut self,
72792         dynamic_rendering_unused_attachments: bool,
72793     ) -> Self {
72794         self.inner.dynamic_rendering_unused_attachments =
72795             dynamic_rendering_unused_attachments.into();
72796         self
72797     }
72798     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
72799     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
72800     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT72801     pub fn build(self) -> PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {
72802         self.inner
72803     }
72804 }
72805 #[repr(C)]
72806 #[cfg_attr(feature = "debug", derive(Debug))]
72807 #[derive(Copy, Clone)]
72808 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfacePresentModeEXT.html>"]
72809 pub struct SurfacePresentModeEXT {
72810     pub s_type: StructureType,
72811     pub p_next: *mut c_void,
72812     pub present_mode: PresentModeKHR,
72813 }
72814 impl ::std::default::Default for SurfacePresentModeEXT {
72815     #[inline]
default() -> Self72816     fn default() -> Self {
72817         Self {
72818             s_type: Self::STRUCTURE_TYPE,
72819             p_next: ::std::ptr::null_mut(),
72820             present_mode: PresentModeKHR::default(),
72821         }
72822     }
72823 }
72824 unsafe impl TaggedStructure for SurfacePresentModeEXT {
72825     const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_PRESENT_MODE_EXT;
72826 }
72827 impl SurfacePresentModeEXT {
builder<'a>() -> SurfacePresentModeEXTBuilder<'a>72828     pub fn builder<'a>() -> SurfacePresentModeEXTBuilder<'a> {
72829         SurfacePresentModeEXTBuilder {
72830             inner: Self::default(),
72831             marker: ::std::marker::PhantomData,
72832         }
72833     }
72834 }
72835 #[repr(transparent)]
72836 pub struct SurfacePresentModeEXTBuilder<'a> {
72837     inner: SurfacePresentModeEXT,
72838     marker: ::std::marker::PhantomData<&'a ()>,
72839 }
72840 unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfacePresentModeEXTBuilder<'_> {}
72841 unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfacePresentModeEXT {}
72842 impl<'a> ::std::ops::Deref for SurfacePresentModeEXTBuilder<'a> {
72843     type Target = SurfacePresentModeEXT;
deref(&self) -> &Self::Target72844     fn deref(&self) -> &Self::Target {
72845         &self.inner
72846     }
72847 }
72848 impl<'a> ::std::ops::DerefMut for SurfacePresentModeEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target72849     fn deref_mut(&mut self) -> &mut Self::Target {
72850         &mut self.inner
72851     }
72852 }
72853 impl<'a> SurfacePresentModeEXTBuilder<'a> {
72854     #[inline]
present_mode(mut self, present_mode: PresentModeKHR) -> Self72855     pub fn present_mode(mut self, present_mode: PresentModeKHR) -> Self {
72856         self.inner.present_mode = present_mode;
72857         self
72858     }
72859     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
72860     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
72861     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SurfacePresentModeEXT72862     pub fn build(self) -> SurfacePresentModeEXT {
72863         self.inner
72864     }
72865 }
72866 #[repr(C)]
72867 #[cfg_attr(feature = "debug", derive(Debug))]
72868 #[derive(Copy, Clone)]
72869 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfacePresentScalingCapabilitiesEXT.html>"]
72870 pub struct SurfacePresentScalingCapabilitiesEXT {
72871     pub s_type: StructureType,
72872     pub p_next: *mut c_void,
72873     pub supported_present_scaling: PresentScalingFlagsEXT,
72874     pub supported_present_gravity_x: PresentGravityFlagsEXT,
72875     pub supported_present_gravity_y: PresentGravityFlagsEXT,
72876     pub min_scaled_image_extent: Extent2D,
72877     pub max_scaled_image_extent: Extent2D,
72878 }
72879 impl ::std::default::Default for SurfacePresentScalingCapabilitiesEXT {
72880     #[inline]
default() -> Self72881     fn default() -> Self {
72882         Self {
72883             s_type: Self::STRUCTURE_TYPE,
72884             p_next: ::std::ptr::null_mut(),
72885             supported_present_scaling: PresentScalingFlagsEXT::default(),
72886             supported_present_gravity_x: PresentGravityFlagsEXT::default(),
72887             supported_present_gravity_y: PresentGravityFlagsEXT::default(),
72888             min_scaled_image_extent: Extent2D::default(),
72889             max_scaled_image_extent: Extent2D::default(),
72890         }
72891     }
72892 }
72893 unsafe impl TaggedStructure for SurfacePresentScalingCapabilitiesEXT {
72894     const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_PRESENT_SCALING_CAPABILITIES_EXT;
72895 }
72896 impl SurfacePresentScalingCapabilitiesEXT {
builder<'a>() -> SurfacePresentScalingCapabilitiesEXTBuilder<'a>72897     pub fn builder<'a>() -> SurfacePresentScalingCapabilitiesEXTBuilder<'a> {
72898         SurfacePresentScalingCapabilitiesEXTBuilder {
72899             inner: Self::default(),
72900             marker: ::std::marker::PhantomData,
72901         }
72902     }
72903 }
72904 #[repr(transparent)]
72905 pub struct SurfacePresentScalingCapabilitiesEXTBuilder<'a> {
72906     inner: SurfacePresentScalingCapabilitiesEXT,
72907     marker: ::std::marker::PhantomData<&'a ()>,
72908 }
72909 unsafe impl ExtendsSurfaceCapabilities2KHR for SurfacePresentScalingCapabilitiesEXTBuilder<'_> {}
72910 unsafe impl ExtendsSurfaceCapabilities2KHR for SurfacePresentScalingCapabilitiesEXT {}
72911 impl<'a> ::std::ops::Deref for SurfacePresentScalingCapabilitiesEXTBuilder<'a> {
72912     type Target = SurfacePresentScalingCapabilitiesEXT;
deref(&self) -> &Self::Target72913     fn deref(&self) -> &Self::Target {
72914         &self.inner
72915     }
72916 }
72917 impl<'a> ::std::ops::DerefMut for SurfacePresentScalingCapabilitiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target72918     fn deref_mut(&mut self) -> &mut Self::Target {
72919         &mut self.inner
72920     }
72921 }
72922 impl<'a> SurfacePresentScalingCapabilitiesEXTBuilder<'a> {
72923     #[inline]
supported_present_scaling( mut self, supported_present_scaling: PresentScalingFlagsEXT, ) -> Self72924     pub fn supported_present_scaling(
72925         mut self,
72926         supported_present_scaling: PresentScalingFlagsEXT,
72927     ) -> Self {
72928         self.inner.supported_present_scaling = supported_present_scaling;
72929         self
72930     }
72931     #[inline]
supported_present_gravity_x( mut self, supported_present_gravity_x: PresentGravityFlagsEXT, ) -> Self72932     pub fn supported_present_gravity_x(
72933         mut self,
72934         supported_present_gravity_x: PresentGravityFlagsEXT,
72935     ) -> Self {
72936         self.inner.supported_present_gravity_x = supported_present_gravity_x;
72937         self
72938     }
72939     #[inline]
supported_present_gravity_y( mut self, supported_present_gravity_y: PresentGravityFlagsEXT, ) -> Self72940     pub fn supported_present_gravity_y(
72941         mut self,
72942         supported_present_gravity_y: PresentGravityFlagsEXT,
72943     ) -> Self {
72944         self.inner.supported_present_gravity_y = supported_present_gravity_y;
72945         self
72946     }
72947     #[inline]
min_scaled_image_extent(mut self, min_scaled_image_extent: Extent2D) -> Self72948     pub fn min_scaled_image_extent(mut self, min_scaled_image_extent: Extent2D) -> Self {
72949         self.inner.min_scaled_image_extent = min_scaled_image_extent;
72950         self
72951     }
72952     #[inline]
max_scaled_image_extent(mut self, max_scaled_image_extent: Extent2D) -> Self72953     pub fn max_scaled_image_extent(mut self, max_scaled_image_extent: Extent2D) -> Self {
72954         self.inner.max_scaled_image_extent = max_scaled_image_extent;
72955         self
72956     }
72957     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
72958     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
72959     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SurfacePresentScalingCapabilitiesEXT72960     pub fn build(self) -> SurfacePresentScalingCapabilitiesEXT {
72961         self.inner
72962     }
72963 }
72964 #[repr(C)]
72965 #[cfg_attr(feature = "debug", derive(Debug))]
72966 #[derive(Copy, Clone)]
72967 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfacePresentModeCompatibilityEXT.html>"]
72968 pub struct SurfacePresentModeCompatibilityEXT {
72969     pub s_type: StructureType,
72970     pub p_next: *mut c_void,
72971     pub present_mode_count: u32,
72972     pub p_present_modes: *mut PresentModeKHR,
72973 }
72974 impl ::std::default::Default for SurfacePresentModeCompatibilityEXT {
72975     #[inline]
default() -> Self72976     fn default() -> Self {
72977         Self {
72978             s_type: Self::STRUCTURE_TYPE,
72979             p_next: ::std::ptr::null_mut(),
72980             present_mode_count: u32::default(),
72981             p_present_modes: ::std::ptr::null_mut(),
72982         }
72983     }
72984 }
72985 unsafe impl TaggedStructure for SurfacePresentModeCompatibilityEXT {
72986     const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_PRESENT_MODE_COMPATIBILITY_EXT;
72987 }
72988 impl SurfacePresentModeCompatibilityEXT {
builder<'a>() -> SurfacePresentModeCompatibilityEXTBuilder<'a>72989     pub fn builder<'a>() -> SurfacePresentModeCompatibilityEXTBuilder<'a> {
72990         SurfacePresentModeCompatibilityEXTBuilder {
72991             inner: Self::default(),
72992             marker: ::std::marker::PhantomData,
72993         }
72994     }
72995 }
72996 #[repr(transparent)]
72997 pub struct SurfacePresentModeCompatibilityEXTBuilder<'a> {
72998     inner: SurfacePresentModeCompatibilityEXT,
72999     marker: ::std::marker::PhantomData<&'a ()>,
73000 }
73001 unsafe impl ExtendsSurfaceCapabilities2KHR for SurfacePresentModeCompatibilityEXTBuilder<'_> {}
73002 unsafe impl ExtendsSurfaceCapabilities2KHR for SurfacePresentModeCompatibilityEXT {}
73003 impl<'a> ::std::ops::Deref for SurfacePresentModeCompatibilityEXTBuilder<'a> {
73004     type Target = SurfacePresentModeCompatibilityEXT;
deref(&self) -> &Self::Target73005     fn deref(&self) -> &Self::Target {
73006         &self.inner
73007     }
73008 }
73009 impl<'a> ::std::ops::DerefMut for SurfacePresentModeCompatibilityEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target73010     fn deref_mut(&mut self) -> &mut Self::Target {
73011         &mut self.inner
73012     }
73013 }
73014 impl<'a> SurfacePresentModeCompatibilityEXTBuilder<'a> {
73015     #[inline]
present_modes(mut self, present_modes: &'a mut [PresentModeKHR]) -> Self73016     pub fn present_modes(mut self, present_modes: &'a mut [PresentModeKHR]) -> Self {
73017         self.inner.present_mode_count = present_modes.len() as _;
73018         self.inner.p_present_modes = present_modes.as_mut_ptr();
73019         self
73020     }
73021     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
73022     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
73023     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SurfacePresentModeCompatibilityEXT73024     pub fn build(self) -> SurfacePresentModeCompatibilityEXT {
73025         self.inner
73026     }
73027 }
73028 #[repr(C)]
73029 #[cfg_attr(feature = "debug", derive(Debug))]
73030 #[derive(Copy, Clone)]
73031 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT.html>"]
73032 pub struct PhysicalDeviceSwapchainMaintenance1FeaturesEXT {
73033     pub s_type: StructureType,
73034     pub p_next: *mut c_void,
73035     pub swapchain_maintenance1: Bool32,
73036 }
73037 impl ::std::default::Default for PhysicalDeviceSwapchainMaintenance1FeaturesEXT {
73038     #[inline]
default() -> Self73039     fn default() -> Self {
73040         Self {
73041             s_type: Self::STRUCTURE_TYPE,
73042             p_next: ::std::ptr::null_mut(),
73043             swapchain_maintenance1: Bool32::default(),
73044         }
73045     }
73046 }
73047 unsafe impl TaggedStructure for PhysicalDeviceSwapchainMaintenance1FeaturesEXT {
73048     const STRUCTURE_TYPE: StructureType =
73049         StructureType::PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT;
73050 }
73051 impl PhysicalDeviceSwapchainMaintenance1FeaturesEXT {
builder<'a>() -> PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder<'a>73052     pub fn builder<'a>() -> PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder<'a> {
73053         PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder {
73054             inner: Self::default(),
73055             marker: ::std::marker::PhantomData,
73056         }
73057     }
73058 }
73059 #[repr(transparent)]
73060 pub struct PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder<'a> {
73061     inner: PhysicalDeviceSwapchainMaintenance1FeaturesEXT,
73062     marker: ::std::marker::PhantomData<&'a ()>,
73063 }
73064 unsafe impl ExtendsPhysicalDeviceFeatures2
73065     for PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder<'_>
73066 {
73067 }
73068 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSwapchainMaintenance1FeaturesEXT {}
73069 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder<'_> {}
73070 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSwapchainMaintenance1FeaturesEXT {}
73071 impl<'a> ::std::ops::Deref for PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder<'a> {
73072     type Target = PhysicalDeviceSwapchainMaintenance1FeaturesEXT;
deref(&self) -> &Self::Target73073     fn deref(&self) -> &Self::Target {
73074         &self.inner
73075     }
73076 }
73077 impl<'a> ::std::ops::DerefMut for PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target73078     fn deref_mut(&mut self) -> &mut Self::Target {
73079         &mut self.inner
73080     }
73081 }
73082 impl<'a> PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder<'a> {
73083     #[inline]
swapchain_maintenance1(mut self, swapchain_maintenance1: bool) -> Self73084     pub fn swapchain_maintenance1(mut self, swapchain_maintenance1: bool) -> Self {
73085         self.inner.swapchain_maintenance1 = swapchain_maintenance1.into();
73086         self
73087     }
73088     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
73089     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
73090     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceSwapchainMaintenance1FeaturesEXT73091     pub fn build(self) -> PhysicalDeviceSwapchainMaintenance1FeaturesEXT {
73092         self.inner
73093     }
73094 }
73095 #[repr(C)]
73096 #[cfg_attr(feature = "debug", derive(Debug))]
73097 #[derive(Copy, Clone)]
73098 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainPresentFenceInfoEXT.html>"]
73099 pub struct SwapchainPresentFenceInfoEXT {
73100     pub s_type: StructureType,
73101     pub p_next: *const c_void,
73102     pub swapchain_count: u32,
73103     pub p_fences: *const Fence,
73104 }
73105 impl ::std::default::Default for SwapchainPresentFenceInfoEXT {
73106     #[inline]
default() -> Self73107     fn default() -> Self {
73108         Self {
73109             s_type: Self::STRUCTURE_TYPE,
73110             p_next: ::std::ptr::null(),
73111             swapchain_count: u32::default(),
73112             p_fences: ::std::ptr::null(),
73113         }
73114     }
73115 }
73116 unsafe impl TaggedStructure for SwapchainPresentFenceInfoEXT {
73117     const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_PRESENT_FENCE_INFO_EXT;
73118 }
73119 impl SwapchainPresentFenceInfoEXT {
builder<'a>() -> SwapchainPresentFenceInfoEXTBuilder<'a>73120     pub fn builder<'a>() -> SwapchainPresentFenceInfoEXTBuilder<'a> {
73121         SwapchainPresentFenceInfoEXTBuilder {
73122             inner: Self::default(),
73123             marker: ::std::marker::PhantomData,
73124         }
73125     }
73126 }
73127 #[repr(transparent)]
73128 pub struct SwapchainPresentFenceInfoEXTBuilder<'a> {
73129     inner: SwapchainPresentFenceInfoEXT,
73130     marker: ::std::marker::PhantomData<&'a ()>,
73131 }
73132 unsafe impl ExtendsPresentInfoKHR for SwapchainPresentFenceInfoEXTBuilder<'_> {}
73133 unsafe impl ExtendsPresentInfoKHR for SwapchainPresentFenceInfoEXT {}
73134 impl<'a> ::std::ops::Deref for SwapchainPresentFenceInfoEXTBuilder<'a> {
73135     type Target = SwapchainPresentFenceInfoEXT;
deref(&self) -> &Self::Target73136     fn deref(&self) -> &Self::Target {
73137         &self.inner
73138     }
73139 }
73140 impl<'a> ::std::ops::DerefMut for SwapchainPresentFenceInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target73141     fn deref_mut(&mut self) -> &mut Self::Target {
73142         &mut self.inner
73143     }
73144 }
73145 impl<'a> SwapchainPresentFenceInfoEXTBuilder<'a> {
73146     #[inline]
fences(mut self, fences: &'a [Fence]) -> Self73147     pub fn fences(mut self, fences: &'a [Fence]) -> Self {
73148         self.inner.swapchain_count = fences.len() as _;
73149         self.inner.p_fences = fences.as_ptr();
73150         self
73151     }
73152     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
73153     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
73154     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SwapchainPresentFenceInfoEXT73155     pub fn build(self) -> SwapchainPresentFenceInfoEXT {
73156         self.inner
73157     }
73158 }
73159 #[repr(C)]
73160 #[cfg_attr(feature = "debug", derive(Debug))]
73161 #[derive(Copy, Clone)]
73162 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainPresentModesCreateInfoEXT.html>"]
73163 pub struct SwapchainPresentModesCreateInfoEXT {
73164     pub s_type: StructureType,
73165     pub p_next: *const c_void,
73166     pub present_mode_count: u32,
73167     pub p_present_modes: *const PresentModeKHR,
73168 }
73169 impl ::std::default::Default for SwapchainPresentModesCreateInfoEXT {
73170     #[inline]
default() -> Self73171     fn default() -> Self {
73172         Self {
73173             s_type: Self::STRUCTURE_TYPE,
73174             p_next: ::std::ptr::null(),
73175             present_mode_count: u32::default(),
73176             p_present_modes: ::std::ptr::null(),
73177         }
73178     }
73179 }
73180 unsafe impl TaggedStructure for SwapchainPresentModesCreateInfoEXT {
73181     const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT;
73182 }
73183 impl SwapchainPresentModesCreateInfoEXT {
builder<'a>() -> SwapchainPresentModesCreateInfoEXTBuilder<'a>73184     pub fn builder<'a>() -> SwapchainPresentModesCreateInfoEXTBuilder<'a> {
73185         SwapchainPresentModesCreateInfoEXTBuilder {
73186             inner: Self::default(),
73187             marker: ::std::marker::PhantomData,
73188         }
73189     }
73190 }
73191 #[repr(transparent)]
73192 pub struct SwapchainPresentModesCreateInfoEXTBuilder<'a> {
73193     inner: SwapchainPresentModesCreateInfoEXT,
73194     marker: ::std::marker::PhantomData<&'a ()>,
73195 }
73196 unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentModesCreateInfoEXTBuilder<'_> {}
73197 unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentModesCreateInfoEXT {}
73198 impl<'a> ::std::ops::Deref for SwapchainPresentModesCreateInfoEXTBuilder<'a> {
73199     type Target = SwapchainPresentModesCreateInfoEXT;
deref(&self) -> &Self::Target73200     fn deref(&self) -> &Self::Target {
73201         &self.inner
73202     }
73203 }
73204 impl<'a> ::std::ops::DerefMut for SwapchainPresentModesCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target73205     fn deref_mut(&mut self) -> &mut Self::Target {
73206         &mut self.inner
73207     }
73208 }
73209 impl<'a> SwapchainPresentModesCreateInfoEXTBuilder<'a> {
73210     #[inline]
present_modes(mut self, present_modes: &'a [PresentModeKHR]) -> Self73211     pub fn present_modes(mut self, present_modes: &'a [PresentModeKHR]) -> Self {
73212         self.inner.present_mode_count = present_modes.len() as _;
73213         self.inner.p_present_modes = present_modes.as_ptr();
73214         self
73215     }
73216     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
73217     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
73218     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SwapchainPresentModesCreateInfoEXT73219     pub fn build(self) -> SwapchainPresentModesCreateInfoEXT {
73220         self.inner
73221     }
73222 }
73223 #[repr(C)]
73224 #[cfg_attr(feature = "debug", derive(Debug))]
73225 #[derive(Copy, Clone)]
73226 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainPresentModeInfoEXT.html>"]
73227 pub struct SwapchainPresentModeInfoEXT {
73228     pub s_type: StructureType,
73229     pub p_next: *const c_void,
73230     pub swapchain_count: u32,
73231     pub p_present_modes: *const PresentModeKHR,
73232 }
73233 impl ::std::default::Default for SwapchainPresentModeInfoEXT {
73234     #[inline]
default() -> Self73235     fn default() -> Self {
73236         Self {
73237             s_type: Self::STRUCTURE_TYPE,
73238             p_next: ::std::ptr::null(),
73239             swapchain_count: u32::default(),
73240             p_present_modes: ::std::ptr::null(),
73241         }
73242     }
73243 }
73244 unsafe impl TaggedStructure for SwapchainPresentModeInfoEXT {
73245     const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_PRESENT_MODE_INFO_EXT;
73246 }
73247 impl SwapchainPresentModeInfoEXT {
builder<'a>() -> SwapchainPresentModeInfoEXTBuilder<'a>73248     pub fn builder<'a>() -> SwapchainPresentModeInfoEXTBuilder<'a> {
73249         SwapchainPresentModeInfoEXTBuilder {
73250             inner: Self::default(),
73251             marker: ::std::marker::PhantomData,
73252         }
73253     }
73254 }
73255 #[repr(transparent)]
73256 pub struct SwapchainPresentModeInfoEXTBuilder<'a> {
73257     inner: SwapchainPresentModeInfoEXT,
73258     marker: ::std::marker::PhantomData<&'a ()>,
73259 }
73260 unsafe impl ExtendsPresentInfoKHR for SwapchainPresentModeInfoEXTBuilder<'_> {}
73261 unsafe impl ExtendsPresentInfoKHR for SwapchainPresentModeInfoEXT {}
73262 impl<'a> ::std::ops::Deref for SwapchainPresentModeInfoEXTBuilder<'a> {
73263     type Target = SwapchainPresentModeInfoEXT;
deref(&self) -> &Self::Target73264     fn deref(&self) -> &Self::Target {
73265         &self.inner
73266     }
73267 }
73268 impl<'a> ::std::ops::DerefMut for SwapchainPresentModeInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target73269     fn deref_mut(&mut self) -> &mut Self::Target {
73270         &mut self.inner
73271     }
73272 }
73273 impl<'a> SwapchainPresentModeInfoEXTBuilder<'a> {
73274     #[inline]
present_modes(mut self, present_modes: &'a [PresentModeKHR]) -> Self73275     pub fn present_modes(mut self, present_modes: &'a [PresentModeKHR]) -> Self {
73276         self.inner.swapchain_count = present_modes.len() as _;
73277         self.inner.p_present_modes = present_modes.as_ptr();
73278         self
73279     }
73280     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
73281     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
73282     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SwapchainPresentModeInfoEXT73283     pub fn build(self) -> SwapchainPresentModeInfoEXT {
73284         self.inner
73285     }
73286 }
73287 #[repr(C)]
73288 #[cfg_attr(feature = "debug", derive(Debug))]
73289 #[derive(Copy, Clone)]
73290 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainPresentScalingCreateInfoEXT.html>"]
73291 pub struct SwapchainPresentScalingCreateInfoEXT {
73292     pub s_type: StructureType,
73293     pub p_next: *const c_void,
73294     pub scaling_behavior: PresentScalingFlagsEXT,
73295     pub present_gravity_x: PresentGravityFlagsEXT,
73296     pub present_gravity_y: PresentGravityFlagsEXT,
73297 }
73298 impl ::std::default::Default for SwapchainPresentScalingCreateInfoEXT {
73299     #[inline]
default() -> Self73300     fn default() -> Self {
73301         Self {
73302             s_type: Self::STRUCTURE_TYPE,
73303             p_next: ::std::ptr::null(),
73304             scaling_behavior: PresentScalingFlagsEXT::default(),
73305             present_gravity_x: PresentGravityFlagsEXT::default(),
73306             present_gravity_y: PresentGravityFlagsEXT::default(),
73307         }
73308     }
73309 }
73310 unsafe impl TaggedStructure for SwapchainPresentScalingCreateInfoEXT {
73311     const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT;
73312 }
73313 impl SwapchainPresentScalingCreateInfoEXT {
builder<'a>() -> SwapchainPresentScalingCreateInfoEXTBuilder<'a>73314     pub fn builder<'a>() -> SwapchainPresentScalingCreateInfoEXTBuilder<'a> {
73315         SwapchainPresentScalingCreateInfoEXTBuilder {
73316             inner: Self::default(),
73317             marker: ::std::marker::PhantomData,
73318         }
73319     }
73320 }
73321 #[repr(transparent)]
73322 pub struct SwapchainPresentScalingCreateInfoEXTBuilder<'a> {
73323     inner: SwapchainPresentScalingCreateInfoEXT,
73324     marker: ::std::marker::PhantomData<&'a ()>,
73325 }
73326 unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentScalingCreateInfoEXTBuilder<'_> {}
73327 unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentScalingCreateInfoEXT {}
73328 impl<'a> ::std::ops::Deref for SwapchainPresentScalingCreateInfoEXTBuilder<'a> {
73329     type Target = SwapchainPresentScalingCreateInfoEXT;
deref(&self) -> &Self::Target73330     fn deref(&self) -> &Self::Target {
73331         &self.inner
73332     }
73333 }
73334 impl<'a> ::std::ops::DerefMut for SwapchainPresentScalingCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target73335     fn deref_mut(&mut self) -> &mut Self::Target {
73336         &mut self.inner
73337     }
73338 }
73339 impl<'a> SwapchainPresentScalingCreateInfoEXTBuilder<'a> {
73340     #[inline]
scaling_behavior(mut self, scaling_behavior: PresentScalingFlagsEXT) -> Self73341     pub fn scaling_behavior(mut self, scaling_behavior: PresentScalingFlagsEXT) -> Self {
73342         self.inner.scaling_behavior = scaling_behavior;
73343         self
73344     }
73345     #[inline]
present_gravity_x(mut self, present_gravity_x: PresentGravityFlagsEXT) -> Self73346     pub fn present_gravity_x(mut self, present_gravity_x: PresentGravityFlagsEXT) -> Self {
73347         self.inner.present_gravity_x = present_gravity_x;
73348         self
73349     }
73350     #[inline]
present_gravity_y(mut self, present_gravity_y: PresentGravityFlagsEXT) -> Self73351     pub fn present_gravity_y(mut self, present_gravity_y: PresentGravityFlagsEXT) -> Self {
73352         self.inner.present_gravity_y = present_gravity_y;
73353         self
73354     }
73355     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
73356     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
73357     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SwapchainPresentScalingCreateInfoEXT73358     pub fn build(self) -> SwapchainPresentScalingCreateInfoEXT {
73359         self.inner
73360     }
73361 }
73362 #[repr(C)]
73363 #[cfg_attr(feature = "debug", derive(Debug))]
73364 #[derive(Copy, Clone)]
73365 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkReleaseSwapchainImagesInfoEXT.html>"]
73366 pub struct ReleaseSwapchainImagesInfoEXT {
73367     pub s_type: StructureType,
73368     pub p_next: *const c_void,
73369     pub swapchain: SwapchainKHR,
73370     pub image_index_count: u32,
73371     pub p_image_indices: *const u32,
73372 }
73373 impl ::std::default::Default for ReleaseSwapchainImagesInfoEXT {
73374     #[inline]
default() -> Self73375     fn default() -> Self {
73376         Self {
73377             s_type: Self::STRUCTURE_TYPE,
73378             p_next: ::std::ptr::null(),
73379             swapchain: SwapchainKHR::default(),
73380             image_index_count: u32::default(),
73381             p_image_indices: ::std::ptr::null(),
73382         }
73383     }
73384 }
73385 unsafe impl TaggedStructure for ReleaseSwapchainImagesInfoEXT {
73386     const STRUCTURE_TYPE: StructureType = StructureType::RELEASE_SWAPCHAIN_IMAGES_INFO_EXT;
73387 }
73388 impl ReleaseSwapchainImagesInfoEXT {
builder<'a>() -> ReleaseSwapchainImagesInfoEXTBuilder<'a>73389     pub fn builder<'a>() -> ReleaseSwapchainImagesInfoEXTBuilder<'a> {
73390         ReleaseSwapchainImagesInfoEXTBuilder {
73391             inner: Self::default(),
73392             marker: ::std::marker::PhantomData,
73393         }
73394     }
73395 }
73396 #[repr(transparent)]
73397 pub struct ReleaseSwapchainImagesInfoEXTBuilder<'a> {
73398     inner: ReleaseSwapchainImagesInfoEXT,
73399     marker: ::std::marker::PhantomData<&'a ()>,
73400 }
73401 impl<'a> ::std::ops::Deref for ReleaseSwapchainImagesInfoEXTBuilder<'a> {
73402     type Target = ReleaseSwapchainImagesInfoEXT;
deref(&self) -> &Self::Target73403     fn deref(&self) -> &Self::Target {
73404         &self.inner
73405     }
73406 }
73407 impl<'a> ::std::ops::DerefMut for ReleaseSwapchainImagesInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target73408     fn deref_mut(&mut self) -> &mut Self::Target {
73409         &mut self.inner
73410     }
73411 }
73412 impl<'a> ReleaseSwapchainImagesInfoEXTBuilder<'a> {
73413     #[inline]
swapchain(mut self, swapchain: SwapchainKHR) -> Self73414     pub fn swapchain(mut self, swapchain: SwapchainKHR) -> Self {
73415         self.inner.swapchain = swapchain;
73416         self
73417     }
73418     #[inline]
image_indices(mut self, image_indices: &'a [u32]) -> Self73419     pub fn image_indices(mut self, image_indices: &'a [u32]) -> Self {
73420         self.inner.image_index_count = image_indices.len() as _;
73421         self.inner.p_image_indices = image_indices.as_ptr();
73422         self
73423     }
73424     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
73425     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
73426     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ReleaseSwapchainImagesInfoEXT73427     pub fn build(self) -> ReleaseSwapchainImagesInfoEXT {
73428         self.inner
73429     }
73430 }
73431 #[repr(C)]
73432 #[cfg_attr(feature = "debug", derive(Debug))]
73433 #[derive(Copy, Clone)]
73434 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV.html>"]
73435 pub struct PhysicalDeviceRayTracingInvocationReorderFeaturesNV {
73436     pub s_type: StructureType,
73437     pub p_next: *mut c_void,
73438     pub ray_tracing_invocation_reorder: Bool32,
73439 }
73440 impl ::std::default::Default for PhysicalDeviceRayTracingInvocationReorderFeaturesNV {
73441     #[inline]
default() -> Self73442     fn default() -> Self {
73443         Self {
73444             s_type: Self::STRUCTURE_TYPE,
73445             p_next: ::std::ptr::null_mut(),
73446             ray_tracing_invocation_reorder: Bool32::default(),
73447         }
73448     }
73449 }
73450 unsafe impl TaggedStructure for PhysicalDeviceRayTracingInvocationReorderFeaturesNV {
73451     const STRUCTURE_TYPE: StructureType =
73452         StructureType::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
73453 }
73454 impl PhysicalDeviceRayTracingInvocationReorderFeaturesNV {
builder<'a>() -> PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'a>73455     pub fn builder<'a>() -> PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'a> {
73456         PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder {
73457             inner: Self::default(),
73458             marker: ::std::marker::PhantomData,
73459         }
73460     }
73461 }
73462 #[repr(transparent)]
73463 pub struct PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'a> {
73464     inner: PhysicalDeviceRayTracingInvocationReorderFeaturesNV,
73465     marker: ::std::marker::PhantomData<&'a ()>,
73466 }
73467 unsafe impl ExtendsPhysicalDeviceFeatures2
73468     for PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'_>
73469 {
73470 }
73471 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingInvocationReorderFeaturesNV {}
73472 unsafe impl ExtendsDeviceCreateInfo
73473     for PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'_>
73474 {
73475 }
73476 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingInvocationReorderFeaturesNV {}
73477 impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'a> {
73478     type Target = PhysicalDeviceRayTracingInvocationReorderFeaturesNV;
deref(&self) -> &Self::Target73479     fn deref(&self) -> &Self::Target {
73480         &self.inner
73481     }
73482 }
73483 impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target73484     fn deref_mut(&mut self) -> &mut Self::Target {
73485         &mut self.inner
73486     }
73487 }
73488 impl<'a> PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'a> {
73489     #[inline]
ray_tracing_invocation_reorder(mut self, ray_tracing_invocation_reorder: bool) -> Self73490     pub fn ray_tracing_invocation_reorder(mut self, ray_tracing_invocation_reorder: bool) -> Self {
73491         self.inner.ray_tracing_invocation_reorder = ray_tracing_invocation_reorder.into();
73492         self
73493     }
73494     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
73495     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
73496     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceRayTracingInvocationReorderFeaturesNV73497     pub fn build(self) -> PhysicalDeviceRayTracingInvocationReorderFeaturesNV {
73498         self.inner
73499     }
73500 }
73501 #[repr(C)]
73502 #[cfg_attr(feature = "debug", derive(Debug))]
73503 #[derive(Copy, Clone)]
73504 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV.html>"]
73505 pub struct PhysicalDeviceRayTracingInvocationReorderPropertiesNV {
73506     pub s_type: StructureType,
73507     pub p_next: *mut c_void,
73508     pub ray_tracing_invocation_reorder_reordering_hint: RayTracingInvocationReorderModeNV,
73509 }
73510 impl ::std::default::Default for PhysicalDeviceRayTracingInvocationReorderPropertiesNV {
73511     #[inline]
default() -> Self73512     fn default() -> Self {
73513         Self {
73514             s_type: Self::STRUCTURE_TYPE,
73515             p_next: ::std::ptr::null_mut(),
73516             ray_tracing_invocation_reorder_reordering_hint:
73517                 RayTracingInvocationReorderModeNV::default(),
73518         }
73519     }
73520 }
73521 unsafe impl TaggedStructure for PhysicalDeviceRayTracingInvocationReorderPropertiesNV {
73522     const STRUCTURE_TYPE: StructureType =
73523         StructureType::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV;
73524 }
73525 impl PhysicalDeviceRayTracingInvocationReorderPropertiesNV {
builder<'a>() -> PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<'a>73526     pub fn builder<'a>() -> PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<'a> {
73527         PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder {
73528             inner: Self::default(),
73529             marker: ::std::marker::PhantomData,
73530         }
73531     }
73532 }
73533 #[repr(transparent)]
73534 pub struct PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<'a> {
73535     inner: PhysicalDeviceRayTracingInvocationReorderPropertiesNV,
73536     marker: ::std::marker::PhantomData<&'a ()>,
73537 }
73538 unsafe impl ExtendsPhysicalDeviceProperties2
73539     for PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<'_>
73540 {
73541 }
73542 unsafe impl ExtendsPhysicalDeviceProperties2
73543     for PhysicalDeviceRayTracingInvocationReorderPropertiesNV
73544 {
73545 }
73546 impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<'a> {
73547     type Target = PhysicalDeviceRayTracingInvocationReorderPropertiesNV;
deref(&self) -> &Self::Target73548     fn deref(&self) -> &Self::Target {
73549         &self.inner
73550     }
73551 }
73552 impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target73553     fn deref_mut(&mut self) -> &mut Self::Target {
73554         &mut self.inner
73555     }
73556 }
73557 impl<'a> PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<'a> {
73558     #[inline]
ray_tracing_invocation_reorder_reordering_hint( mut self, ray_tracing_invocation_reorder_reordering_hint: RayTracingInvocationReorderModeNV, ) -> Self73559     pub fn ray_tracing_invocation_reorder_reordering_hint(
73560         mut self,
73561         ray_tracing_invocation_reorder_reordering_hint: RayTracingInvocationReorderModeNV,
73562     ) -> Self {
73563         self.inner.ray_tracing_invocation_reorder_reordering_hint =
73564             ray_tracing_invocation_reorder_reordering_hint;
73565         self
73566     }
73567     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
73568     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
73569     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceRayTracingInvocationReorderPropertiesNV73570     pub fn build(self) -> PhysicalDeviceRayTracingInvocationReorderPropertiesNV {
73571         self.inner
73572     }
73573 }
73574 #[repr(C)]
73575 #[derive(Copy, Clone)]
73576 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDirectDriverLoadingInfoLUNARG.html>"]
73577 pub struct DirectDriverLoadingInfoLUNARG {
73578     pub s_type: StructureType,
73579     pub p_next: *mut c_void,
73580     pub flags: DirectDriverLoadingFlagsLUNARG,
73581     pub pfn_get_instance_proc_addr: PFN_vkGetInstanceProcAddrLUNARG,
73582 }
73583 #[cfg(feature = "debug")]
73584 impl fmt::Debug for DirectDriverLoadingInfoLUNARG {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result73585     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
73586         fmt.debug_struct("DirectDriverLoadingInfoLUNARG")
73587             .field("s_type", &self.s_type)
73588             .field("p_next", &self.p_next)
73589             .field("flags", &self.flags)
73590             .field(
73591                 "pfn_get_instance_proc_addr",
73592                 &(self.pfn_get_instance_proc_addr.map(|x| x as *const ())),
73593             )
73594             .finish()
73595     }
73596 }
73597 impl ::std::default::Default for DirectDriverLoadingInfoLUNARG {
73598     #[inline]
default() -> Self73599     fn default() -> Self {
73600         Self {
73601             s_type: Self::STRUCTURE_TYPE,
73602             p_next: ::std::ptr::null_mut(),
73603             flags: DirectDriverLoadingFlagsLUNARG::default(),
73604             pfn_get_instance_proc_addr: PFN_vkGetInstanceProcAddrLUNARG::default(),
73605         }
73606     }
73607 }
73608 unsafe impl TaggedStructure for DirectDriverLoadingInfoLUNARG {
73609     const STRUCTURE_TYPE: StructureType = StructureType::DIRECT_DRIVER_LOADING_INFO_LUNARG;
73610 }
73611 impl DirectDriverLoadingInfoLUNARG {
builder<'a>() -> DirectDriverLoadingInfoLUNARGBuilder<'a>73612     pub fn builder<'a>() -> DirectDriverLoadingInfoLUNARGBuilder<'a> {
73613         DirectDriverLoadingInfoLUNARGBuilder {
73614             inner: Self::default(),
73615             marker: ::std::marker::PhantomData,
73616         }
73617     }
73618 }
73619 #[repr(transparent)]
73620 pub struct DirectDriverLoadingInfoLUNARGBuilder<'a> {
73621     inner: DirectDriverLoadingInfoLUNARG,
73622     marker: ::std::marker::PhantomData<&'a ()>,
73623 }
73624 impl<'a> ::std::ops::Deref for DirectDriverLoadingInfoLUNARGBuilder<'a> {
73625     type Target = DirectDriverLoadingInfoLUNARG;
deref(&self) -> &Self::Target73626     fn deref(&self) -> &Self::Target {
73627         &self.inner
73628     }
73629 }
73630 impl<'a> ::std::ops::DerefMut for DirectDriverLoadingInfoLUNARGBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target73631     fn deref_mut(&mut self) -> &mut Self::Target {
73632         &mut self.inner
73633     }
73634 }
73635 impl<'a> DirectDriverLoadingInfoLUNARGBuilder<'a> {
73636     #[inline]
flags(mut self, flags: DirectDriverLoadingFlagsLUNARG) -> Self73637     pub fn flags(mut self, flags: DirectDriverLoadingFlagsLUNARG) -> Self {
73638         self.inner.flags = flags;
73639         self
73640     }
73641     #[inline]
pfn_get_instance_proc_addr( mut self, pfn_get_instance_proc_addr: PFN_vkGetInstanceProcAddrLUNARG, ) -> Self73642     pub fn pfn_get_instance_proc_addr(
73643         mut self,
73644         pfn_get_instance_proc_addr: PFN_vkGetInstanceProcAddrLUNARG,
73645     ) -> Self {
73646         self.inner.pfn_get_instance_proc_addr = pfn_get_instance_proc_addr;
73647         self
73648     }
73649     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
73650     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
73651     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DirectDriverLoadingInfoLUNARG73652     pub fn build(self) -> DirectDriverLoadingInfoLUNARG {
73653         self.inner
73654     }
73655 }
73656 #[repr(C)]
73657 #[cfg_attr(feature = "debug", derive(Debug))]
73658 #[derive(Copy, Clone)]
73659 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDirectDriverLoadingListLUNARG.html>"]
73660 pub struct DirectDriverLoadingListLUNARG {
73661     pub s_type: StructureType,
73662     pub p_next: *mut c_void,
73663     pub mode: DirectDriverLoadingModeLUNARG,
73664     pub driver_count: u32,
73665     pub p_drivers: *const DirectDriverLoadingInfoLUNARG,
73666 }
73667 impl ::std::default::Default for DirectDriverLoadingListLUNARG {
73668     #[inline]
default() -> Self73669     fn default() -> Self {
73670         Self {
73671             s_type: Self::STRUCTURE_TYPE,
73672             p_next: ::std::ptr::null_mut(),
73673             mode: DirectDriverLoadingModeLUNARG::default(),
73674             driver_count: u32::default(),
73675             p_drivers: ::std::ptr::null(),
73676         }
73677     }
73678 }
73679 unsafe impl TaggedStructure for DirectDriverLoadingListLUNARG {
73680     const STRUCTURE_TYPE: StructureType = StructureType::DIRECT_DRIVER_LOADING_LIST_LUNARG;
73681 }
73682 impl DirectDriverLoadingListLUNARG {
builder<'a>() -> DirectDriverLoadingListLUNARGBuilder<'a>73683     pub fn builder<'a>() -> DirectDriverLoadingListLUNARGBuilder<'a> {
73684         DirectDriverLoadingListLUNARGBuilder {
73685             inner: Self::default(),
73686             marker: ::std::marker::PhantomData,
73687         }
73688     }
73689 }
73690 #[repr(transparent)]
73691 pub struct DirectDriverLoadingListLUNARGBuilder<'a> {
73692     inner: DirectDriverLoadingListLUNARG,
73693     marker: ::std::marker::PhantomData<&'a ()>,
73694 }
73695 unsafe impl ExtendsInstanceCreateInfo for DirectDriverLoadingListLUNARGBuilder<'_> {}
73696 unsafe impl ExtendsInstanceCreateInfo for DirectDriverLoadingListLUNARG {}
73697 impl<'a> ::std::ops::Deref for DirectDriverLoadingListLUNARGBuilder<'a> {
73698     type Target = DirectDriverLoadingListLUNARG;
deref(&self) -> &Self::Target73699     fn deref(&self) -> &Self::Target {
73700         &self.inner
73701     }
73702 }
73703 impl<'a> ::std::ops::DerefMut for DirectDriverLoadingListLUNARGBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target73704     fn deref_mut(&mut self) -> &mut Self::Target {
73705         &mut self.inner
73706     }
73707 }
73708 impl<'a> DirectDriverLoadingListLUNARGBuilder<'a> {
73709     #[inline]
mode(mut self, mode: DirectDriverLoadingModeLUNARG) -> Self73710     pub fn mode(mut self, mode: DirectDriverLoadingModeLUNARG) -> Self {
73711         self.inner.mode = mode;
73712         self
73713     }
73714     #[inline]
drivers(mut self, drivers: &'a [DirectDriverLoadingInfoLUNARG]) -> Self73715     pub fn drivers(mut self, drivers: &'a [DirectDriverLoadingInfoLUNARG]) -> Self {
73716         self.inner.driver_count = drivers.len() as _;
73717         self.inner.p_drivers = drivers.as_ptr();
73718         self
73719     }
73720     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
73721     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
73722     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DirectDriverLoadingListLUNARG73723     pub fn build(self) -> DirectDriverLoadingListLUNARG {
73724         self.inner
73725     }
73726 }
73727 #[repr(C)]
73728 #[cfg_attr(feature = "debug", derive(Debug))]
73729 #[derive(Copy, Clone)]
73730 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM.html>"]
73731 pub struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {
73732     pub s_type: StructureType,
73733     pub p_next: *mut c_void,
73734     pub multiview_per_view_viewports: Bool32,
73735 }
73736 impl ::std::default::Default for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {
73737     #[inline]
default() -> Self73738     fn default() -> Self {
73739         Self {
73740             s_type: Self::STRUCTURE_TYPE,
73741             p_next: ::std::ptr::null_mut(),
73742             multiview_per_view_viewports: Bool32::default(),
73743         }
73744     }
73745 }
73746 unsafe impl TaggedStructure for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {
73747     const STRUCTURE_TYPE: StructureType =
73748         StructureType::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM;
73749 }
73750 impl PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {
builder<'a>() -> PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'a>73751     pub fn builder<'a>() -> PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'a> {
73752         PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder {
73753             inner: Self::default(),
73754             marker: ::std::marker::PhantomData,
73755         }
73756     }
73757 }
73758 #[repr(transparent)]
73759 pub struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'a> {
73760     inner: PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM,
73761     marker: ::std::marker::PhantomData<&'a ()>,
73762 }
73763 unsafe impl ExtendsPhysicalDeviceFeatures2
73764     for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'_>
73765 {
73766 }
73767 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {}
73768 unsafe impl ExtendsDeviceCreateInfo
73769     for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'_>
73770 {
73771 }
73772 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {}
73773 impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'a> {
73774     type Target = PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM;
deref(&self) -> &Self::Target73775     fn deref(&self) -> &Self::Target {
73776         &self.inner
73777     }
73778 }
73779 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target73780     fn deref_mut(&mut self) -> &mut Self::Target {
73781         &mut self.inner
73782     }
73783 }
73784 impl<'a> PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'a> {
73785     #[inline]
multiview_per_view_viewports(mut self, multiview_per_view_viewports: bool) -> Self73786     pub fn multiview_per_view_viewports(mut self, multiview_per_view_viewports: bool) -> Self {
73787         self.inner.multiview_per_view_viewports = multiview_per_view_viewports.into();
73788         self
73789     }
73790     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
73791     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
73792     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM73793     pub fn build(self) -> PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {
73794         self.inner
73795     }
73796 }
73797 #[repr(C)]
73798 #[cfg_attr(feature = "debug", derive(Debug))]
73799 #[derive(Copy, Clone)]
73800 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR.html>"]
73801 pub struct PhysicalDeviceRayTracingPositionFetchFeaturesKHR {
73802     pub s_type: StructureType,
73803     pub p_next: *mut c_void,
73804     pub ray_tracing_position_fetch: Bool32,
73805 }
73806 impl ::std::default::Default for PhysicalDeviceRayTracingPositionFetchFeaturesKHR {
73807     #[inline]
default() -> Self73808     fn default() -> Self {
73809         Self {
73810             s_type: Self::STRUCTURE_TYPE,
73811             p_next: ::std::ptr::null_mut(),
73812             ray_tracing_position_fetch: Bool32::default(),
73813         }
73814     }
73815 }
73816 unsafe impl TaggedStructure for PhysicalDeviceRayTracingPositionFetchFeaturesKHR {
73817     const STRUCTURE_TYPE: StructureType =
73818         StructureType::PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR;
73819 }
73820 impl PhysicalDeviceRayTracingPositionFetchFeaturesKHR {
builder<'a>() -> PhysicalDeviceRayTracingPositionFetchFeaturesKHRBuilder<'a>73821     pub fn builder<'a>() -> PhysicalDeviceRayTracingPositionFetchFeaturesKHRBuilder<'a> {
73822         PhysicalDeviceRayTracingPositionFetchFeaturesKHRBuilder {
73823             inner: Self::default(),
73824             marker: ::std::marker::PhantomData,
73825         }
73826     }
73827 }
73828 #[repr(transparent)]
73829 pub struct PhysicalDeviceRayTracingPositionFetchFeaturesKHRBuilder<'a> {
73830     inner: PhysicalDeviceRayTracingPositionFetchFeaturesKHR,
73831     marker: ::std::marker::PhantomData<&'a ()>,
73832 }
73833 unsafe impl ExtendsPhysicalDeviceFeatures2
73834     for PhysicalDeviceRayTracingPositionFetchFeaturesKHRBuilder<'_>
73835 {
73836 }
73837 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingPositionFetchFeaturesKHR {}
73838 unsafe impl ExtendsDeviceCreateInfo
73839     for PhysicalDeviceRayTracingPositionFetchFeaturesKHRBuilder<'_>
73840 {
73841 }
73842 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingPositionFetchFeaturesKHR {}
73843 impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPositionFetchFeaturesKHRBuilder<'a> {
73844     type Target = PhysicalDeviceRayTracingPositionFetchFeaturesKHR;
deref(&self) -> &Self::Target73845     fn deref(&self) -> &Self::Target {
73846         &self.inner
73847     }
73848 }
73849 impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPositionFetchFeaturesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target73850     fn deref_mut(&mut self) -> &mut Self::Target {
73851         &mut self.inner
73852     }
73853 }
73854 impl<'a> PhysicalDeviceRayTracingPositionFetchFeaturesKHRBuilder<'a> {
73855     #[inline]
ray_tracing_position_fetch(mut self, ray_tracing_position_fetch: bool) -> Self73856     pub fn ray_tracing_position_fetch(mut self, ray_tracing_position_fetch: bool) -> Self {
73857         self.inner.ray_tracing_position_fetch = ray_tracing_position_fetch.into();
73858         self
73859     }
73860     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
73861     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
73862     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceRayTracingPositionFetchFeaturesKHR73863     pub fn build(self) -> PhysicalDeviceRayTracingPositionFetchFeaturesKHR {
73864         self.inner
73865     }
73866 }
73867 #[repr(C)]
73868 #[cfg_attr(feature = "debug", derive(Debug))]
73869 #[derive(Copy, Clone)]
73870 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderCorePropertiesARM.html>"]
73871 pub struct PhysicalDeviceShaderCorePropertiesARM {
73872     pub s_type: StructureType,
73873     pub p_next: *mut c_void,
73874     pub pixel_rate: u32,
73875     pub texel_rate: u32,
73876     pub fma_rate: u32,
73877 }
73878 impl ::std::default::Default for PhysicalDeviceShaderCorePropertiesARM {
73879     #[inline]
default() -> Self73880     fn default() -> Self {
73881         Self {
73882             s_type: Self::STRUCTURE_TYPE,
73883             p_next: ::std::ptr::null_mut(),
73884             pixel_rate: u32::default(),
73885             texel_rate: u32::default(),
73886             fma_rate: u32::default(),
73887         }
73888     }
73889 }
73890 unsafe impl TaggedStructure for PhysicalDeviceShaderCorePropertiesARM {
73891     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM;
73892 }
73893 impl PhysicalDeviceShaderCorePropertiesARM {
builder<'a>() -> PhysicalDeviceShaderCorePropertiesARMBuilder<'a>73894     pub fn builder<'a>() -> PhysicalDeviceShaderCorePropertiesARMBuilder<'a> {
73895         PhysicalDeviceShaderCorePropertiesARMBuilder {
73896             inner: Self::default(),
73897             marker: ::std::marker::PhantomData,
73898         }
73899     }
73900 }
73901 #[repr(transparent)]
73902 pub struct PhysicalDeviceShaderCorePropertiesARMBuilder<'a> {
73903     inner: PhysicalDeviceShaderCorePropertiesARM,
73904     marker: ::std::marker::PhantomData<&'a ()>,
73905 }
73906 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesARMBuilder<'_> {}
73907 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesARM {}
73908 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderCorePropertiesARMBuilder<'a> {
73909     type Target = PhysicalDeviceShaderCorePropertiesARM;
deref(&self) -> &Self::Target73910     fn deref(&self) -> &Self::Target {
73911         &self.inner
73912     }
73913 }
73914 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderCorePropertiesARMBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target73915     fn deref_mut(&mut self) -> &mut Self::Target {
73916         &mut self.inner
73917     }
73918 }
73919 impl<'a> PhysicalDeviceShaderCorePropertiesARMBuilder<'a> {
73920     #[inline]
pixel_rate(mut self, pixel_rate: u32) -> Self73921     pub fn pixel_rate(mut self, pixel_rate: u32) -> Self {
73922         self.inner.pixel_rate = pixel_rate;
73923         self
73924     }
73925     #[inline]
texel_rate(mut self, texel_rate: u32) -> Self73926     pub fn texel_rate(mut self, texel_rate: u32) -> Self {
73927         self.inner.texel_rate = texel_rate;
73928         self
73929     }
73930     #[inline]
fma_rate(mut self, fma_rate: u32) -> Self73931     pub fn fma_rate(mut self, fma_rate: u32) -> Self {
73932         self.inner.fma_rate = fma_rate;
73933         self
73934     }
73935     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
73936     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
73937     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderCorePropertiesARM73938     pub fn build(self) -> PhysicalDeviceShaderCorePropertiesARM {
73939         self.inner
73940     }
73941 }
73942 #[repr(C)]
73943 #[cfg_attr(feature = "debug", derive(Debug))]
73944 #[derive(Copy, Clone)]
73945 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.html>"]
73946 pub struct PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM {
73947     pub s_type: StructureType,
73948     pub p_next: *mut c_void,
73949     pub multiview_per_view_render_areas: Bool32,
73950 }
73951 impl ::std::default::Default for PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM {
73952     #[inline]
default() -> Self73953     fn default() -> Self {
73954         Self {
73955             s_type: Self::STRUCTURE_TYPE,
73956             p_next: ::std::ptr::null_mut(),
73957             multiview_per_view_render_areas: Bool32::default(),
73958         }
73959     }
73960 }
73961 unsafe impl TaggedStructure for PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM {
73962     const STRUCTURE_TYPE: StructureType =
73963         StructureType::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM;
73964 }
73965 impl PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM {
builder<'a>() -> PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOMBuilder<'a>73966     pub fn builder<'a>() -> PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOMBuilder<'a> {
73967         PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOMBuilder {
73968             inner: Self::default(),
73969             marker: ::std::marker::PhantomData,
73970         }
73971     }
73972 }
73973 #[repr(transparent)]
73974 pub struct PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOMBuilder<'a> {
73975     inner: PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM,
73976     marker: ::std::marker::PhantomData<&'a ()>,
73977 }
73978 unsafe impl ExtendsPhysicalDeviceFeatures2
73979     for PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOMBuilder<'_>
73980 {
73981 }
73982 unsafe impl ExtendsPhysicalDeviceFeatures2
73983     for PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM
73984 {
73985 }
73986 unsafe impl ExtendsDeviceCreateInfo
73987     for PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOMBuilder<'_>
73988 {
73989 }
73990 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM {}
73991 impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOMBuilder<'a> {
73992     type Target = PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM;
deref(&self) -> &Self::Target73993     fn deref(&self) -> &Self::Target {
73994         &self.inner
73995     }
73996 }
73997 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOMBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target73998     fn deref_mut(&mut self) -> &mut Self::Target {
73999         &mut self.inner
74000     }
74001 }
74002 impl<'a> PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOMBuilder<'a> {
74003     #[inline]
multiview_per_view_render_areas( mut self, multiview_per_view_render_areas: bool, ) -> Self74004     pub fn multiview_per_view_render_areas(
74005         mut self,
74006         multiview_per_view_render_areas: bool,
74007     ) -> Self {
74008         self.inner.multiview_per_view_render_areas = multiview_per_view_render_areas.into();
74009         self
74010     }
74011     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
74012     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
74013     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM74014     pub fn build(self) -> PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM {
74015         self.inner
74016     }
74017 }
74018 #[repr(C)]
74019 #[cfg_attr(feature = "debug", derive(Debug))]
74020 #[derive(Copy, Clone)]
74021 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM.html>"]
74022 pub struct MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {
74023     pub s_type: StructureType,
74024     pub p_next: *const c_void,
74025     pub per_view_render_area_count: u32,
74026     pub p_per_view_render_areas: *const Rect2D,
74027 }
74028 impl ::std::default::Default for MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {
74029     #[inline]
default() -> Self74030     fn default() -> Self {
74031         Self {
74032             s_type: Self::STRUCTURE_TYPE,
74033             p_next: ::std::ptr::null(),
74034             per_view_render_area_count: u32::default(),
74035             p_per_view_render_areas: ::std::ptr::null(),
74036         }
74037     }
74038 }
74039 unsafe impl TaggedStructure for MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {
74040     const STRUCTURE_TYPE: StructureType =
74041         StructureType::MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM;
74042 }
74043 impl MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {
builder<'a>() -> MultiviewPerViewRenderAreasRenderPassBeginInfoQCOMBuilder<'a>74044     pub fn builder<'a>() -> MultiviewPerViewRenderAreasRenderPassBeginInfoQCOMBuilder<'a> {
74045         MultiviewPerViewRenderAreasRenderPassBeginInfoQCOMBuilder {
74046             inner: Self::default(),
74047             marker: ::std::marker::PhantomData,
74048         }
74049     }
74050 }
74051 #[repr(transparent)]
74052 pub struct MultiviewPerViewRenderAreasRenderPassBeginInfoQCOMBuilder<'a> {
74053     inner: MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM,
74054     marker: ::std::marker::PhantomData<&'a ()>,
74055 }
74056 unsafe impl ExtendsRenderPassBeginInfo
74057     for MultiviewPerViewRenderAreasRenderPassBeginInfoQCOMBuilder<'_>
74058 {
74059 }
74060 unsafe impl ExtendsRenderPassBeginInfo for MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {}
74061 unsafe impl ExtendsRenderingInfo for MultiviewPerViewRenderAreasRenderPassBeginInfoQCOMBuilder<'_> {}
74062 unsafe impl ExtendsRenderingInfo for MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {}
74063 impl<'a> ::std::ops::Deref for MultiviewPerViewRenderAreasRenderPassBeginInfoQCOMBuilder<'a> {
74064     type Target = MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM;
deref(&self) -> &Self::Target74065     fn deref(&self) -> &Self::Target {
74066         &self.inner
74067     }
74068 }
74069 impl<'a> ::std::ops::DerefMut for MultiviewPerViewRenderAreasRenderPassBeginInfoQCOMBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target74070     fn deref_mut(&mut self) -> &mut Self::Target {
74071         &mut self.inner
74072     }
74073 }
74074 impl<'a> MultiviewPerViewRenderAreasRenderPassBeginInfoQCOMBuilder<'a> {
74075     #[inline]
per_view_render_areas(mut self, per_view_render_areas: &'a [Rect2D]) -> Self74076     pub fn per_view_render_areas(mut self, per_view_render_areas: &'a [Rect2D]) -> Self {
74077         self.inner.per_view_render_area_count = per_view_render_areas.len() as _;
74078         self.inner.p_per_view_render_areas = per_view_render_areas.as_ptr();
74079         self
74080     }
74081     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
74082     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
74083     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM74084     pub fn build(self) -> MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {
74085         self.inner
74086     }
74087 }
74088 #[repr(C)]
74089 #[cfg_attr(feature = "debug", derive(Debug))]
74090 #[derive(Copy, Clone)]
74091 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryLowLatencySupportNV.html>"]
74092 pub struct QueryLowLatencySupportNV {
74093     pub s_type: StructureType,
74094     pub p_next: *const c_void,
74095     pub p_queried_low_latency_data: *mut c_void,
74096 }
74097 impl ::std::default::Default for QueryLowLatencySupportNV {
74098     #[inline]
default() -> Self74099     fn default() -> Self {
74100         Self {
74101             s_type: Self::STRUCTURE_TYPE,
74102             p_next: ::std::ptr::null(),
74103             p_queried_low_latency_data: ::std::ptr::null_mut(),
74104         }
74105     }
74106 }
74107 unsafe impl TaggedStructure for QueryLowLatencySupportNV {
74108     const STRUCTURE_TYPE: StructureType = StructureType::QUERY_LOW_LATENCY_SUPPORT_NV;
74109 }
74110 impl QueryLowLatencySupportNV {
builder<'a>() -> QueryLowLatencySupportNVBuilder<'a>74111     pub fn builder<'a>() -> QueryLowLatencySupportNVBuilder<'a> {
74112         QueryLowLatencySupportNVBuilder {
74113             inner: Self::default(),
74114             marker: ::std::marker::PhantomData,
74115         }
74116     }
74117 }
74118 #[repr(transparent)]
74119 pub struct QueryLowLatencySupportNVBuilder<'a> {
74120     inner: QueryLowLatencySupportNV,
74121     marker: ::std::marker::PhantomData<&'a ()>,
74122 }
74123 unsafe impl ExtendsSemaphoreCreateInfo for QueryLowLatencySupportNVBuilder<'_> {}
74124 unsafe impl ExtendsSemaphoreCreateInfo for QueryLowLatencySupportNV {}
74125 impl<'a> ::std::ops::Deref for QueryLowLatencySupportNVBuilder<'a> {
74126     type Target = QueryLowLatencySupportNV;
deref(&self) -> &Self::Target74127     fn deref(&self) -> &Self::Target {
74128         &self.inner
74129     }
74130 }
74131 impl<'a> ::std::ops::DerefMut for QueryLowLatencySupportNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target74132     fn deref_mut(&mut self) -> &mut Self::Target {
74133         &mut self.inner
74134     }
74135 }
74136 impl<'a> QueryLowLatencySupportNVBuilder<'a> {
74137     #[inline]
queried_low_latency_data(mut self, queried_low_latency_data: *mut c_void) -> Self74138     pub fn queried_low_latency_data(mut self, queried_low_latency_data: *mut c_void) -> Self {
74139         self.inner.p_queried_low_latency_data = queried_low_latency_data;
74140         self
74141     }
74142     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
74143     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
74144     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> QueryLowLatencySupportNV74145     pub fn build(self) -> QueryLowLatencySupportNV {
74146         self.inner
74147     }
74148 }
74149 #[repr(C)]
74150 #[cfg_attr(feature = "debug", derive(Debug))]
74151 #[derive(Copy, Clone)]
74152 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryMapInfoKHR.html>"]
74153 pub struct MemoryMapInfoKHR {
74154     pub s_type: StructureType,
74155     pub p_next: *const c_void,
74156     pub flags: MemoryMapFlags,
74157     pub memory: DeviceMemory,
74158     pub offset: DeviceSize,
74159     pub size: DeviceSize,
74160 }
74161 impl ::std::default::Default for MemoryMapInfoKHR {
74162     #[inline]
default() -> Self74163     fn default() -> Self {
74164         Self {
74165             s_type: Self::STRUCTURE_TYPE,
74166             p_next: ::std::ptr::null(),
74167             flags: MemoryMapFlags::default(),
74168             memory: DeviceMemory::default(),
74169             offset: DeviceSize::default(),
74170             size: DeviceSize::default(),
74171         }
74172     }
74173 }
74174 unsafe impl TaggedStructure for MemoryMapInfoKHR {
74175     const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_MAP_INFO_KHR;
74176 }
74177 impl MemoryMapInfoKHR {
builder<'a>() -> MemoryMapInfoKHRBuilder<'a>74178     pub fn builder<'a>() -> MemoryMapInfoKHRBuilder<'a> {
74179         MemoryMapInfoKHRBuilder {
74180             inner: Self::default(),
74181             marker: ::std::marker::PhantomData,
74182         }
74183     }
74184 }
74185 #[repr(transparent)]
74186 pub struct MemoryMapInfoKHRBuilder<'a> {
74187     inner: MemoryMapInfoKHR,
74188     marker: ::std::marker::PhantomData<&'a ()>,
74189 }
74190 impl<'a> ::std::ops::Deref for MemoryMapInfoKHRBuilder<'a> {
74191     type Target = MemoryMapInfoKHR;
deref(&self) -> &Self::Target74192     fn deref(&self) -> &Self::Target {
74193         &self.inner
74194     }
74195 }
74196 impl<'a> ::std::ops::DerefMut for MemoryMapInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target74197     fn deref_mut(&mut self) -> &mut Self::Target {
74198         &mut self.inner
74199     }
74200 }
74201 impl<'a> MemoryMapInfoKHRBuilder<'a> {
74202     #[inline]
flags(mut self, flags: MemoryMapFlags) -> Self74203     pub fn flags(mut self, flags: MemoryMapFlags) -> Self {
74204         self.inner.flags = flags;
74205         self
74206     }
74207     #[inline]
memory(mut self, memory: DeviceMemory) -> Self74208     pub fn memory(mut self, memory: DeviceMemory) -> Self {
74209         self.inner.memory = memory;
74210         self
74211     }
74212     #[inline]
offset(mut self, offset: DeviceSize) -> Self74213     pub fn offset(mut self, offset: DeviceSize) -> Self {
74214         self.inner.offset = offset;
74215         self
74216     }
74217     #[inline]
size(mut self, size: DeviceSize) -> Self74218     pub fn size(mut self, size: DeviceSize) -> Self {
74219         self.inner.size = size;
74220         self
74221     }
74222     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
74223     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
74224     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryMapInfoKHR74225     pub fn build(self) -> MemoryMapInfoKHR {
74226         self.inner
74227     }
74228 }
74229 #[repr(C)]
74230 #[cfg_attr(feature = "debug", derive(Debug))]
74231 #[derive(Copy, Clone)]
74232 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryUnmapInfoKHR.html>"]
74233 pub struct MemoryUnmapInfoKHR {
74234     pub s_type: StructureType,
74235     pub p_next: *const c_void,
74236     pub flags: MemoryUnmapFlagsKHR,
74237     pub memory: DeviceMemory,
74238 }
74239 impl ::std::default::Default for MemoryUnmapInfoKHR {
74240     #[inline]
default() -> Self74241     fn default() -> Self {
74242         Self {
74243             s_type: Self::STRUCTURE_TYPE,
74244             p_next: ::std::ptr::null(),
74245             flags: MemoryUnmapFlagsKHR::default(),
74246             memory: DeviceMemory::default(),
74247         }
74248     }
74249 }
74250 unsafe impl TaggedStructure for MemoryUnmapInfoKHR {
74251     const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_UNMAP_INFO_KHR;
74252 }
74253 impl MemoryUnmapInfoKHR {
builder<'a>() -> MemoryUnmapInfoKHRBuilder<'a>74254     pub fn builder<'a>() -> MemoryUnmapInfoKHRBuilder<'a> {
74255         MemoryUnmapInfoKHRBuilder {
74256             inner: Self::default(),
74257             marker: ::std::marker::PhantomData,
74258         }
74259     }
74260 }
74261 #[repr(transparent)]
74262 pub struct MemoryUnmapInfoKHRBuilder<'a> {
74263     inner: MemoryUnmapInfoKHR,
74264     marker: ::std::marker::PhantomData<&'a ()>,
74265 }
74266 impl<'a> ::std::ops::Deref for MemoryUnmapInfoKHRBuilder<'a> {
74267     type Target = MemoryUnmapInfoKHR;
deref(&self) -> &Self::Target74268     fn deref(&self) -> &Self::Target {
74269         &self.inner
74270     }
74271 }
74272 impl<'a> ::std::ops::DerefMut for MemoryUnmapInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target74273     fn deref_mut(&mut self) -> &mut Self::Target {
74274         &mut self.inner
74275     }
74276 }
74277 impl<'a> MemoryUnmapInfoKHRBuilder<'a> {
74278     #[inline]
flags(mut self, flags: MemoryUnmapFlagsKHR) -> Self74279     pub fn flags(mut self, flags: MemoryUnmapFlagsKHR) -> Self {
74280         self.inner.flags = flags;
74281         self
74282     }
74283     #[inline]
memory(mut self, memory: DeviceMemory) -> Self74284     pub fn memory(mut self, memory: DeviceMemory) -> Self {
74285         self.inner.memory = memory;
74286         self
74287     }
74288     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
74289     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
74290     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryUnmapInfoKHR74291     pub fn build(self) -> MemoryUnmapInfoKHR {
74292         self.inner
74293     }
74294 }
74295 #[repr(C)]
74296 #[cfg_attr(feature = "debug", derive(Debug))]
74297 #[derive(Copy, Clone)]
74298 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderObjectFeaturesEXT.html>"]
74299 pub struct PhysicalDeviceShaderObjectFeaturesEXT {
74300     pub s_type: StructureType,
74301     pub p_next: *mut c_void,
74302     pub shader_object: Bool32,
74303 }
74304 impl ::std::default::Default for PhysicalDeviceShaderObjectFeaturesEXT {
74305     #[inline]
default() -> Self74306     fn default() -> Self {
74307         Self {
74308             s_type: Self::STRUCTURE_TYPE,
74309             p_next: ::std::ptr::null_mut(),
74310             shader_object: Bool32::default(),
74311         }
74312     }
74313 }
74314 unsafe impl TaggedStructure for PhysicalDeviceShaderObjectFeaturesEXT {
74315     const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT;
74316 }
74317 impl PhysicalDeviceShaderObjectFeaturesEXT {
builder<'a>() -> PhysicalDeviceShaderObjectFeaturesEXTBuilder<'a>74318     pub fn builder<'a>() -> PhysicalDeviceShaderObjectFeaturesEXTBuilder<'a> {
74319         PhysicalDeviceShaderObjectFeaturesEXTBuilder {
74320             inner: Self::default(),
74321             marker: ::std::marker::PhantomData,
74322         }
74323     }
74324 }
74325 #[repr(transparent)]
74326 pub struct PhysicalDeviceShaderObjectFeaturesEXTBuilder<'a> {
74327     inner: PhysicalDeviceShaderObjectFeaturesEXT,
74328     marker: ::std::marker::PhantomData<&'a ()>,
74329 }
74330 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderObjectFeaturesEXTBuilder<'_> {}
74331 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderObjectFeaturesEXT {}
74332 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderObjectFeaturesEXTBuilder<'_> {}
74333 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderObjectFeaturesEXT {}
74334 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderObjectFeaturesEXTBuilder<'a> {
74335     type Target = PhysicalDeviceShaderObjectFeaturesEXT;
deref(&self) -> &Self::Target74336     fn deref(&self) -> &Self::Target {
74337         &self.inner
74338     }
74339 }
74340 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderObjectFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target74341     fn deref_mut(&mut self) -> &mut Self::Target {
74342         &mut self.inner
74343     }
74344 }
74345 impl<'a> PhysicalDeviceShaderObjectFeaturesEXTBuilder<'a> {
74346     #[inline]
shader_object(mut self, shader_object: bool) -> Self74347     pub fn shader_object(mut self, shader_object: bool) -> Self {
74348         self.inner.shader_object = shader_object.into();
74349         self
74350     }
74351     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
74352     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
74353     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderObjectFeaturesEXT74354     pub fn build(self) -> PhysicalDeviceShaderObjectFeaturesEXT {
74355         self.inner
74356     }
74357 }
74358 #[repr(C)]
74359 #[cfg_attr(feature = "debug", derive(Debug))]
74360 #[derive(Copy, Clone)]
74361 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderObjectPropertiesEXT.html>"]
74362 pub struct PhysicalDeviceShaderObjectPropertiesEXT {
74363     pub s_type: StructureType,
74364     pub p_next: *mut c_void,
74365     pub shader_binary_uuid: [u8; UUID_SIZE],
74366     pub shader_binary_version: u32,
74367 }
74368 impl ::std::default::Default for PhysicalDeviceShaderObjectPropertiesEXT {
74369     #[inline]
default() -> Self74370     fn default() -> Self {
74371         Self {
74372             s_type: Self::STRUCTURE_TYPE,
74373             p_next: ::std::ptr::null_mut(),
74374             shader_binary_uuid: unsafe { ::std::mem::zeroed() },
74375             shader_binary_version: u32::default(),
74376         }
74377     }
74378 }
74379 unsafe impl TaggedStructure for PhysicalDeviceShaderObjectPropertiesEXT {
74380     const STRUCTURE_TYPE: StructureType =
74381         StructureType::PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT;
74382 }
74383 impl PhysicalDeviceShaderObjectPropertiesEXT {
builder<'a>() -> PhysicalDeviceShaderObjectPropertiesEXTBuilder<'a>74384     pub fn builder<'a>() -> PhysicalDeviceShaderObjectPropertiesEXTBuilder<'a> {
74385         PhysicalDeviceShaderObjectPropertiesEXTBuilder {
74386             inner: Self::default(),
74387             marker: ::std::marker::PhantomData,
74388         }
74389     }
74390 }
74391 #[repr(transparent)]
74392 pub struct PhysicalDeviceShaderObjectPropertiesEXTBuilder<'a> {
74393     inner: PhysicalDeviceShaderObjectPropertiesEXT,
74394     marker: ::std::marker::PhantomData<&'a ()>,
74395 }
74396 unsafe impl ExtendsPhysicalDeviceProperties2
74397     for PhysicalDeviceShaderObjectPropertiesEXTBuilder<'_>
74398 {
74399 }
74400 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderObjectPropertiesEXT {}
74401 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderObjectPropertiesEXTBuilder<'a> {
74402     type Target = PhysicalDeviceShaderObjectPropertiesEXT;
deref(&self) -> &Self::Target74403     fn deref(&self) -> &Self::Target {
74404         &self.inner
74405     }
74406 }
74407 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderObjectPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target74408     fn deref_mut(&mut self) -> &mut Self::Target {
74409         &mut self.inner
74410     }
74411 }
74412 impl<'a> PhysicalDeviceShaderObjectPropertiesEXTBuilder<'a> {
74413     #[inline]
shader_binary_uuid(mut self, shader_binary_uuid: [u8; UUID_SIZE]) -> Self74414     pub fn shader_binary_uuid(mut self, shader_binary_uuid: [u8; UUID_SIZE]) -> Self {
74415         self.inner.shader_binary_uuid = shader_binary_uuid;
74416         self
74417     }
74418     #[inline]
shader_binary_version(mut self, shader_binary_version: u32) -> Self74419     pub fn shader_binary_version(mut self, shader_binary_version: u32) -> Self {
74420         self.inner.shader_binary_version = shader_binary_version;
74421         self
74422     }
74423     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
74424     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
74425     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderObjectPropertiesEXT74426     pub fn build(self) -> PhysicalDeviceShaderObjectPropertiesEXT {
74427         self.inner
74428     }
74429 }
74430 #[repr(C)]
74431 #[cfg_attr(feature = "debug", derive(Debug))]
74432 #[derive(Copy, Clone)]
74433 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderCreateInfoEXT.html>"]
74434 pub struct ShaderCreateInfoEXT {
74435     pub s_type: StructureType,
74436     pub p_next: *const c_void,
74437     pub flags: ShaderCreateFlagsEXT,
74438     pub stage: ShaderStageFlags,
74439     pub next_stage: ShaderStageFlags,
74440     pub code_type: ShaderCodeTypeEXT,
74441     pub code_size: usize,
74442     pub p_code: *const c_void,
74443     pub p_name: *const c_char,
74444     pub set_layout_count: u32,
74445     pub p_set_layouts: *const DescriptorSetLayout,
74446     pub push_constant_range_count: u32,
74447     pub p_push_constant_ranges: *const PushConstantRange,
74448     pub p_specialization_info: *const SpecializationInfo,
74449 }
74450 impl ::std::default::Default for ShaderCreateInfoEXT {
74451     #[inline]
default() -> Self74452     fn default() -> Self {
74453         Self {
74454             s_type: Self::STRUCTURE_TYPE,
74455             p_next: ::std::ptr::null(),
74456             flags: ShaderCreateFlagsEXT::default(),
74457             stage: ShaderStageFlags::default(),
74458             next_stage: ShaderStageFlags::default(),
74459             code_type: ShaderCodeTypeEXT::default(),
74460             code_size: usize::default(),
74461             p_code: ::std::ptr::null(),
74462             p_name: ::std::ptr::null(),
74463             set_layout_count: u32::default(),
74464             p_set_layouts: ::std::ptr::null(),
74465             push_constant_range_count: u32::default(),
74466             p_push_constant_ranges: ::std::ptr::null(),
74467             p_specialization_info: ::std::ptr::null(),
74468         }
74469     }
74470 }
74471 unsafe impl TaggedStructure for ShaderCreateInfoEXT {
74472     const STRUCTURE_TYPE: StructureType = StructureType::SHADER_CREATE_INFO_EXT;
74473 }
74474 impl ShaderCreateInfoEXT {
builder<'a>() -> ShaderCreateInfoEXTBuilder<'a>74475     pub fn builder<'a>() -> ShaderCreateInfoEXTBuilder<'a> {
74476         ShaderCreateInfoEXTBuilder {
74477             inner: Self::default(),
74478             marker: ::std::marker::PhantomData,
74479         }
74480     }
74481 }
74482 #[repr(transparent)]
74483 pub struct ShaderCreateInfoEXTBuilder<'a> {
74484     inner: ShaderCreateInfoEXT,
74485     marker: ::std::marker::PhantomData<&'a ()>,
74486 }
74487 pub unsafe trait ExtendsShaderCreateInfoEXT {}
74488 impl<'a> ::std::ops::Deref for ShaderCreateInfoEXTBuilder<'a> {
74489     type Target = ShaderCreateInfoEXT;
deref(&self) -> &Self::Target74490     fn deref(&self) -> &Self::Target {
74491         &self.inner
74492     }
74493 }
74494 impl<'a> ::std::ops::DerefMut for ShaderCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target74495     fn deref_mut(&mut self) -> &mut Self::Target {
74496         &mut self.inner
74497     }
74498 }
74499 impl<'a> ShaderCreateInfoEXTBuilder<'a> {
74500     #[inline]
flags(mut self, flags: ShaderCreateFlagsEXT) -> Self74501     pub fn flags(mut self, flags: ShaderCreateFlagsEXT) -> Self {
74502         self.inner.flags = flags;
74503         self
74504     }
74505     #[inline]
stage(mut self, stage: ShaderStageFlags) -> Self74506     pub fn stage(mut self, stage: ShaderStageFlags) -> Self {
74507         self.inner.stage = stage;
74508         self
74509     }
74510     #[inline]
next_stage(mut self, next_stage: ShaderStageFlags) -> Self74511     pub fn next_stage(mut self, next_stage: ShaderStageFlags) -> Self {
74512         self.inner.next_stage = next_stage;
74513         self
74514     }
74515     #[inline]
code_type(mut self, code_type: ShaderCodeTypeEXT) -> Self74516     pub fn code_type(mut self, code_type: ShaderCodeTypeEXT) -> Self {
74517         self.inner.code_type = code_type;
74518         self
74519     }
74520     #[inline]
code(mut self, code: &'a [u8]) -> Self74521     pub fn code(mut self, code: &'a [u8]) -> Self {
74522         self.inner.code_size = code.len();
74523         self.inner.p_code = code.as_ptr().cast();
74524         self
74525     }
74526     #[inline]
name(mut self, name: &'a ::std::ffi::CStr) -> Self74527     pub fn name(mut self, name: &'a ::std::ffi::CStr) -> Self {
74528         self.inner.p_name = name.as_ptr();
74529         self
74530     }
74531     #[inline]
set_layouts(mut self, set_layouts: &'a [DescriptorSetLayout]) -> Self74532     pub fn set_layouts(mut self, set_layouts: &'a [DescriptorSetLayout]) -> Self {
74533         self.inner.set_layout_count = set_layouts.len() as _;
74534         self.inner.p_set_layouts = set_layouts.as_ptr();
74535         self
74536     }
74537     #[inline]
push_constant_ranges(mut self, push_constant_ranges: &'a [PushConstantRange]) -> Self74538     pub fn push_constant_ranges(mut self, push_constant_ranges: &'a [PushConstantRange]) -> Self {
74539         self.inner.push_constant_range_count = push_constant_ranges.len() as _;
74540         self.inner.p_push_constant_ranges = push_constant_ranges.as_ptr();
74541         self
74542     }
74543     #[inline]
specialization_info(mut self, specialization_info: &'a SpecializationInfo) -> Self74544     pub fn specialization_info(mut self, specialization_info: &'a SpecializationInfo) -> Self {
74545         self.inner.p_specialization_info = specialization_info;
74546         self
74547     }
74548     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
74549     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
74550     #[doc = r" valid extension structs can be pushed into the chain."]
74551     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
74552     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsShaderCreateInfoEXT>(mut self, next: &'a mut T) -> Self74553     pub fn push_next<T: ExtendsShaderCreateInfoEXT>(mut self, next: &'a mut T) -> Self {
74554         unsafe {
74555             let next_ptr = <*const T>::cast(next);
74556             let last_next = ptr_chain_iter(next).last().unwrap();
74557             (*last_next).p_next = self.inner.p_next as _;
74558             self.inner.p_next = next_ptr;
74559         }
74560         self
74561     }
74562     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
74563     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
74564     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ShaderCreateInfoEXT74565     pub fn build(self) -> ShaderCreateInfoEXT {
74566         self.inner
74567     }
74568 }
74569 #[repr(C)]
74570 #[cfg_attr(feature = "debug", derive(Debug))]
74571 #[derive(Copy, Clone)]
74572 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderTileImageFeaturesEXT.html>"]
74573 pub struct PhysicalDeviceShaderTileImageFeaturesEXT {
74574     pub s_type: StructureType,
74575     pub p_next: *mut c_void,
74576     pub shader_tile_image_color_read_access: Bool32,
74577     pub shader_tile_image_depth_read_access: Bool32,
74578     pub shader_tile_image_stencil_read_access: Bool32,
74579 }
74580 impl ::std::default::Default for PhysicalDeviceShaderTileImageFeaturesEXT {
74581     #[inline]
default() -> Self74582     fn default() -> Self {
74583         Self {
74584             s_type: Self::STRUCTURE_TYPE,
74585             p_next: ::std::ptr::null_mut(),
74586             shader_tile_image_color_read_access: Bool32::default(),
74587             shader_tile_image_depth_read_access: Bool32::default(),
74588             shader_tile_image_stencil_read_access: Bool32::default(),
74589         }
74590     }
74591 }
74592 unsafe impl TaggedStructure for PhysicalDeviceShaderTileImageFeaturesEXT {
74593     const STRUCTURE_TYPE: StructureType =
74594         StructureType::PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT;
74595 }
74596 impl PhysicalDeviceShaderTileImageFeaturesEXT {
builder<'a>() -> PhysicalDeviceShaderTileImageFeaturesEXTBuilder<'a>74597     pub fn builder<'a>() -> PhysicalDeviceShaderTileImageFeaturesEXTBuilder<'a> {
74598         PhysicalDeviceShaderTileImageFeaturesEXTBuilder {
74599             inner: Self::default(),
74600             marker: ::std::marker::PhantomData,
74601         }
74602     }
74603 }
74604 #[repr(transparent)]
74605 pub struct PhysicalDeviceShaderTileImageFeaturesEXTBuilder<'a> {
74606     inner: PhysicalDeviceShaderTileImageFeaturesEXT,
74607     marker: ::std::marker::PhantomData<&'a ()>,
74608 }
74609 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderTileImageFeaturesEXTBuilder<'_> {}
74610 unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderTileImageFeaturesEXT {}
74611 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderTileImageFeaturesEXTBuilder<'_> {}
74612 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderTileImageFeaturesEXT {}
74613 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderTileImageFeaturesEXTBuilder<'a> {
74614     type Target = PhysicalDeviceShaderTileImageFeaturesEXT;
deref(&self) -> &Self::Target74615     fn deref(&self) -> &Self::Target {
74616         &self.inner
74617     }
74618 }
74619 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderTileImageFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target74620     fn deref_mut(&mut self) -> &mut Self::Target {
74621         &mut self.inner
74622     }
74623 }
74624 impl<'a> PhysicalDeviceShaderTileImageFeaturesEXTBuilder<'a> {
74625     #[inline]
shader_tile_image_color_read_access( mut self, shader_tile_image_color_read_access: bool, ) -> Self74626     pub fn shader_tile_image_color_read_access(
74627         mut self,
74628         shader_tile_image_color_read_access: bool,
74629     ) -> Self {
74630         self.inner.shader_tile_image_color_read_access = shader_tile_image_color_read_access.into();
74631         self
74632     }
74633     #[inline]
shader_tile_image_depth_read_access( mut self, shader_tile_image_depth_read_access: bool, ) -> Self74634     pub fn shader_tile_image_depth_read_access(
74635         mut self,
74636         shader_tile_image_depth_read_access: bool,
74637     ) -> Self {
74638         self.inner.shader_tile_image_depth_read_access = shader_tile_image_depth_read_access.into();
74639         self
74640     }
74641     #[inline]
shader_tile_image_stencil_read_access( mut self, shader_tile_image_stencil_read_access: bool, ) -> Self74642     pub fn shader_tile_image_stencil_read_access(
74643         mut self,
74644         shader_tile_image_stencil_read_access: bool,
74645     ) -> Self {
74646         self.inner.shader_tile_image_stencil_read_access =
74647             shader_tile_image_stencil_read_access.into();
74648         self
74649     }
74650     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
74651     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
74652     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderTileImageFeaturesEXT74653     pub fn build(self) -> PhysicalDeviceShaderTileImageFeaturesEXT {
74654         self.inner
74655     }
74656 }
74657 #[repr(C)]
74658 #[cfg_attr(feature = "debug", derive(Debug))]
74659 #[derive(Copy, Clone)]
74660 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderTileImagePropertiesEXT.html>"]
74661 pub struct PhysicalDeviceShaderTileImagePropertiesEXT {
74662     pub s_type: StructureType,
74663     pub p_next: *mut c_void,
74664     pub shader_tile_image_coherent_read_accelerated: Bool32,
74665     pub shader_tile_image_read_sample_from_pixel_rate_invocation: Bool32,
74666     pub shader_tile_image_read_from_helper_invocation: Bool32,
74667 }
74668 impl ::std::default::Default for PhysicalDeviceShaderTileImagePropertiesEXT {
74669     #[inline]
default() -> Self74670     fn default() -> Self {
74671         Self {
74672             s_type: Self::STRUCTURE_TYPE,
74673             p_next: ::std::ptr::null_mut(),
74674             shader_tile_image_coherent_read_accelerated: Bool32::default(),
74675             shader_tile_image_read_sample_from_pixel_rate_invocation: Bool32::default(),
74676             shader_tile_image_read_from_helper_invocation: Bool32::default(),
74677         }
74678     }
74679 }
74680 unsafe impl TaggedStructure for PhysicalDeviceShaderTileImagePropertiesEXT {
74681     const STRUCTURE_TYPE: StructureType =
74682         StructureType::PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT;
74683 }
74684 impl PhysicalDeviceShaderTileImagePropertiesEXT {
builder<'a>() -> PhysicalDeviceShaderTileImagePropertiesEXTBuilder<'a>74685     pub fn builder<'a>() -> PhysicalDeviceShaderTileImagePropertiesEXTBuilder<'a> {
74686         PhysicalDeviceShaderTileImagePropertiesEXTBuilder {
74687             inner: Self::default(),
74688             marker: ::std::marker::PhantomData,
74689         }
74690     }
74691 }
74692 #[repr(transparent)]
74693 pub struct PhysicalDeviceShaderTileImagePropertiesEXTBuilder<'a> {
74694     inner: PhysicalDeviceShaderTileImagePropertiesEXT,
74695     marker: ::std::marker::PhantomData<&'a ()>,
74696 }
74697 unsafe impl ExtendsPhysicalDeviceProperties2
74698     for PhysicalDeviceShaderTileImagePropertiesEXTBuilder<'_>
74699 {
74700 }
74701 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderTileImagePropertiesEXT {}
74702 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderTileImagePropertiesEXTBuilder<'a> {
74703     type Target = PhysicalDeviceShaderTileImagePropertiesEXT;
deref(&self) -> &Self::Target74704     fn deref(&self) -> &Self::Target {
74705         &self.inner
74706     }
74707 }
74708 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderTileImagePropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target74709     fn deref_mut(&mut self) -> &mut Self::Target {
74710         &mut self.inner
74711     }
74712 }
74713 impl<'a> PhysicalDeviceShaderTileImagePropertiesEXTBuilder<'a> {
74714     #[inline]
shader_tile_image_coherent_read_accelerated( mut self, shader_tile_image_coherent_read_accelerated: bool, ) -> Self74715     pub fn shader_tile_image_coherent_read_accelerated(
74716         mut self,
74717         shader_tile_image_coherent_read_accelerated: bool,
74718     ) -> Self {
74719         self.inner.shader_tile_image_coherent_read_accelerated =
74720             shader_tile_image_coherent_read_accelerated.into();
74721         self
74722     }
74723     #[inline]
shader_tile_image_read_sample_from_pixel_rate_invocation( mut self, shader_tile_image_read_sample_from_pixel_rate_invocation: bool, ) -> Self74724     pub fn shader_tile_image_read_sample_from_pixel_rate_invocation(
74725         mut self,
74726         shader_tile_image_read_sample_from_pixel_rate_invocation: bool,
74727     ) -> Self {
74728         self.inner
74729             .shader_tile_image_read_sample_from_pixel_rate_invocation =
74730             shader_tile_image_read_sample_from_pixel_rate_invocation.into();
74731         self
74732     }
74733     #[inline]
shader_tile_image_read_from_helper_invocation( mut self, shader_tile_image_read_from_helper_invocation: bool, ) -> Self74734     pub fn shader_tile_image_read_from_helper_invocation(
74735         mut self,
74736         shader_tile_image_read_from_helper_invocation: bool,
74737     ) -> Self {
74738         self.inner.shader_tile_image_read_from_helper_invocation =
74739             shader_tile_image_read_from_helper_invocation.into();
74740         self
74741     }
74742     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
74743     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
74744     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderTileImagePropertiesEXT74745     pub fn build(self) -> PhysicalDeviceShaderTileImagePropertiesEXT {
74746         self.inner
74747     }
74748 }
74749