1use crate::vk::aliases::*;
2use crate::vk::bitflags::*;
3use crate::vk::constants::*;
4use crate::vk::enums::*;
5use crate::vk::native::*;
6use crate::vk::platform_types::*;
7use crate::vk::prelude::*;
8use crate::vk::{ptr_chain_iter, Handle};
9use std::fmt;
10use 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>"]
13pub 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>"]
18pub 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>"]
23pub 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>"]
28pub 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>"]
32pub 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>"]
36pub 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>"]
40pub 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>"]
44pub 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>"]
48pub 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>"]
52pub 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>"]
54pub 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>"]
56pub 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>"]
58pub const API_VERSION_1_3: u32 = make_api_version(0, 1, 3, 0);
59pub const HEADER_VERSION: u32 = 209u32;
60#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_HEADER_VERSION_COMPLETE.html>"]
61pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 3, HEADER_VERSION);
62#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSampleMask.html>"]
63pub type SampleMask = u32;
64#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBool32.html>"]
65pub type Bool32 = u32;
66#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFlags.html>"]
67pub type Flags = u32;
68#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFlags64.html>"]
69pub type Flags64 = u64;
70#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceSize.html>"]
71pub type DeviceSize = u64;
72#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceAddress.html>"]
73pub type DeviceAddress = u64;
74#[repr(transparent)]
75#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
76#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPoolCreateFlags.html>"]
77pub struct QueryPoolCreateFlags(pub(crate) Flags);
78vk_bitflags_wrapped!(QueryPoolCreateFlags, Flags);
79#[repr(transparent)]
80#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
81#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDynamicStateCreateFlags.html>"]
82pub struct PipelineDynamicStateCreateFlags(pub(crate) Flags);
83vk_bitflags_wrapped!(PipelineDynamicStateCreateFlags, Flags);
84#[repr(transparent)]
85#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
86#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineMultisampleStateCreateFlags.html>"]
87pub struct PipelineMultisampleStateCreateFlags(pub(crate) Flags);
88vk_bitflags_wrapped!(PipelineMultisampleStateCreateFlags, Flags);
89#[repr(transparent)]
90#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
91#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationStateCreateFlags.html>"]
92pub struct PipelineRasterizationStateCreateFlags(pub(crate) Flags);
93vk_bitflags_wrapped!(PipelineRasterizationStateCreateFlags, Flags);
94#[repr(transparent)]
95#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
96#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportStateCreateFlags.html>"]
97pub struct PipelineViewportStateCreateFlags(pub(crate) Flags);
98vk_bitflags_wrapped!(PipelineViewportStateCreateFlags, Flags);
99#[repr(transparent)]
100#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
101#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineTessellationStateCreateFlags.html>"]
102pub struct PipelineTessellationStateCreateFlags(pub(crate) Flags);
103vk_bitflags_wrapped!(PipelineTessellationStateCreateFlags, Flags);
104#[repr(transparent)]
105#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
106#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineInputAssemblyStateCreateFlags.html>"]
107pub struct PipelineInputAssemblyStateCreateFlags(pub(crate) Flags);
108vk_bitflags_wrapped!(PipelineInputAssemblyStateCreateFlags, Flags);
109#[repr(transparent)]
110#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
111#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineVertexInputStateCreateFlags.html>"]
112pub struct PipelineVertexInputStateCreateFlags(pub(crate) Flags);
113vk_bitflags_wrapped!(PipelineVertexInputStateCreateFlags, Flags);
114#[repr(transparent)]
115#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
116#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferViewCreateFlags.html>"]
117pub struct BufferViewCreateFlags(pub(crate) Flags);
118vk_bitflags_wrapped!(BufferViewCreateFlags, Flags);
119#[repr(transparent)]
120#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
121#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceCreateFlags.html>"]
122pub struct DeviceCreateFlags(pub(crate) Flags);
123vk_bitflags_wrapped!(DeviceCreateFlags, Flags);
124#[repr(transparent)]
125#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
126#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryMapFlags.html>"]
127pub struct MemoryMapFlags(pub(crate) Flags);
128vk_bitflags_wrapped!(MemoryMapFlags, Flags);
129#[repr(transparent)]
130#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
131#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPoolResetFlags.html>"]
132pub struct DescriptorPoolResetFlags(pub(crate) Flags);
133vk_bitflags_wrapped!(DescriptorPoolResetFlags, Flags);
134#[repr(transparent)]
135#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
136#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorUpdateTemplateCreateFlags.html>"]
137pub struct DescriptorUpdateTemplateCreateFlags(pub(crate) Flags);
138vk_bitflags_wrapped!(DescriptorUpdateTemplateCreateFlags, Flags);
139#[repr(transparent)]
140#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
141#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMotionInfoFlagsNV.html>"]
142pub struct AccelerationStructureMotionInfoFlagsNV(pub(crate) Flags);
143vk_bitflags_wrapped!(AccelerationStructureMotionInfoFlagsNV, Flags);
144#[repr(transparent)]
145#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
146#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMotionInstanceFlagsNV.html>"]
147pub struct AccelerationStructureMotionInstanceFlagsNV(pub(crate) Flags);
148vk_bitflags_wrapped!(AccelerationStructureMotionInstanceFlagsNV, Flags);
149#[repr(transparent)]
150#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
151#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModeCreateFlagsKHR.html>"]
152pub struct DisplayModeCreateFlagsKHR(pub(crate) Flags);
153vk_bitflags_wrapped!(DisplayModeCreateFlagsKHR, Flags);
154#[repr(transparent)]
155#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
156#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplaySurfaceCreateFlagsKHR.html>"]
157pub struct DisplaySurfaceCreateFlagsKHR(pub(crate) Flags);
158vk_bitflags_wrapped!(DisplaySurfaceCreateFlagsKHR, Flags);
159#[repr(transparent)]
160#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
161#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAndroidSurfaceCreateFlagsKHR.html>"]
162pub struct AndroidSurfaceCreateFlagsKHR(pub(crate) Flags);
163vk_bitflags_wrapped!(AndroidSurfaceCreateFlagsKHR, Flags);
164#[repr(transparent)]
165#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
166#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkViSurfaceCreateFlagsNN.html>"]
167pub struct ViSurfaceCreateFlagsNN(pub(crate) Flags);
168vk_bitflags_wrapped!(ViSurfaceCreateFlagsNN, Flags);
169#[repr(transparent)]
170#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
171#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWaylandSurfaceCreateFlagsKHR.html>"]
172pub struct WaylandSurfaceCreateFlagsKHR(pub(crate) Flags);
173vk_bitflags_wrapped!(WaylandSurfaceCreateFlagsKHR, Flags);
174#[repr(transparent)]
175#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
176#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWin32SurfaceCreateFlagsKHR.html>"]
177pub struct Win32SurfaceCreateFlagsKHR(pub(crate) Flags);
178vk_bitflags_wrapped!(Win32SurfaceCreateFlagsKHR, Flags);
179#[repr(transparent)]
180#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
181#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkXlibSurfaceCreateFlagsKHR.html>"]
182pub struct XlibSurfaceCreateFlagsKHR(pub(crate) Flags);
183vk_bitflags_wrapped!(XlibSurfaceCreateFlagsKHR, Flags);
184#[repr(transparent)]
185#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
186#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkXcbSurfaceCreateFlagsKHR.html>"]
187pub struct XcbSurfaceCreateFlagsKHR(pub(crate) Flags);
188vk_bitflags_wrapped!(XcbSurfaceCreateFlagsKHR, Flags);
189#[repr(transparent)]
190#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
191#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDirectFBSurfaceCreateFlagsEXT.html>"]
192pub struct DirectFBSurfaceCreateFlagsEXT(pub(crate) Flags);
193vk_bitflags_wrapped!(DirectFBSurfaceCreateFlagsEXT, Flags);
194#[repr(transparent)]
195#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
196#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIOSSurfaceCreateFlagsMVK.html>"]
197pub struct IOSSurfaceCreateFlagsMVK(pub(crate) Flags);
198vk_bitflags_wrapped!(IOSSurfaceCreateFlagsMVK, Flags);
199#[repr(transparent)]
200#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
201#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMacOSSurfaceCreateFlagsMVK.html>"]
202pub struct MacOSSurfaceCreateFlagsMVK(pub(crate) Flags);
203vk_bitflags_wrapped!(MacOSSurfaceCreateFlagsMVK, Flags);
204#[repr(transparent)]
205#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
206#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMetalSurfaceCreateFlagsEXT.html>"]
207pub struct MetalSurfaceCreateFlagsEXT(pub(crate) Flags);
208vk_bitflags_wrapped!(MetalSurfaceCreateFlagsEXT, Flags);
209#[repr(transparent)]
210#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
211#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImagePipeSurfaceCreateFlagsFUCHSIA.html>"]
212pub struct ImagePipeSurfaceCreateFlagsFUCHSIA(pub(crate) Flags);
213vk_bitflags_wrapped!(ImagePipeSurfaceCreateFlagsFUCHSIA, Flags);
214#[repr(transparent)]
215#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
216#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkStreamDescriptorSurfaceCreateFlagsGGP.html>"]
217pub struct StreamDescriptorSurfaceCreateFlagsGGP(pub(crate) Flags);
218vk_bitflags_wrapped!(StreamDescriptorSurfaceCreateFlagsGGP, Flags);
219#[repr(transparent)]
220#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
221#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkHeadlessSurfaceCreateFlagsEXT.html>"]
222pub struct HeadlessSurfaceCreateFlagsEXT(pub(crate) Flags);
223vk_bitflags_wrapped!(HeadlessSurfaceCreateFlagsEXT, Flags);
224#[repr(transparent)]
225#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
226#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkScreenSurfaceCreateFlagsQNX.html>"]
227pub struct ScreenSurfaceCreateFlagsQNX(pub(crate) Flags);
228vk_bitflags_wrapped!(ScreenSurfaceCreateFlagsQNX, Flags);
229#[repr(transparent)]
230#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
231#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandPoolTrimFlags.html>"]
232pub struct CommandPoolTrimFlags(pub(crate) Flags);
233vk_bitflags_wrapped!(CommandPoolTrimFlags, Flags);
234#[repr(transparent)]
235#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
236#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportSwizzleStateCreateFlagsNV.html>"]
237pub struct PipelineViewportSwizzleStateCreateFlagsNV(pub(crate) Flags);
238vk_bitflags_wrapped!(PipelineViewportSwizzleStateCreateFlagsNV, Flags);
239#[repr(transparent)]
240#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
241#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDiscardRectangleStateCreateFlagsEXT.html>"]
242pub struct PipelineDiscardRectangleStateCreateFlagsEXT(pub(crate) Flags);
243vk_bitflags_wrapped!(PipelineDiscardRectangleStateCreateFlagsEXT, Flags);
244#[repr(transparent)]
245#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
246#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageToColorStateCreateFlagsNV.html>"]
247pub struct PipelineCoverageToColorStateCreateFlagsNV(pub(crate) Flags);
248vk_bitflags_wrapped!(PipelineCoverageToColorStateCreateFlagsNV, Flags);
249#[repr(transparent)]
250#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
251#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageModulationStateCreateFlagsNV.html>"]
252pub struct PipelineCoverageModulationStateCreateFlagsNV(pub(crate) Flags);
253vk_bitflags_wrapped!(PipelineCoverageModulationStateCreateFlagsNV, Flags);
254#[repr(transparent)]
255#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
256#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageReductionStateCreateFlagsNV.html>"]
257pub struct PipelineCoverageReductionStateCreateFlagsNV(pub(crate) Flags);
258vk_bitflags_wrapped!(PipelineCoverageReductionStateCreateFlagsNV, Flags);
259#[repr(transparent)]
260#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
261#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationCacheCreateFlagsEXT.html>"]
262pub struct ValidationCacheCreateFlagsEXT(pub(crate) Flags);
263vk_bitflags_wrapped!(ValidationCacheCreateFlagsEXT, Flags);
264#[repr(transparent)]
265#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
266#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessengerCreateFlagsEXT.html>"]
267pub struct DebugUtilsMessengerCreateFlagsEXT(pub(crate) Flags);
268vk_bitflags_wrapped!(DebugUtilsMessengerCreateFlagsEXT, Flags);
269#[repr(transparent)]
270#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
271#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessengerCallbackDataFlagsEXT.html>"]
272pub struct DebugUtilsMessengerCallbackDataFlagsEXT(pub(crate) Flags);
273vk_bitflags_wrapped!(DebugUtilsMessengerCallbackDataFlagsEXT, Flags);
274#[repr(transparent)]
275#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
276#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceMemoryReportFlagsEXT.html>"]
277pub struct DeviceMemoryReportFlagsEXT(pub(crate) Flags);
278vk_bitflags_wrapped!(DeviceMemoryReportFlagsEXT, Flags);
279#[repr(transparent)]
280#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
281#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationConservativeStateCreateFlagsEXT.html>"]
282pub struct PipelineRasterizationConservativeStateCreateFlagsEXT(pub(crate) Flags);
283vk_bitflags_wrapped!(PipelineRasterizationConservativeStateCreateFlagsEXT, Flags);
284#[repr(transparent)]
285#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
286#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationStateStreamCreateFlagsEXT.html>"]
287pub struct PipelineRasterizationStateStreamCreateFlagsEXT(pub(crate) Flags);
288vk_bitflags_wrapped!(PipelineRasterizationStateStreamCreateFlagsEXT, Flags);
289#[repr(transparent)]
290#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
291#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationDepthClipStateCreateFlagsEXT.html>"]
292pub struct PipelineRasterizationDepthClipStateCreateFlagsEXT(pub(crate) Flags);
293vk_bitflags_wrapped!(PipelineRasterizationDepthClipStateCreateFlagsEXT, Flags);
294#[repr(transparent)]
295#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
296#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoBeginCodingFlagsKHR.html>"]
297pub struct VideoBeginCodingFlagsKHR(pub(crate) Flags);
298vk_bitflags_wrapped!(VideoBeginCodingFlagsKHR, Flags);
299#[repr(transparent)]
300#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
301#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEndCodingFlagsKHR.html>"]
302pub struct VideoEndCodingFlagsKHR(pub(crate) Flags);
303vk_bitflags_wrapped!(VideoEndCodingFlagsKHR, Flags);
304define_handle!(
305 Instance,
306 INSTANCE,
307 doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkInstance.html>"
308);
309define_handle ! (PhysicalDevice , PHYSICAL_DEVICE , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevice.html>") ;
310define_handle!(
311 Device,
312 DEVICE,
313 doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDevice.html>"
314);
315define_handle!(
316 Queue,
317 QUEUE,
318 doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueue.html>"
319);
320define_handle ! (CommandBuffer , COMMAND_BUFFER , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBuffer.html>") ;
321handle_nondispatchable ! (DeviceMemory , DEVICE_MEMORY , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceMemory.html>") ;
322handle_nondispatchable ! (CommandPool , COMMAND_POOL , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandPool.html>") ;
323handle_nondispatchable!(
324 Buffer,
325 BUFFER,
326 doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBuffer.html>"
327);
328handle_nondispatchable!(
329 BufferView,
330 BUFFER_VIEW,
331 doc =
332 "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferView.html>"
333);
334handle_nondispatchable!(
335 Image,
336 IMAGE,
337 doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImage.html>"
338);
339handle_nondispatchable!(
340 ImageView,
341 IMAGE_VIEW,
342 doc =
343 "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageView.html>"
344);
345handle_nondispatchable ! (ShaderModule , SHADER_MODULE , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderModule.html>") ;
346handle_nondispatchable!(
347 Pipeline,
348 PIPELINE,
349 doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipeline.html>"
350);
351handle_nondispatchable ! (PipelineLayout , PIPELINE_LAYOUT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineLayout.html>") ;
352handle_nondispatchable!(
353 Sampler,
354 SAMPLER,
355 doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSampler.html>"
356);
357handle_nondispatchable ! (DescriptorSet , DESCRIPTOR_SET , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSet.html>") ;
358handle_nondispatchable ! (DescriptorSetLayout , DESCRIPTOR_SET_LAYOUT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayout.html>") ;
359handle_nondispatchable ! (DescriptorPool , DESCRIPTOR_POOL , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPool.html>") ;
360handle_nondispatchable!(
361 Fence,
362 FENCE,
363 doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFence.html>"
364);
365handle_nondispatchable!(
366 Semaphore,
367 SEMAPHORE,
368 doc =
369 "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphore.html>"
370);
371handle_nondispatchable!(
372 Event,
373 EVENT,
374 doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkEvent.html>"
375);
376handle_nondispatchable!(
377 QueryPool,
378 QUERY_POOL,
379 doc =
380 "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPool.html>"
381);
382handle_nondispatchable ! (Framebuffer , FRAMEBUFFER , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebuffer.html>") ;
383handle_nondispatchable!(
384 RenderPass,
385 RENDER_PASS,
386 doc =
387 "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPass.html>"
388);
389handle_nondispatchable ! (PipelineCache , PIPELINE_CACHE , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCache.html>") ;
390handle_nondispatchable ! (IndirectCommandsLayoutNV , INDIRECT_COMMANDS_LAYOUT_NV , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIndirectCommandsLayoutNV.html>") ;
391handle_nondispatchable ! (DescriptorUpdateTemplate , DESCRIPTOR_UPDATE_TEMPLATE , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorUpdateTemplate.html>") ;
392handle_nondispatchable ! (SamplerYcbcrConversion , SAMPLER_YCBCR_CONVERSION , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerYcbcrConversion.html>") ;
393handle_nondispatchable ! (ValidationCacheEXT , VALIDATION_CACHE_EXT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationCacheEXT.html>") ;
394handle_nondispatchable ! (AccelerationStructureKHR , ACCELERATION_STRUCTURE_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureKHR.html>") ;
395handle_nondispatchable ! (AccelerationStructureNV , ACCELERATION_STRUCTURE_NV , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureNV.html>") ;
396handle_nondispatchable ! (PerformanceConfigurationINTEL , PERFORMANCE_CONFIGURATION_INTEL , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceConfigurationINTEL.html>") ;
397handle_nondispatchable ! (BufferCollectionFUCHSIA , BUFFER_COLLECTION_FUCHSIA , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCollectionFUCHSIA.html>") ;
398handle_nondispatchable ! (DeferredOperationKHR , DEFERRED_OPERATION_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeferredOperationKHR.html>") ;
399handle_nondispatchable ! (PrivateDataSlot , PRIVATE_DATA_SLOT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPrivateDataSlot.html>") ;
400handle_nondispatchable ! (CuModuleNVX , CU_MODULE_NVX , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCuModuleNVX.html>") ;
401handle_nondispatchable ! (CuFunctionNVX , CU_FUNCTION_NVX , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCuFunctionNVX.html>") ;
402handle_nondispatchable!(
403 DisplayKHR,
404 DISPLAY_KHR,
405 doc =
406 "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayKHR.html>"
407);
408handle_nondispatchable ! (DisplayModeKHR , DISPLAY_MODE_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModeKHR.html>") ;
409handle_nondispatchable!(
410 SurfaceKHR,
411 SURFACE_KHR,
412 doc =
413 "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceKHR.html>"
414);
415handle_nondispatchable ! (SwapchainKHR , SWAPCHAIN_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainKHR.html>") ;
416handle_nondispatchable ! (DebugReportCallbackEXT , DEBUG_REPORT_CALLBACK_EXT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugReportCallbackEXT.html>") ;
417handle_nondispatchable ! (DebugUtilsMessengerEXT , DEBUG_UTILS_MESSENGER_EXT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessengerEXT.html>") ;
418handle_nondispatchable ! (VideoSessionKHR , VIDEO_SESSION_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionKHR.html>") ;
419handle_nondispatchable ! (VideoSessionParametersKHR , VIDEO_SESSION_PARAMETERS_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionParametersKHR.html>") ;
420#[allow(non_camel_case_types)]
421#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkInternalAllocationNotification.html>"]
422pub type PFN_vkInternalAllocationNotification = Option<
423 unsafe extern "system" fn(
424 p_user_data: *mut c_void,
425 size: usize,
426 allocation_type: InternalAllocationType,
427 allocation_scope: SystemAllocationScope,
428 ),
429>;
430#[allow(non_camel_case_types)]
431#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkInternalFreeNotification.html>"]
432pub type PFN_vkInternalFreeNotification = Option<
433 unsafe extern "system" fn(
434 p_user_data: *mut c_void,
435 size: usize,
436 allocation_type: InternalAllocationType,
437 allocation_scope: SystemAllocationScope,
438 ),
439>;
440#[allow(non_camel_case_types)]
441#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkReallocationFunction.html>"]
442pub type PFN_vkReallocationFunction = Option<
443 unsafe extern "system" fn(
444 p_user_data: *mut c_void,
445 p_original: *mut c_void,
446 size: usize,
447 alignment: usize,
448 allocation_scope: SystemAllocationScope,
449 ) -> *mut c_void,
450>;
451#[allow(non_camel_case_types)]
452#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkAllocationFunction.html>"]
453pub type PFN_vkAllocationFunction = Option<
454 unsafe extern "system" fn(
455 p_user_data: *mut c_void,
456 size: usize,
457 alignment: usize,
458 allocation_scope: SystemAllocationScope,
459 ) -> *mut c_void,
460>;
461#[allow(non_camel_case_types)]
462#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkFreeFunction.html>"]
463pub type PFN_vkFreeFunction =
464 Option<unsafe extern "system" fn(p_user_data: *mut c_void, p_memory: *mut c_void)>;
465#[allow(non_camel_case_types)]
466#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkVoidFunction.html>"]
467pub type PFN_vkVoidFunction = Option<unsafe extern "system" fn()>;
468#[allow(non_camel_case_types)]
469#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkDebugReportCallbackEXT.html>"]
470pub type PFN_vkDebugReportCallbackEXT = Option<
471 unsafe extern "system" fn(
472 flags: DebugReportFlagsEXT,
473 object_type: DebugReportObjectTypeEXT,
474 object: u64,
475 location: usize,
476 message_code: i32,
477 p_layer_prefix: *const c_char,
478 p_message: *const c_char,
479 p_user_data: *mut c_void,
480 ) -> Bool32,
481>;
482#[allow(non_camel_case_types)]
483#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkDebugUtilsMessengerCallbackEXT.html>"]
484pub type PFN_vkDebugUtilsMessengerCallbackEXT = Option<
485 unsafe extern "system" fn(
486 message_severity: DebugUtilsMessageSeverityFlagsEXT,
487 message_types: DebugUtilsMessageTypeFlagsEXT,
488 p_callback_data: *const DebugUtilsMessengerCallbackDataEXT,
489 p_user_data: *mut c_void,
490 ) -> Bool32,
491>;
492#[allow(non_camel_case_types)]
493#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkDeviceMemoryReportCallbackEXT.html>"]
494pub type PFN_vkDeviceMemoryReportCallbackEXT = Option<
495 unsafe extern "system" fn(
496 p_callback_data: *const DeviceMemoryReportCallbackDataEXT,
497 p_user_data: *mut c_void,
498 ),
499>;
500#[repr(C)]
501#[cfg_attr(feature = "debug", derive(Debug))]
502#[derive(Copy, Clone)]
503#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBaseOutStructure.html>"]
504pub struct BaseOutStructure {
505 pub s_type: StructureType,
506 pub p_next: *mut Self,
507}
508impl ::std::default::Default for BaseOutStructure {
509 fn default() -> Self {
510 Self {
511 s_type: unsafe { ::std::mem::zeroed() },
512 p_next: ::std::ptr::null_mut(),
513 }
514 }
515}
516#[repr(C)]
517#[cfg_attr(feature = "debug", derive(Debug))]
518#[derive(Copy, Clone)]
519#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBaseInStructure.html>"]
520pub struct BaseInStructure {
521 pub s_type: StructureType,
522 pub p_next: *const Self,
523}
524impl ::std::default::Default for BaseInStructure {
525 fn default() -> Self {
526 Self {
527 s_type: unsafe { ::std::mem::zeroed() },
528 p_next: ::std::ptr::null(),
529 }
530 }
531}
532#[repr(C)]
533#[cfg_attr(feature = "debug", derive(Debug))]
534#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
535#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOffset2D.html>"]
536pub struct Offset2D {
537 pub x: i32,
538 pub y: i32,
539}
540impl Offset2D {
541 pub fn builder<'a>() -> Offset2DBuilder<'a> {
542 Offset2DBuilder {
543 inner: Self::default(),
544 marker: ::std::marker::PhantomData,
545 }
546 }
547}
548#[repr(transparent)]
549pub struct Offset2DBuilder<'a> {
550 inner: Offset2D,
551 marker: ::std::marker::PhantomData<&'a ()>,
552}
553impl<'a> ::std::ops::Deref for Offset2DBuilder<'a> {
554 type Target = Offset2D;
555 fn deref(&self) -> &Self::Target {
556 &self.inner
557 }
558}
559impl<'a> ::std::ops::DerefMut for Offset2DBuilder<'a> {
560 fn deref_mut(&mut self) -> &mut Self::Target {
561 &mut self.inner
562 }
563}
564impl<'a> Offset2DBuilder<'a> {
565 pub fn x(mut self, x: i32) -> Self {
566 self.inner.x = x;
567 self
568 }
569 pub fn y(mut self, y: i32) -> Self {
570 self.inner.y = y;
571 self
572 }
573 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
574 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
575 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
576 pub fn build(self) -> Offset2D {
577 self.inner
578 }
579}
580#[repr(C)]
581#[cfg_attr(feature = "debug", derive(Debug))]
582#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
583#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOffset3D.html>"]
584pub struct Offset3D {
585 pub x: i32,
586 pub y: i32,
587 pub z: i32,
588}
589impl Offset3D {
590 pub fn builder<'a>() -> Offset3DBuilder<'a> {
591 Offset3DBuilder {
592 inner: Self::default(),
593 marker: ::std::marker::PhantomData,
594 }
595 }
596}
597#[repr(transparent)]
598pub struct Offset3DBuilder<'a> {
599 inner: Offset3D,
600 marker: ::std::marker::PhantomData<&'a ()>,
601}
602impl<'a> ::std::ops::Deref for Offset3DBuilder<'a> {
603 type Target = Offset3D;
604 fn deref(&self) -> &Self::Target {
605 &self.inner
606 }
607}
608impl<'a> ::std::ops::DerefMut for Offset3DBuilder<'a> {
609 fn deref_mut(&mut self) -> &mut Self::Target {
610 &mut self.inner
611 }
612}
613impl<'a> Offset3DBuilder<'a> {
614 pub fn x(mut self, x: i32) -> Self {
615 self.inner.x = x;
616 self
617 }
618 pub fn y(mut self, y: i32) -> Self {
619 self.inner.y = y;
620 self
621 }
622 pub fn z(mut self, z: i32) -> Self {
623 self.inner.z = z;
624 self
625 }
626 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
627 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
628 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
629 pub fn build(self) -> Offset3D {
630 self.inner
631 }
632}
633#[repr(C)]
634#[cfg_attr(feature = "debug", derive(Debug))]
635#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
636#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExtent2D.html>"]
637pub struct Extent2D {
638 pub width: u32,
639 pub height: u32,
640}
641impl Extent2D {
642 pub fn builder<'a>() -> Extent2DBuilder<'a> {
643 Extent2DBuilder {
644 inner: Self::default(),
645 marker: ::std::marker::PhantomData,
646 }
647 }
648}
649#[repr(transparent)]
650pub struct Extent2DBuilder<'a> {
651 inner: Extent2D,
652 marker: ::std::marker::PhantomData<&'a ()>,
653}
654impl<'a> ::std::ops::Deref for Extent2DBuilder<'a> {
655 type Target = Extent2D;
656 fn deref(&self) -> &Self::Target {
657 &self.inner
658 }
659}
660impl<'a> ::std::ops::DerefMut for Extent2DBuilder<'a> {
661 fn deref_mut(&mut self) -> &mut Self::Target {
662 &mut self.inner
663 }
664}
665impl<'a> Extent2DBuilder<'a> {
666 pub fn width(mut self, width: u32) -> Self {
667 self.inner.width = width;
668 self
669 }
670 pub fn height(mut self, height: u32) -> Self {
671 self.inner.height = height;
672 self
673 }
674 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
675 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
676 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
677 pub fn build(self) -> Extent2D {
678 self.inner
679 }
680}
681#[repr(C)]
682#[cfg_attr(feature = "debug", derive(Debug))]
683#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
684#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExtent3D.html>"]
685pub struct Extent3D {
686 pub width: u32,
687 pub height: u32,
688 pub depth: u32,
689}
690impl Extent3D {
691 pub fn builder<'a>() -> Extent3DBuilder<'a> {
692 Extent3DBuilder {
693 inner: Self::default(),
694 marker: ::std::marker::PhantomData,
695 }
696 }
697}
698#[repr(transparent)]
699pub struct Extent3DBuilder<'a> {
700 inner: Extent3D,
701 marker: ::std::marker::PhantomData<&'a ()>,
702}
703impl<'a> ::std::ops::Deref for Extent3DBuilder<'a> {
704 type Target = Extent3D;
705 fn deref(&self) -> &Self::Target {
706 &self.inner
707 }
708}
709impl<'a> ::std::ops::DerefMut for Extent3DBuilder<'a> {
710 fn deref_mut(&mut self) -> &mut Self::Target {
711 &mut self.inner
712 }
713}
714impl<'a> Extent3DBuilder<'a> {
715 pub fn width(mut self, width: u32) -> Self {
716 self.inner.width = width;
717 self
718 }
719 pub fn height(mut self, height: u32) -> Self {
720 self.inner.height = height;
721 self
722 }
723 pub fn depth(mut self, depth: u32) -> Self {
724 self.inner.depth = depth;
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."]
730 pub fn build(self) -> Extent3D {
731 self.inner
732 }
733}
734#[repr(C)]
735#[cfg_attr(feature = "debug", derive(Debug))]
736#[derive(Copy, Clone, Default)]
737#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkViewport.html>"]
738pub struct Viewport {
739 pub x: f32,
740 pub y: f32,
741 pub width: f32,
742 pub height: f32,
743 pub min_depth: f32,
744 pub max_depth: f32,
745}
746impl Viewport {
747 pub fn builder<'a>() -> ViewportBuilder<'a> {
748 ViewportBuilder {
749 inner: Self::default(),
750 marker: ::std::marker::PhantomData,
751 }
752 }
753}
754#[repr(transparent)]
755pub struct ViewportBuilder<'a> {
756 inner: Viewport,
757 marker: ::std::marker::PhantomData<&'a ()>,
758}
759impl<'a> ::std::ops::Deref for ViewportBuilder<'a> {
760 type Target = Viewport;
761 fn deref(&self) -> &Self::Target {
762 &self.inner
763 }
764}
765impl<'a> ::std::ops::DerefMut for ViewportBuilder<'a> {
766 fn deref_mut(&mut self) -> &mut Self::Target {
767 &mut self.inner
768 }
769}
770impl<'a> ViewportBuilder<'a> {
771 pub fn x(mut self, x: f32) -> Self {
772 self.inner.x = x;
773 self
774 }
775 pub fn y(mut self, y: f32) -> Self {
776 self.inner.y = y;
777 self
778 }
779 pub fn width(mut self, width: f32) -> Self {
780 self.inner.width = width;
781 self
782 }
783 pub fn height(mut self, height: f32) -> Self {
784 self.inner.height = height;
785 self
786 }
787 pub fn min_depth(mut self, min_depth: f32) -> Self {
788 self.inner.min_depth = min_depth;
789 self
790 }
791 pub fn max_depth(mut self, max_depth: f32) -> Self {
792 self.inner.max_depth = max_depth;
793 self
794 }
795 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
796 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
797 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
798 pub fn build(self) -> Viewport {
799 self.inner
800 }
801}
802#[repr(C)]
803#[cfg_attr(feature = "debug", derive(Debug))]
804#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
805#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRect2D.html>"]
806pub struct Rect2D {
807 pub offset: Offset2D,
808 pub extent: Extent2D,
809}
810impl Rect2D {
811 pub fn builder<'a>() -> Rect2DBuilder<'a> {
812 Rect2DBuilder {
813 inner: Self::default(),
814 marker: ::std::marker::PhantomData,
815 }
816 }
817}
818#[repr(transparent)]
819pub struct Rect2DBuilder<'a> {
820 inner: Rect2D,
821 marker: ::std::marker::PhantomData<&'a ()>,
822}
823impl<'a> ::std::ops::Deref for Rect2DBuilder<'a> {
824 type Target = Rect2D;
825 fn deref(&self) -> &Self::Target {
826 &self.inner
827 }
828}
829impl<'a> ::std::ops::DerefMut for Rect2DBuilder<'a> {
830 fn deref_mut(&mut self) -> &mut Self::Target {
831 &mut self.inner
832 }
833}
834impl<'a> Rect2DBuilder<'a> {
835 pub fn offset(mut self, offset: Offset2D) -> Self {
836 self.inner.offset = offset;
837 self
838 }
839 pub fn extent(mut self, extent: Extent2D) -> Self {
840 self.inner.extent = extent;
841 self
842 }
843 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
844 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
845 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
846 pub fn build(self) -> Rect2D {
847 self.inner
848 }
849}
850#[repr(C)]
851#[cfg_attr(feature = "debug", derive(Debug))]
852#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
853#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkClearRect.html>"]
854pub struct ClearRect {
855 pub rect: Rect2D,
856 pub base_array_layer: u32,
857 pub layer_count: u32,
858}
859impl ClearRect {
860 pub fn builder<'a>() -> ClearRectBuilder<'a> {
861 ClearRectBuilder {
862 inner: Self::default(),
863 marker: ::std::marker::PhantomData,
864 }
865 }
866}
867#[repr(transparent)]
868pub struct ClearRectBuilder<'a> {
869 inner: ClearRect,
870 marker: ::std::marker::PhantomData<&'a ()>,
871}
872impl<'a> ::std::ops::Deref for ClearRectBuilder<'a> {
873 type Target = ClearRect;
874 fn deref(&self) -> &Self::Target {
875 &self.inner
876 }
877}
878impl<'a> ::std::ops::DerefMut for ClearRectBuilder<'a> {
879 fn deref_mut(&mut self) -> &mut Self::Target {
880 &mut self.inner
881 }
882}
883impl<'a> ClearRectBuilder<'a> {
884 pub fn rect(mut self, rect: Rect2D) -> Self {
885 self.inner.rect = rect;
886 self
887 }
888 pub fn base_array_layer(mut self, base_array_layer: u32) -> Self {
889 self.inner.base_array_layer = base_array_layer;
890 self
891 }
892 pub fn layer_count(mut self, layer_count: u32) -> Self {
893 self.inner.layer_count = layer_count;
894 self
895 }
896 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
897 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
898 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
899 pub fn build(self) -> ClearRect {
900 self.inner
901 }
902}
903#[repr(C)]
904#[cfg_attr(feature = "debug", derive(Debug))]
905#[derive(Copy, Clone, Default)]
906#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkComponentMapping.html>"]
907pub struct ComponentMapping {
908 pub r: ComponentSwizzle,
909 pub g: ComponentSwizzle,
910 pub b: ComponentSwizzle,
911 pub a: ComponentSwizzle,
912}
913impl ComponentMapping {
914 pub fn builder<'a>() -> ComponentMappingBuilder<'a> {
915 ComponentMappingBuilder {
916 inner: Self::default(),
917 marker: ::std::marker::PhantomData,
918 }
919 }
920}
921#[repr(transparent)]
922pub struct ComponentMappingBuilder<'a> {
923 inner: ComponentMapping,
924 marker: ::std::marker::PhantomData<&'a ()>,
925}
926impl<'a> ::std::ops::Deref for ComponentMappingBuilder<'a> {
927 type Target = ComponentMapping;
928 fn deref(&self) -> &Self::Target {
929 &self.inner
930 }
931}
932impl<'a> ::std::ops::DerefMut for ComponentMappingBuilder<'a> {
933 fn deref_mut(&mut self) -> &mut Self::Target {
934 &mut self.inner
935 }
936}
937impl<'a> ComponentMappingBuilder<'a> {
938 pub fn r(mut self, r: ComponentSwizzle) -> Self {
939 self.inner.r = r;
940 self
941 }
942 pub fn g(mut self, g: ComponentSwizzle) -> Self {
943 self.inner.g = g;
944 self
945 }
946 pub fn b(mut self, b: ComponentSwizzle) -> Self {
947 self.inner.b = b;
948 self
949 }
950 pub fn a(mut self, a: ComponentSwizzle) -> Self {
951 self.inner.a = a;
952 self
953 }
954 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
955 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
956 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
957 pub fn build(self) -> ComponentMapping {
958 self.inner
959 }
960}
961#[repr(C)]
962#[derive(Copy, Clone)]
963#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProperties.html>"]
964pub struct PhysicalDeviceProperties {
965 pub api_version: u32,
966 pub driver_version: u32,
967 pub vendor_id: u32,
968 pub device_id: u32,
969 pub device_type: PhysicalDeviceType,
970 pub device_name: [c_char; MAX_PHYSICAL_DEVICE_NAME_SIZE],
971 pub pipeline_cache_uuid: [u8; UUID_SIZE],
972 pub limits: PhysicalDeviceLimits,
973 pub sparse_properties: PhysicalDeviceSparseProperties,
974}
975#[cfg(feature = "debug")]
976impl fmt::Debug for PhysicalDeviceProperties {
977 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
978 fmt.debug_struct("PhysicalDeviceProperties")
979 .field("api_version", &self.api_version)
980 .field("driver_version", &self.driver_version)
981 .field("vendor_id", &self.vendor_id)
982 .field("device_id", &self.device_id)
983 .field("device_type", &self.device_type)
984 .field("device_name", &unsafe {
985 ::std::ffi::CStr::from_ptr(self.device_name.as_ptr())
986 })
987 .field("pipeline_cache_uuid", &self.pipeline_cache_uuid)
988 .field("limits", &self.limits)
989 .field("sparse_properties", &self.sparse_properties)
990 .finish()
991 }
992}
993impl ::std::default::Default for PhysicalDeviceProperties {
994 fn default() -> Self {
995 Self {
996 api_version: u32::default(),
997 driver_version: u32::default(),
998 vendor_id: u32::default(),
999 device_id: u32::default(),
1000 device_type: PhysicalDeviceType::default(),
1001 device_name: unsafe { ::std::mem::zeroed() },
1002 pipeline_cache_uuid: unsafe { ::std::mem::zeroed() },
1003 limits: PhysicalDeviceLimits::default(),
1004 sparse_properties: PhysicalDeviceSparseProperties::default(),
1005 }
1006 }
1007}
1008impl PhysicalDeviceProperties {
1009 pub fn builder<'a>() -> PhysicalDevicePropertiesBuilder<'a> {
1010 PhysicalDevicePropertiesBuilder {
1011 inner: Self::default(),
1012 marker: ::std::marker::PhantomData,
1013 }
1014 }
1015}
1016#[repr(transparent)]
1017pub struct PhysicalDevicePropertiesBuilder<'a> {
1018 inner: PhysicalDeviceProperties,
1019 marker: ::std::marker::PhantomData<&'a ()>,
1020}
1021impl<'a> ::std::ops::Deref for PhysicalDevicePropertiesBuilder<'a> {
1022 type Target = PhysicalDeviceProperties;
1023 fn deref(&self) -> &Self::Target {
1024 &self.inner
1025 }
1026}
1027impl<'a> ::std::ops::DerefMut for PhysicalDevicePropertiesBuilder<'a> {
1028 fn deref_mut(&mut self) -> &mut Self::Target {
1029 &mut self.inner
1030 }
1031}
1032impl<'a> PhysicalDevicePropertiesBuilder<'a> {
1033 pub fn api_version(mut self, api_version: u32) -> Self {
1034 self.inner.api_version = api_version;
1035 self
1036 }
1037 pub fn driver_version(mut self, driver_version: u32) -> Self {
1038 self.inner.driver_version = driver_version;
1039 self
1040 }
1041 pub fn vendor_id(mut self, vendor_id: u32) -> Self {
1042 self.inner.vendor_id = vendor_id;
1043 self
1044 }
1045 pub fn device_id(mut self, device_id: u32) -> Self {
1046 self.inner.device_id = device_id;
1047 self
1048 }
1049 pub fn device_type(mut self, device_type: PhysicalDeviceType) -> Self {
1050 self.inner.device_type = device_type;
1051 self
1052 }
1053 pub fn device_name(mut self, device_name: [c_char; MAX_PHYSICAL_DEVICE_NAME_SIZE]) -> Self {
1054 self.inner.device_name = device_name;
1055 self
1056 }
1057 pub fn pipeline_cache_uuid(mut self, pipeline_cache_uuid: [u8; UUID_SIZE]) -> Self {
1058 self.inner.pipeline_cache_uuid = pipeline_cache_uuid;
1059 self
1060 }
1061 pub fn limits(mut self, limits: PhysicalDeviceLimits) -> Self {
1062 self.inner.limits = limits;
1063 self
1064 }
1065 pub fn sparse_properties(mut self, sparse_properties: PhysicalDeviceSparseProperties) -> Self {
1066 self.inner.sparse_properties = sparse_properties;
1067 self
1068 }
1069 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1070 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1071 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
1072 pub fn build(self) -> PhysicalDeviceProperties {
1073 self.inner
1074 }
1075}
1076#[repr(C)]
1077#[derive(Copy, Clone)]
1078#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExtensionProperties.html>"]
1079pub struct ExtensionProperties {
1080 pub extension_name: [c_char; MAX_EXTENSION_NAME_SIZE],
1081 pub spec_version: u32,
1082}
1083#[cfg(feature = "debug")]
1084impl fmt::Debug for ExtensionProperties {
1085 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
1086 fmt.debug_struct("ExtensionProperties")
1087 .field("extension_name", &unsafe {
1088 ::std::ffi::CStr::from_ptr(self.extension_name.as_ptr())
1089 })
1090 .field("spec_version", &self.spec_version)
1091 .finish()
1092 }
1093}
1094impl ::std::default::Default for ExtensionProperties {
1095 fn default() -> Self {
1096 Self {
1097 extension_name: unsafe { ::std::mem::zeroed() },
1098 spec_version: u32::default(),
1099 }
1100 }
1101}
1102impl ExtensionProperties {
1103 pub fn builder<'a>() -> ExtensionPropertiesBuilder<'a> {
1104 ExtensionPropertiesBuilder {
1105 inner: Self::default(),
1106 marker: ::std::marker::PhantomData,
1107 }
1108 }
1109}
1110#[repr(transparent)]
1111pub struct ExtensionPropertiesBuilder<'a> {
1112 inner: ExtensionProperties,
1113 marker: ::std::marker::PhantomData<&'a ()>,
1114}
1115impl<'a> ::std::ops::Deref for ExtensionPropertiesBuilder<'a> {
1116 type Target = ExtensionProperties;
1117 fn deref(&self) -> &Self::Target {
1118 &self.inner
1119 }
1120}
1121impl<'a> ::std::ops::DerefMut for ExtensionPropertiesBuilder<'a> {
1122 fn deref_mut(&mut self) -> &mut Self::Target {
1123 &mut self.inner
1124 }
1125}
1126impl<'a> ExtensionPropertiesBuilder<'a> {
1127 pub fn extension_name(mut self, extension_name: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self {
1128 self.inner.extension_name = extension_name;
1129 self
1130 }
1131 pub fn spec_version(mut self, spec_version: u32) -> Self {
1132 self.inner.spec_version = spec_version;
1133 self
1134 }
1135 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1136 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1137 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
1138 pub fn build(self) -> ExtensionProperties {
1139 self.inner
1140 }
1141}
1142#[repr(C)]
1143#[derive(Copy, Clone)]
1144#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkLayerProperties.html>"]
1145pub struct LayerProperties {
1146 pub layer_name: [c_char; MAX_EXTENSION_NAME_SIZE],
1147 pub spec_version: u32,
1148 pub implementation_version: u32,
1149 pub description: [c_char; MAX_DESCRIPTION_SIZE],
1150}
1151#[cfg(feature = "debug")]
1152impl fmt::Debug for LayerProperties {
1153 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
1154 fmt.debug_struct("LayerProperties")
1155 .field("layer_name", &unsafe {
1156 ::std::ffi::CStr::from_ptr(self.layer_name.as_ptr())
1157 })
1158 .field("spec_version", &self.spec_version)
1159 .field("implementation_version", &self.implementation_version)
1160 .field("description", &unsafe {
1161 ::std::ffi::CStr::from_ptr(self.description.as_ptr())
1162 })
1163 .finish()
1164 }
1165}
1166impl ::std::default::Default for LayerProperties {
1167 fn default() -> Self {
1168 Self {
1169 layer_name: unsafe { ::std::mem::zeroed() },
1170 spec_version: u32::default(),
1171 implementation_version: u32::default(),
1172 description: unsafe { ::std::mem::zeroed() },
1173 }
1174 }
1175}
1176impl LayerProperties {
1177 pub fn builder<'a>() -> LayerPropertiesBuilder<'a> {
1178 LayerPropertiesBuilder {
1179 inner: Self::default(),
1180 marker: ::std::marker::PhantomData,
1181 }
1182 }
1183}
1184#[repr(transparent)]
1185pub struct LayerPropertiesBuilder<'a> {
1186 inner: LayerProperties,
1187 marker: ::std::marker::PhantomData<&'a ()>,
1188}
1189impl<'a> ::std::ops::Deref for LayerPropertiesBuilder<'a> {
1190 type Target = LayerProperties;
1191 fn deref(&self) -> &Self::Target {
1192 &self.inner
1193 }
1194}
1195impl<'a> ::std::ops::DerefMut for LayerPropertiesBuilder<'a> {
1196 fn deref_mut(&mut self) -> &mut Self::Target {
1197 &mut self.inner
1198 }
1199}
1200impl<'a> LayerPropertiesBuilder<'a> {
1201 pub fn layer_name(mut self, layer_name: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self {
1202 self.inner.layer_name = layer_name;
1203 self
1204 }
1205 pub fn spec_version(mut self, spec_version: u32) -> Self {
1206 self.inner.spec_version = spec_version;
1207 self
1208 }
1209 pub fn implementation_version(mut self, implementation_version: u32) -> Self {
1210 self.inner.implementation_version = implementation_version;
1211 self
1212 }
1213 pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
1214 self.inner.description = description;
1215 self
1216 }
1217 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1218 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1219 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
1220 pub fn build(self) -> LayerProperties {
1221 self.inner
1222 }
1223}
1224#[repr(C)]
1225#[cfg_attr(feature = "debug", derive(Debug))]
1226#[derive(Copy, Clone)]
1227#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkApplicationInfo.html>"]
1228pub struct ApplicationInfo {
1229 pub s_type: StructureType,
1230 pub p_next: *const c_void,
1231 pub p_application_name: *const c_char,
1232 pub application_version: u32,
1233 pub p_engine_name: *const c_char,
1234 pub engine_version: u32,
1235 pub api_version: u32,
1236}
1237impl ::std::default::Default for ApplicationInfo {
1238 fn default() -> Self {
1239 Self {
1240 s_type: StructureType::APPLICATION_INFO,
1241 p_next: ::std::ptr::null(),
1242 p_application_name: ::std::ptr::null(),
1243 application_version: u32::default(),
1244 p_engine_name: ::std::ptr::null(),
1245 engine_version: u32::default(),
1246 api_version: u32::default(),
1247 }
1248 }
1249}
1250impl ApplicationInfo {
1251 pub fn builder<'a>() -> ApplicationInfoBuilder<'a> {
1252 ApplicationInfoBuilder {
1253 inner: Self::default(),
1254 marker: ::std::marker::PhantomData,
1255 }
1256 }
1257}
1258#[repr(transparent)]
1259pub struct ApplicationInfoBuilder<'a> {
1260 inner: ApplicationInfo,
1261 marker: ::std::marker::PhantomData<&'a ()>,
1262}
1263impl<'a> ::std::ops::Deref for ApplicationInfoBuilder<'a> {
1264 type Target = ApplicationInfo;
1265 fn deref(&self) -> &Self::Target {
1266 &self.inner
1267 }
1268}
1269impl<'a> ::std::ops::DerefMut for ApplicationInfoBuilder<'a> {
1270 fn deref_mut(&mut self) -> &mut Self::Target {
1271 &mut self.inner
1272 }
1273}
1274impl<'a> ApplicationInfoBuilder<'a> {
1275 pub fn application_name(mut self, application_name: &'a ::std::ffi::CStr) -> Self {
1276 self.inner.p_application_name = application_name.as_ptr();
1277 self
1278 }
1279 pub fn application_version(mut self, application_version: u32) -> Self {
1280 self.inner.application_version = application_version;
1281 self
1282 }
1283 pub fn engine_name(mut self, engine_name: &'a ::std::ffi::CStr) -> Self {
1284 self.inner.p_engine_name = engine_name.as_ptr();
1285 self
1286 }
1287 pub fn engine_version(mut self, engine_version: u32) -> Self {
1288 self.inner.engine_version = engine_version;
1289 self
1290 }
1291 pub fn api_version(mut self, api_version: u32) -> Self {
1292 self.inner.api_version = api_version;
1293 self
1294 }
1295 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1296 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1297 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
1298 pub fn build(self) -> ApplicationInfo {
1299 self.inner
1300 }
1301}
1302#[repr(C)]
1303#[derive(Copy, Clone)]
1304#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAllocationCallbacks.html>"]
1305pub struct AllocationCallbacks {
1306 pub p_user_data: *mut c_void,
1307 pub pfn_allocation: PFN_vkAllocationFunction,
1308 pub pfn_reallocation: PFN_vkReallocationFunction,
1309 pub pfn_free: PFN_vkFreeFunction,
1310 pub pfn_internal_allocation: PFN_vkInternalAllocationNotification,
1311 pub pfn_internal_free: PFN_vkInternalFreeNotification,
1312}
1313#[cfg(feature = "debug")]
1314impl fmt::Debug for AllocationCallbacks {
1315 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
1316 fmt.debug_struct("AllocationCallbacks")
1317 .field("p_user_data", &self.p_user_data)
1318 .field(
1319 "pfn_allocation",
1320 &(self.pfn_allocation.map(|x| x as *const ())),
1321 )
1322 .field(
1323 "pfn_reallocation",
1324 &(self.pfn_reallocation.map(|x| x as *const ())),
1325 )
1326 .field("pfn_free", &(self.pfn_free.map(|x| x as *const ())))
1327 .field(
1328 "pfn_internal_allocation",
1329 &(self.pfn_internal_allocation.map(|x| x as *const ())),
1330 )
1331 .field(
1332 "pfn_internal_free",
1333 &(self.pfn_internal_free.map(|x| x as *const ())),
1334 )
1335 .finish()
1336 }
1337}
1338impl ::std::default::Default for AllocationCallbacks {
1339 fn default() -> Self {
1340 Self {
1341 p_user_data: ::std::ptr::null_mut(),
1342 pfn_allocation: PFN_vkAllocationFunction::default(),
1343 pfn_reallocation: PFN_vkReallocationFunction::default(),
1344 pfn_free: PFN_vkFreeFunction::default(),
1345 pfn_internal_allocation: PFN_vkInternalAllocationNotification::default(),
1346 pfn_internal_free: PFN_vkInternalFreeNotification::default(),
1347 }
1348 }
1349}
1350impl AllocationCallbacks {
1351 pub fn builder<'a>() -> AllocationCallbacksBuilder<'a> {
1352 AllocationCallbacksBuilder {
1353 inner: Self::default(),
1354 marker: ::std::marker::PhantomData,
1355 }
1356 }
1357}
1358#[repr(transparent)]
1359pub struct AllocationCallbacksBuilder<'a> {
1360 inner: AllocationCallbacks,
1361 marker: ::std::marker::PhantomData<&'a ()>,
1362}
1363impl<'a> ::std::ops::Deref for AllocationCallbacksBuilder<'a> {
1364 type Target = AllocationCallbacks;
1365 fn deref(&self) -> &Self::Target {
1366 &self.inner
1367 }
1368}
1369impl<'a> ::std::ops::DerefMut for AllocationCallbacksBuilder<'a> {
1370 fn deref_mut(&mut self) -> &mut Self::Target {
1371 &mut self.inner
1372 }
1373}
1374impl<'a> AllocationCallbacksBuilder<'a> {
1375 pub fn user_data(mut self, user_data: *mut c_void) -> Self {
1376 self.inner.p_user_data = user_data;
1377 self
1378 }
1379 pub fn pfn_allocation(mut self, pfn_allocation: PFN_vkAllocationFunction) -> Self {
1380 self.inner.pfn_allocation = pfn_allocation;
1381 self
1382 }
1383 pub fn pfn_reallocation(mut self, pfn_reallocation: PFN_vkReallocationFunction) -> Self {
1384 self.inner.pfn_reallocation = pfn_reallocation;
1385 self
1386 }
1387 pub fn pfn_free(mut self, pfn_free: PFN_vkFreeFunction) -> Self {
1388 self.inner.pfn_free = pfn_free;
1389 self
1390 }
1391 pub fn pfn_internal_allocation(
1392 mut self,
1393 pfn_internal_allocation: PFN_vkInternalAllocationNotification,
1394 ) -> Self {
1395 self.inner.pfn_internal_allocation = pfn_internal_allocation;
1396 self
1397 }
1398 pub fn pfn_internal_free(mut self, pfn_internal_free: PFN_vkInternalFreeNotification) -> Self {
1399 self.inner.pfn_internal_free = pfn_internal_free;
1400 self
1401 }
1402 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1403 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1404 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
1405 pub fn build(self) -> AllocationCallbacks {
1406 self.inner
1407 }
1408}
1409#[repr(C)]
1410#[cfg_attr(feature = "debug", derive(Debug))]
1411#[derive(Copy, Clone)]
1412#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceQueueCreateInfo.html>"]
1413pub struct DeviceQueueCreateInfo {
1414 pub s_type: StructureType,
1415 pub p_next: *const c_void,
1416 pub flags: DeviceQueueCreateFlags,
1417 pub queue_family_index: u32,
1418 pub queue_count: u32,
1419 pub p_queue_priorities: *const f32,
1420}
1421impl ::std::default::Default for DeviceQueueCreateInfo {
1422 fn default() -> Self {
1423 Self {
1424 s_type: StructureType::DEVICE_QUEUE_CREATE_INFO,
1425 p_next: ::std::ptr::null(),
1426 flags: DeviceQueueCreateFlags::default(),
1427 queue_family_index: u32::default(),
1428 queue_count: u32::default(),
1429 p_queue_priorities: ::std::ptr::null(),
1430 }
1431 }
1432}
1433impl DeviceQueueCreateInfo {
1434 pub fn builder<'a>() -> DeviceQueueCreateInfoBuilder<'a> {
1435 DeviceQueueCreateInfoBuilder {
1436 inner: Self::default(),
1437 marker: ::std::marker::PhantomData,
1438 }
1439 }
1440}
1441#[repr(transparent)]
1442pub struct DeviceQueueCreateInfoBuilder<'a> {
1443 inner: DeviceQueueCreateInfo,
1444 marker: ::std::marker::PhantomData<&'a ()>,
1445}
1446pub unsafe trait ExtendsDeviceQueueCreateInfo {}
1447impl<'a> ::std::ops::Deref for DeviceQueueCreateInfoBuilder<'a> {
1448 type Target = DeviceQueueCreateInfo;
1449 fn deref(&self) -> &Self::Target {
1450 &self.inner
1451 }
1452}
1453impl<'a> ::std::ops::DerefMut for DeviceQueueCreateInfoBuilder<'a> {
1454 fn deref_mut(&mut self) -> &mut Self::Target {
1455 &mut self.inner
1456 }
1457}
1458impl<'a> DeviceQueueCreateInfoBuilder<'a> {
1459 pub fn flags(mut self, flags: DeviceQueueCreateFlags) -> Self {
1460 self.inner.flags = flags;
1461 self
1462 }
1463 pub fn queue_family_index(mut self, queue_family_index: u32) -> Self {
1464 self.inner.queue_family_index = queue_family_index;
1465 self
1466 }
1467 pub fn queue_priorities(mut self, queue_priorities: &'a [f32]) -> Self {
1468 self.inner.queue_count = queue_priorities.len() as _;
1469 self.inner.p_queue_priorities = queue_priorities.as_ptr();
1470 self
1471 }
1472 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
1473 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
1474 #[doc = r" valid extension structs can be pushed into the chain."]
1475 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
1476 #[doc = r" chain will look like `A -> D -> B -> C`."]
1477 pub fn push_next<T: ExtendsDeviceQueueCreateInfo>(mut self, next: &'a mut T) -> Self {
1478 unsafe {
1479 let next_ptr = <*const T>::cast(next);
1480 let last_next = ptr_chain_iter(next).last().unwrap();
1481 (*last_next).p_next = self.inner.p_next as _;
1482 self.inner.p_next = next_ptr;
1483 }
1484 self
1485 }
1486 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1487 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1488 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
1489 pub fn build(self) -> DeviceQueueCreateInfo {
1490 self.inner
1491 }
1492}
1493#[repr(C)]
1494#[cfg_attr(feature = "debug", derive(Debug))]
1495#[derive(Copy, Clone)]
1496#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceCreateInfo.html>"]
1497pub struct DeviceCreateInfo {
1498 pub s_type: StructureType,
1499 pub p_next: *const c_void,
1500 pub flags: DeviceCreateFlags,
1501 pub queue_create_info_count: u32,
1502 pub p_queue_create_infos: *const DeviceQueueCreateInfo,
1503 pub enabled_layer_count: u32,
1504 pub pp_enabled_layer_names: *const *const c_char,
1505 pub enabled_extension_count: u32,
1506 pub pp_enabled_extension_names: *const *const c_char,
1507 pub p_enabled_features: *const PhysicalDeviceFeatures,
1508}
1509impl ::std::default::Default for DeviceCreateInfo {
1510 fn default() -> Self {
1511 Self {
1512 s_type: StructureType::DEVICE_CREATE_INFO,
1513 p_next: ::std::ptr::null(),
1514 flags: DeviceCreateFlags::default(),
1515 queue_create_info_count: u32::default(),
1516 p_queue_create_infos: ::std::ptr::null(),
1517 enabled_layer_count: u32::default(),
1518 pp_enabled_layer_names: ::std::ptr::null(),
1519 enabled_extension_count: u32::default(),
1520 pp_enabled_extension_names: ::std::ptr::null(),
1521 p_enabled_features: ::std::ptr::null(),
1522 }
1523 }
1524}
1525impl DeviceCreateInfo {
1526 pub fn builder<'a>() -> DeviceCreateInfoBuilder<'a> {
1527 DeviceCreateInfoBuilder {
1528 inner: Self::default(),
1529 marker: ::std::marker::PhantomData,
1530 }
1531 }
1532}
1533#[repr(transparent)]
1534pub struct DeviceCreateInfoBuilder<'a> {
1535 inner: DeviceCreateInfo,
1536 marker: ::std::marker::PhantomData<&'a ()>,
1537}
1538pub unsafe trait ExtendsDeviceCreateInfo {}
1539impl<'a> ::std::ops::Deref for DeviceCreateInfoBuilder<'a> {
1540 type Target = DeviceCreateInfo;
1541 fn deref(&self) -> &Self::Target {
1542 &self.inner
1543 }
1544}
1545impl<'a> ::std::ops::DerefMut for DeviceCreateInfoBuilder<'a> {
1546 fn deref_mut(&mut self) -> &mut Self::Target {
1547 &mut self.inner
1548 }
1549}
1550impl<'a> DeviceCreateInfoBuilder<'a> {
1551 pub fn flags(mut self, flags: DeviceCreateFlags) -> Self {
1552 self.inner.flags = flags;
1553 self
1554 }
1555 pub fn queue_create_infos(mut self, queue_create_infos: &'a [DeviceQueueCreateInfo]) -> Self {
1556 self.inner.queue_create_info_count = queue_create_infos.len() as _;
1557 self.inner.p_queue_create_infos = queue_create_infos.as_ptr();
1558 self
1559 }
1560 pub fn enabled_layer_names(mut self, enabled_layer_names: &'a [*const c_char]) -> Self {
1561 self.inner.enabled_layer_count = enabled_layer_names.len() as _;
1562 self.inner.pp_enabled_layer_names = enabled_layer_names.as_ptr();
1563 self
1564 }
1565 pub fn enabled_extension_names(mut self, enabled_extension_names: &'a [*const c_char]) -> Self {
1566 self.inner.enabled_extension_count = enabled_extension_names.len() as _;
1567 self.inner.pp_enabled_extension_names = enabled_extension_names.as_ptr();
1568 self
1569 }
1570 pub fn enabled_features(mut self, enabled_features: &'a PhysicalDeviceFeatures) -> Self {
1571 self.inner.p_enabled_features = enabled_features;
1572 self
1573 }
1574 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
1575 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
1576 #[doc = r" valid extension structs can be pushed into the chain."]
1577 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
1578 #[doc = r" chain will look like `A -> D -> B -> C`."]
1579 pub fn push_next<T: ExtendsDeviceCreateInfo>(mut self, next: &'a mut T) -> Self {
1580 unsafe {
1581 let next_ptr = <*const T>::cast(next);
1582 let last_next = ptr_chain_iter(next).last().unwrap();
1583 (*last_next).p_next = self.inner.p_next as _;
1584 self.inner.p_next = next_ptr;
1585 }
1586 self
1587 }
1588 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1589 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1590 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
1591 pub fn build(self) -> DeviceCreateInfo {
1592 self.inner
1593 }
1594}
1595#[repr(C)]
1596#[cfg_attr(feature = "debug", derive(Debug))]
1597#[derive(Copy, Clone)]
1598#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkInstanceCreateInfo.html>"]
1599pub struct InstanceCreateInfo {
1600 pub s_type: StructureType,
1601 pub p_next: *const c_void,
1602 pub flags: InstanceCreateFlags,
1603 pub p_application_info: *const ApplicationInfo,
1604 pub enabled_layer_count: u32,
1605 pub pp_enabled_layer_names: *const *const c_char,
1606 pub enabled_extension_count: u32,
1607 pub pp_enabled_extension_names: *const *const c_char,
1608}
1609impl ::std::default::Default for InstanceCreateInfo {
1610 fn default() -> Self {
1611 Self {
1612 s_type: StructureType::INSTANCE_CREATE_INFO,
1613 p_next: ::std::ptr::null(),
1614 flags: InstanceCreateFlags::default(),
1615 p_application_info: ::std::ptr::null(),
1616 enabled_layer_count: u32::default(),
1617 pp_enabled_layer_names: ::std::ptr::null(),
1618 enabled_extension_count: u32::default(),
1619 pp_enabled_extension_names: ::std::ptr::null(),
1620 }
1621 }
1622}
1623impl InstanceCreateInfo {
1624 pub fn builder<'a>() -> InstanceCreateInfoBuilder<'a> {
1625 InstanceCreateInfoBuilder {
1626 inner: Self::default(),
1627 marker: ::std::marker::PhantomData,
1628 }
1629 }
1630}
1631#[repr(transparent)]
1632pub struct InstanceCreateInfoBuilder<'a> {
1633 inner: InstanceCreateInfo,
1634 marker: ::std::marker::PhantomData<&'a ()>,
1635}
1636pub unsafe trait ExtendsInstanceCreateInfo {}
1637impl<'a> ::std::ops::Deref for InstanceCreateInfoBuilder<'a> {
1638 type Target = InstanceCreateInfo;
1639 fn deref(&self) -> &Self::Target {
1640 &self.inner
1641 }
1642}
1643impl<'a> ::std::ops::DerefMut for InstanceCreateInfoBuilder<'a> {
1644 fn deref_mut(&mut self) -> &mut Self::Target {
1645 &mut self.inner
1646 }
1647}
1648impl<'a> InstanceCreateInfoBuilder<'a> {
1649 pub fn flags(mut self, flags: InstanceCreateFlags) -> Self {
1650 self.inner.flags = flags;
1651 self
1652 }
1653 pub fn application_info(mut self, application_info: &'a ApplicationInfo) -> Self {
1654 self.inner.p_application_info = application_info;
1655 self
1656 }
1657 pub fn enabled_layer_names(mut self, enabled_layer_names: &'a [*const c_char]) -> Self {
1658 self.inner.enabled_layer_count = enabled_layer_names.len() as _;
1659 self.inner.pp_enabled_layer_names = enabled_layer_names.as_ptr();
1660 self
1661 }
1662 pub fn enabled_extension_names(mut self, enabled_extension_names: &'a [*const c_char]) -> Self {
1663 self.inner.enabled_extension_count = enabled_extension_names.len() as _;
1664 self.inner.pp_enabled_extension_names = enabled_extension_names.as_ptr();
1665 self
1666 }
1667 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
1668 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
1669 #[doc = r" valid extension structs can be pushed into the chain."]
1670 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
1671 #[doc = r" chain will look like `A -> D -> B -> C`."]
1672 pub fn push_next<T: ExtendsInstanceCreateInfo>(mut self, next: &'a mut T) -> Self {
1673 unsafe {
1674 let next_ptr = <*const T>::cast(next);
1675 let last_next = ptr_chain_iter(next).last().unwrap();
1676 (*last_next).p_next = self.inner.p_next as _;
1677 self.inner.p_next = next_ptr;
1678 }
1679 self
1680 }
1681 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1682 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1683 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
1684 pub fn build(self) -> InstanceCreateInfo {
1685 self.inner
1686 }
1687}
1688#[repr(C)]
1689#[cfg_attr(feature = "debug", derive(Debug))]
1690#[derive(Copy, Clone, Default)]
1691#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyProperties.html>"]
1692pub struct QueueFamilyProperties {
1693 pub queue_flags: QueueFlags,
1694 pub queue_count: u32,
1695 pub timestamp_valid_bits: u32,
1696 pub min_image_transfer_granularity: Extent3D,
1697}
1698impl QueueFamilyProperties {
1699 pub fn builder<'a>() -> QueueFamilyPropertiesBuilder<'a> {
1700 QueueFamilyPropertiesBuilder {
1701 inner: Self::default(),
1702 marker: ::std::marker::PhantomData,
1703 }
1704 }
1705}
1706#[repr(transparent)]
1707pub struct QueueFamilyPropertiesBuilder<'a> {
1708 inner: QueueFamilyProperties,
1709 marker: ::std::marker::PhantomData<&'a ()>,
1710}
1711impl<'a> ::std::ops::Deref for QueueFamilyPropertiesBuilder<'a> {
1712 type Target = QueueFamilyProperties;
1713 fn deref(&self) -> &Self::Target {
1714 &self.inner
1715 }
1716}
1717impl<'a> ::std::ops::DerefMut for QueueFamilyPropertiesBuilder<'a> {
1718 fn deref_mut(&mut self) -> &mut Self::Target {
1719 &mut self.inner
1720 }
1721}
1722impl<'a> QueueFamilyPropertiesBuilder<'a> {
1723 pub fn queue_flags(mut self, queue_flags: QueueFlags) -> Self {
1724 self.inner.queue_flags = queue_flags;
1725 self
1726 }
1727 pub fn queue_count(mut self, queue_count: u32) -> Self {
1728 self.inner.queue_count = queue_count;
1729 self
1730 }
1731 pub fn timestamp_valid_bits(mut self, timestamp_valid_bits: u32) -> Self {
1732 self.inner.timestamp_valid_bits = timestamp_valid_bits;
1733 self
1734 }
1735 pub fn min_image_transfer_granularity(
1736 mut self,
1737 min_image_transfer_granularity: Extent3D,
1738 ) -> Self {
1739 self.inner.min_image_transfer_granularity = min_image_transfer_granularity;
1740 self
1741 }
1742 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1743 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1744 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
1745 pub fn build(self) -> QueueFamilyProperties {
1746 self.inner
1747 }
1748}
1749#[repr(C)]
1750#[cfg_attr(feature = "debug", derive(Debug))]
1751#[derive(Copy, Clone)]
1752#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMemoryProperties.html>"]
1753pub struct PhysicalDeviceMemoryProperties {
1754 pub memory_type_count: u32,
1755 pub memory_types: [MemoryType; MAX_MEMORY_TYPES],
1756 pub memory_heap_count: u32,
1757 pub memory_heaps: [MemoryHeap; MAX_MEMORY_HEAPS],
1758}
1759impl ::std::default::Default for PhysicalDeviceMemoryProperties {
1760 fn default() -> Self {
1761 Self {
1762 memory_type_count: u32::default(),
1763 memory_types: unsafe { ::std::mem::zeroed() },
1764 memory_heap_count: u32::default(),
1765 memory_heaps: unsafe { ::std::mem::zeroed() },
1766 }
1767 }
1768}
1769impl PhysicalDeviceMemoryProperties {
1770 pub fn builder<'a>() -> PhysicalDeviceMemoryPropertiesBuilder<'a> {
1771 PhysicalDeviceMemoryPropertiesBuilder {
1772 inner: Self::default(),
1773 marker: ::std::marker::PhantomData,
1774 }
1775 }
1776}
1777#[repr(transparent)]
1778pub struct PhysicalDeviceMemoryPropertiesBuilder<'a> {
1779 inner: PhysicalDeviceMemoryProperties,
1780 marker: ::std::marker::PhantomData<&'a ()>,
1781}
1782impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryPropertiesBuilder<'a> {
1783 type Target = PhysicalDeviceMemoryProperties;
1784 fn deref(&self) -> &Self::Target {
1785 &self.inner
1786 }
1787}
1788impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryPropertiesBuilder<'a> {
1789 fn deref_mut(&mut self) -> &mut Self::Target {
1790 &mut self.inner
1791 }
1792}
1793impl<'a> PhysicalDeviceMemoryPropertiesBuilder<'a> {
1794 pub fn memory_type_count(mut self, memory_type_count: u32) -> Self {
1795 self.inner.memory_type_count = memory_type_count;
1796 self
1797 }
1798 pub fn memory_types(mut self, memory_types: [MemoryType; MAX_MEMORY_TYPES]) -> Self {
1799 self.inner.memory_types = memory_types;
1800 self
1801 }
1802 pub fn memory_heap_count(mut self, memory_heap_count: u32) -> Self {
1803 self.inner.memory_heap_count = memory_heap_count;
1804 self
1805 }
1806 pub fn memory_heaps(mut self, memory_heaps: [MemoryHeap; MAX_MEMORY_HEAPS]) -> Self {
1807 self.inner.memory_heaps = memory_heaps;
1808 self
1809 }
1810 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1811 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1812 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
1813 pub fn build(self) -> PhysicalDeviceMemoryProperties {
1814 self.inner
1815 }
1816}
1817#[repr(C)]
1818#[cfg_attr(feature = "debug", derive(Debug))]
1819#[derive(Copy, Clone)]
1820#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryAllocateInfo.html>"]
1821pub struct MemoryAllocateInfo {
1822 pub s_type: StructureType,
1823 pub p_next: *const c_void,
1824 pub allocation_size: DeviceSize,
1825 pub memory_type_index: u32,
1826}
1827impl ::std::default::Default for MemoryAllocateInfo {
1828 fn default() -> Self {
1829 Self {
1830 s_type: StructureType::MEMORY_ALLOCATE_INFO,
1831 p_next: ::std::ptr::null(),
1832 allocation_size: DeviceSize::default(),
1833 memory_type_index: u32::default(),
1834 }
1835 }
1836}
1837impl MemoryAllocateInfo {
1838 pub fn builder<'a>() -> MemoryAllocateInfoBuilder<'a> {
1839 MemoryAllocateInfoBuilder {
1840 inner: Self::default(),
1841 marker: ::std::marker::PhantomData,
1842 }
1843 }
1844}
1845#[repr(transparent)]
1846pub struct MemoryAllocateInfoBuilder<'a> {
1847 inner: MemoryAllocateInfo,
1848 marker: ::std::marker::PhantomData<&'a ()>,
1849}
1850pub unsafe trait ExtendsMemoryAllocateInfo {}
1851impl<'a> ::std::ops::Deref for MemoryAllocateInfoBuilder<'a> {
1852 type Target = MemoryAllocateInfo;
1853 fn deref(&self) -> &Self::Target {
1854 &self.inner
1855 }
1856}
1857impl<'a> ::std::ops::DerefMut for MemoryAllocateInfoBuilder<'a> {
1858 fn deref_mut(&mut self) -> &mut Self::Target {
1859 &mut self.inner
1860 }
1861}
1862impl<'a> MemoryAllocateInfoBuilder<'a> {
1863 pub fn allocation_size(mut self, allocation_size: DeviceSize) -> Self {
1864 self.inner.allocation_size = allocation_size;
1865 self
1866 }
1867 pub fn memory_type_index(mut self, memory_type_index: u32) -> Self {
1868 self.inner.memory_type_index = memory_type_index;
1869 self
1870 }
1871 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
1872 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
1873 #[doc = r" valid extension structs can be pushed into the chain."]
1874 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
1875 #[doc = r" chain will look like `A -> D -> B -> C`."]
1876 pub fn push_next<T: ExtendsMemoryAllocateInfo>(mut self, next: &'a mut T) -> Self {
1877 unsafe {
1878 let next_ptr = <*const T>::cast(next);
1879 let last_next = ptr_chain_iter(next).last().unwrap();
1880 (*last_next).p_next = self.inner.p_next as _;
1881 self.inner.p_next = next_ptr;
1882 }
1883 self
1884 }
1885 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1886 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1887 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
1888 pub fn build(self) -> MemoryAllocateInfo {
1889 self.inner
1890 }
1891}
1892#[repr(C)]
1893#[cfg_attr(feature = "debug", derive(Debug))]
1894#[derive(Copy, Clone, Default)]
1895#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryRequirements.html>"]
1896pub struct MemoryRequirements {
1897 pub size: DeviceSize,
1898 pub alignment: DeviceSize,
1899 pub memory_type_bits: u32,
1900}
1901impl MemoryRequirements {
1902 pub fn builder<'a>() -> MemoryRequirementsBuilder<'a> {
1903 MemoryRequirementsBuilder {
1904 inner: Self::default(),
1905 marker: ::std::marker::PhantomData,
1906 }
1907 }
1908}
1909#[repr(transparent)]
1910pub struct MemoryRequirementsBuilder<'a> {
1911 inner: MemoryRequirements,
1912 marker: ::std::marker::PhantomData<&'a ()>,
1913}
1914impl<'a> ::std::ops::Deref for MemoryRequirementsBuilder<'a> {
1915 type Target = MemoryRequirements;
1916 fn deref(&self) -> &Self::Target {
1917 &self.inner
1918 }
1919}
1920impl<'a> ::std::ops::DerefMut for MemoryRequirementsBuilder<'a> {
1921 fn deref_mut(&mut self) -> &mut Self::Target {
1922 &mut self.inner
1923 }
1924}
1925impl<'a> MemoryRequirementsBuilder<'a> {
1926 pub fn size(mut self, size: DeviceSize) -> Self {
1927 self.inner.size = size;
1928 self
1929 }
1930 pub fn alignment(mut self, alignment: DeviceSize) -> Self {
1931 self.inner.alignment = alignment;
1932 self
1933 }
1934 pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self {
1935 self.inner.memory_type_bits = memory_type_bits;
1936 self
1937 }
1938 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1939 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1940 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
1941 pub fn build(self) -> MemoryRequirements {
1942 self.inner
1943 }
1944}
1945#[repr(C)]
1946#[cfg_attr(feature = "debug", derive(Debug))]
1947#[derive(Copy, Clone, Default)]
1948#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageFormatProperties.html>"]
1949pub struct SparseImageFormatProperties {
1950 pub aspect_mask: ImageAspectFlags,
1951 pub image_granularity: Extent3D,
1952 pub flags: SparseImageFormatFlags,
1953}
1954impl SparseImageFormatProperties {
1955 pub fn builder<'a>() -> SparseImageFormatPropertiesBuilder<'a> {
1956 SparseImageFormatPropertiesBuilder {
1957 inner: Self::default(),
1958 marker: ::std::marker::PhantomData,
1959 }
1960 }
1961}
1962#[repr(transparent)]
1963pub struct SparseImageFormatPropertiesBuilder<'a> {
1964 inner: SparseImageFormatProperties,
1965 marker: ::std::marker::PhantomData<&'a ()>,
1966}
1967impl<'a> ::std::ops::Deref for SparseImageFormatPropertiesBuilder<'a> {
1968 type Target = SparseImageFormatProperties;
1969 fn deref(&self) -> &Self::Target {
1970 &self.inner
1971 }
1972}
1973impl<'a> ::std::ops::DerefMut for SparseImageFormatPropertiesBuilder<'a> {
1974 fn deref_mut(&mut self) -> &mut Self::Target {
1975 &mut self.inner
1976 }
1977}
1978impl<'a> SparseImageFormatPropertiesBuilder<'a> {
1979 pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self {
1980 self.inner.aspect_mask = aspect_mask;
1981 self
1982 }
1983 pub fn image_granularity(mut self, image_granularity: Extent3D) -> Self {
1984 self.inner.image_granularity = image_granularity;
1985 self
1986 }
1987 pub fn flags(mut self, flags: SparseImageFormatFlags) -> Self {
1988 self.inner.flags = flags;
1989 self
1990 }
1991 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1992 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1993 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
1994 pub fn build(self) -> SparseImageFormatProperties {
1995 self.inner
1996 }
1997}
1998#[repr(C)]
1999#[cfg_attr(feature = "debug", derive(Debug))]
2000#[derive(Copy, Clone, Default)]
2001#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageMemoryRequirements.html>"]
2002pub struct SparseImageMemoryRequirements {
2003 pub format_properties: SparseImageFormatProperties,
2004 pub image_mip_tail_first_lod: u32,
2005 pub image_mip_tail_size: DeviceSize,
2006 pub image_mip_tail_offset: DeviceSize,
2007 pub image_mip_tail_stride: DeviceSize,
2008}
2009impl SparseImageMemoryRequirements {
2010 pub fn builder<'a>() -> SparseImageMemoryRequirementsBuilder<'a> {
2011 SparseImageMemoryRequirementsBuilder {
2012 inner: Self::default(),
2013 marker: ::std::marker::PhantomData,
2014 }
2015 }
2016}
2017#[repr(transparent)]
2018pub struct SparseImageMemoryRequirementsBuilder<'a> {
2019 inner: SparseImageMemoryRequirements,
2020 marker: ::std::marker::PhantomData<&'a ()>,
2021}
2022impl<'a> ::std::ops::Deref for SparseImageMemoryRequirementsBuilder<'a> {
2023 type Target = SparseImageMemoryRequirements;
2024 fn deref(&self) -> &Self::Target {
2025 &self.inner
2026 }
2027}
2028impl<'a> ::std::ops::DerefMut for SparseImageMemoryRequirementsBuilder<'a> {
2029 fn deref_mut(&mut self) -> &mut Self::Target {
2030 &mut self.inner
2031 }
2032}
2033impl<'a> SparseImageMemoryRequirementsBuilder<'a> {
2034 pub fn format_properties(mut self, format_properties: SparseImageFormatProperties) -> Self {
2035 self.inner.format_properties = format_properties;
2036 self
2037 }
2038 pub fn image_mip_tail_first_lod(mut self, image_mip_tail_first_lod: u32) -> Self {
2039 self.inner.image_mip_tail_first_lod = image_mip_tail_first_lod;
2040 self
2041 }
2042 pub fn image_mip_tail_size(mut self, image_mip_tail_size: DeviceSize) -> Self {
2043 self.inner.image_mip_tail_size = image_mip_tail_size;
2044 self
2045 }
2046 pub fn image_mip_tail_offset(mut self, image_mip_tail_offset: DeviceSize) -> Self {
2047 self.inner.image_mip_tail_offset = image_mip_tail_offset;
2048 self
2049 }
2050 pub fn image_mip_tail_stride(mut self, image_mip_tail_stride: DeviceSize) -> Self {
2051 self.inner.image_mip_tail_stride = image_mip_tail_stride;
2052 self
2053 }
2054 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2055 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2056 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2057 pub fn build(self) -> SparseImageMemoryRequirements {
2058 self.inner
2059 }
2060}
2061#[repr(C)]
2062#[cfg_attr(feature = "debug", derive(Debug))]
2063#[derive(Copy, Clone, Default)]
2064#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryType.html>"]
2065pub struct MemoryType {
2066 pub property_flags: MemoryPropertyFlags,
2067 pub heap_index: u32,
2068}
2069impl MemoryType {
2070 pub fn builder<'a>() -> MemoryTypeBuilder<'a> {
2071 MemoryTypeBuilder {
2072 inner: Self::default(),
2073 marker: ::std::marker::PhantomData,
2074 }
2075 }
2076}
2077#[repr(transparent)]
2078pub struct MemoryTypeBuilder<'a> {
2079 inner: MemoryType,
2080 marker: ::std::marker::PhantomData<&'a ()>,
2081}
2082impl<'a> ::std::ops::Deref for MemoryTypeBuilder<'a> {
2083 type Target = MemoryType;
2084 fn deref(&self) -> &Self::Target {
2085 &self.inner
2086 }
2087}
2088impl<'a> ::std::ops::DerefMut for MemoryTypeBuilder<'a> {
2089 fn deref_mut(&mut self) -> &mut Self::Target {
2090 &mut self.inner
2091 }
2092}
2093impl<'a> MemoryTypeBuilder<'a> {
2094 pub fn property_flags(mut self, property_flags: MemoryPropertyFlags) -> Self {
2095 self.inner.property_flags = property_flags;
2096 self
2097 }
2098 pub fn heap_index(mut self, heap_index: u32) -> Self {
2099 self.inner.heap_index = heap_index;
2100 self
2101 }
2102 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2103 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2104 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2105 pub fn build(self) -> MemoryType {
2106 self.inner
2107 }
2108}
2109#[repr(C)]
2110#[cfg_attr(feature = "debug", derive(Debug))]
2111#[derive(Copy, Clone, Default)]
2112#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryHeap.html>"]
2113pub struct MemoryHeap {
2114 pub size: DeviceSize,
2115 pub flags: MemoryHeapFlags,
2116}
2117impl MemoryHeap {
2118 pub fn builder<'a>() -> MemoryHeapBuilder<'a> {
2119 MemoryHeapBuilder {
2120 inner: Self::default(),
2121 marker: ::std::marker::PhantomData,
2122 }
2123 }
2124}
2125#[repr(transparent)]
2126pub struct MemoryHeapBuilder<'a> {
2127 inner: MemoryHeap,
2128 marker: ::std::marker::PhantomData<&'a ()>,
2129}
2130impl<'a> ::std::ops::Deref for MemoryHeapBuilder<'a> {
2131 type Target = MemoryHeap;
2132 fn deref(&self) -> &Self::Target {
2133 &self.inner
2134 }
2135}
2136impl<'a> ::std::ops::DerefMut for MemoryHeapBuilder<'a> {
2137 fn deref_mut(&mut self) -> &mut Self::Target {
2138 &mut self.inner
2139 }
2140}
2141impl<'a> MemoryHeapBuilder<'a> {
2142 pub fn size(mut self, size: DeviceSize) -> Self {
2143 self.inner.size = size;
2144 self
2145 }
2146 pub fn flags(mut self, flags: MemoryHeapFlags) -> Self {
2147 self.inner.flags = flags;
2148 self
2149 }
2150 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2151 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2152 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2153 pub fn build(self) -> MemoryHeap {
2154 self.inner
2155 }
2156}
2157#[repr(C)]
2158#[cfg_attr(feature = "debug", derive(Debug))]
2159#[derive(Copy, Clone)]
2160#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMappedMemoryRange.html>"]
2161pub struct MappedMemoryRange {
2162 pub s_type: StructureType,
2163 pub p_next: *const c_void,
2164 pub memory: DeviceMemory,
2165 pub offset: DeviceSize,
2166 pub size: DeviceSize,
2167}
2168impl ::std::default::Default for MappedMemoryRange {
2169 fn default() -> Self {
2170 Self {
2171 s_type: StructureType::MAPPED_MEMORY_RANGE,
2172 p_next: ::std::ptr::null(),
2173 memory: DeviceMemory::default(),
2174 offset: DeviceSize::default(),
2175 size: DeviceSize::default(),
2176 }
2177 }
2178}
2179impl MappedMemoryRange {
2180 pub fn builder<'a>() -> MappedMemoryRangeBuilder<'a> {
2181 MappedMemoryRangeBuilder {
2182 inner: Self::default(),
2183 marker: ::std::marker::PhantomData,
2184 }
2185 }
2186}
2187#[repr(transparent)]
2188pub struct MappedMemoryRangeBuilder<'a> {
2189 inner: MappedMemoryRange,
2190 marker: ::std::marker::PhantomData<&'a ()>,
2191}
2192impl<'a> ::std::ops::Deref for MappedMemoryRangeBuilder<'a> {
2193 type Target = MappedMemoryRange;
2194 fn deref(&self) -> &Self::Target {
2195 &self.inner
2196 }
2197}
2198impl<'a> ::std::ops::DerefMut for MappedMemoryRangeBuilder<'a> {
2199 fn deref_mut(&mut self) -> &mut Self::Target {
2200 &mut self.inner
2201 }
2202}
2203impl<'a> MappedMemoryRangeBuilder<'a> {
2204 pub fn memory(mut self, memory: DeviceMemory) -> Self {
2205 self.inner.memory = memory;
2206 self
2207 }
2208 pub fn offset(mut self, offset: DeviceSize) -> Self {
2209 self.inner.offset = offset;
2210 self
2211 }
2212 pub fn size(mut self, size: DeviceSize) -> Self {
2213 self.inner.size = size;
2214 self
2215 }
2216 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2217 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2218 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2219 pub fn build(self) -> MappedMemoryRange {
2220 self.inner
2221 }
2222}
2223#[repr(C)]
2224#[cfg_attr(feature = "debug", derive(Debug))]
2225#[derive(Copy, Clone, Default)]
2226#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFormatProperties.html>"]
2227pub struct FormatProperties {
2228 pub linear_tiling_features: FormatFeatureFlags,
2229 pub optimal_tiling_features: FormatFeatureFlags,
2230 pub buffer_features: FormatFeatureFlags,
2231}
2232impl FormatProperties {
2233 pub fn builder<'a>() -> FormatPropertiesBuilder<'a> {
2234 FormatPropertiesBuilder {
2235 inner: Self::default(),
2236 marker: ::std::marker::PhantomData,
2237 }
2238 }
2239}
2240#[repr(transparent)]
2241pub struct FormatPropertiesBuilder<'a> {
2242 inner: FormatProperties,
2243 marker: ::std::marker::PhantomData<&'a ()>,
2244}
2245impl<'a> ::std::ops::Deref for FormatPropertiesBuilder<'a> {
2246 type Target = FormatProperties;
2247 fn deref(&self) -> &Self::Target {
2248 &self.inner
2249 }
2250}
2251impl<'a> ::std::ops::DerefMut for FormatPropertiesBuilder<'a> {
2252 fn deref_mut(&mut self) -> &mut Self::Target {
2253 &mut self.inner
2254 }
2255}
2256impl<'a> FormatPropertiesBuilder<'a> {
2257 pub fn linear_tiling_features(mut self, linear_tiling_features: FormatFeatureFlags) -> Self {
2258 self.inner.linear_tiling_features = linear_tiling_features;
2259 self
2260 }
2261 pub fn optimal_tiling_features(mut self, optimal_tiling_features: FormatFeatureFlags) -> Self {
2262 self.inner.optimal_tiling_features = optimal_tiling_features;
2263 self
2264 }
2265 pub fn buffer_features(mut self, buffer_features: FormatFeatureFlags) -> Self {
2266 self.inner.buffer_features = buffer_features;
2267 self
2268 }
2269 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2270 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2271 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2272 pub fn build(self) -> FormatProperties {
2273 self.inner
2274 }
2275}
2276#[repr(C)]
2277#[cfg_attr(feature = "debug", derive(Debug))]
2278#[derive(Copy, Clone, Default)]
2279#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageFormatProperties.html>"]
2280pub struct ImageFormatProperties {
2281 pub max_extent: Extent3D,
2282 pub max_mip_levels: u32,
2283 pub max_array_layers: u32,
2284 pub sample_counts: SampleCountFlags,
2285 pub max_resource_size: DeviceSize,
2286}
2287impl ImageFormatProperties {
2288 pub fn builder<'a>() -> ImageFormatPropertiesBuilder<'a> {
2289 ImageFormatPropertiesBuilder {
2290 inner: Self::default(),
2291 marker: ::std::marker::PhantomData,
2292 }
2293 }
2294}
2295#[repr(transparent)]
2296pub struct ImageFormatPropertiesBuilder<'a> {
2297 inner: ImageFormatProperties,
2298 marker: ::std::marker::PhantomData<&'a ()>,
2299}
2300impl<'a> ::std::ops::Deref for ImageFormatPropertiesBuilder<'a> {
2301 type Target = ImageFormatProperties;
2302 fn deref(&self) -> &Self::Target {
2303 &self.inner
2304 }
2305}
2306impl<'a> ::std::ops::DerefMut for ImageFormatPropertiesBuilder<'a> {
2307 fn deref_mut(&mut self) -> &mut Self::Target {
2308 &mut self.inner
2309 }
2310}
2311impl<'a> ImageFormatPropertiesBuilder<'a> {
2312 pub fn max_extent(mut self, max_extent: Extent3D) -> Self {
2313 self.inner.max_extent = max_extent;
2314 self
2315 }
2316 pub fn max_mip_levels(mut self, max_mip_levels: u32) -> Self {
2317 self.inner.max_mip_levels = max_mip_levels;
2318 self
2319 }
2320 pub fn max_array_layers(mut self, max_array_layers: u32) -> Self {
2321 self.inner.max_array_layers = max_array_layers;
2322 self
2323 }
2324 pub fn sample_counts(mut self, sample_counts: SampleCountFlags) -> Self {
2325 self.inner.sample_counts = sample_counts;
2326 self
2327 }
2328 pub fn max_resource_size(mut self, max_resource_size: DeviceSize) -> Self {
2329 self.inner.max_resource_size = max_resource_size;
2330 self
2331 }
2332 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2333 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2334 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2335 pub fn build(self) -> ImageFormatProperties {
2336 self.inner
2337 }
2338}
2339#[repr(C)]
2340#[cfg_attr(feature = "debug", derive(Debug))]
2341#[derive(Copy, Clone, Default)]
2342#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorBufferInfo.html>"]
2343pub struct DescriptorBufferInfo {
2344 pub buffer: Buffer,
2345 pub offset: DeviceSize,
2346 pub range: DeviceSize,
2347}
2348impl DescriptorBufferInfo {
2349 pub fn builder<'a>() -> DescriptorBufferInfoBuilder<'a> {
2350 DescriptorBufferInfoBuilder {
2351 inner: Self::default(),
2352 marker: ::std::marker::PhantomData,
2353 }
2354 }
2355}
2356#[repr(transparent)]
2357pub struct DescriptorBufferInfoBuilder<'a> {
2358 inner: DescriptorBufferInfo,
2359 marker: ::std::marker::PhantomData<&'a ()>,
2360}
2361impl<'a> ::std::ops::Deref for DescriptorBufferInfoBuilder<'a> {
2362 type Target = DescriptorBufferInfo;
2363 fn deref(&self) -> &Self::Target {
2364 &self.inner
2365 }
2366}
2367impl<'a> ::std::ops::DerefMut for DescriptorBufferInfoBuilder<'a> {
2368 fn deref_mut(&mut self) -> &mut Self::Target {
2369 &mut self.inner
2370 }
2371}
2372impl<'a> DescriptorBufferInfoBuilder<'a> {
2373 pub fn buffer(mut self, buffer: Buffer) -> Self {
2374 self.inner.buffer = buffer;
2375 self
2376 }
2377 pub fn offset(mut self, offset: DeviceSize) -> Self {
2378 self.inner.offset = offset;
2379 self
2380 }
2381 pub fn range(mut self, range: DeviceSize) -> Self {
2382 self.inner.range = range;
2383 self
2384 }
2385 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2386 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2387 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2388 pub fn build(self) -> DescriptorBufferInfo {
2389 self.inner
2390 }
2391}
2392#[repr(C)]
2393#[cfg_attr(feature = "debug", derive(Debug))]
2394#[derive(Copy, Clone, Default)]
2395#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorImageInfo.html>"]
2396pub struct DescriptorImageInfo {
2397 pub sampler: Sampler,
2398 pub image_view: ImageView,
2399 pub image_layout: ImageLayout,
2400}
2401impl DescriptorImageInfo {
2402 pub fn builder<'a>() -> DescriptorImageInfoBuilder<'a> {
2403 DescriptorImageInfoBuilder {
2404 inner: Self::default(),
2405 marker: ::std::marker::PhantomData,
2406 }
2407 }
2408}
2409#[repr(transparent)]
2410pub struct DescriptorImageInfoBuilder<'a> {
2411 inner: DescriptorImageInfo,
2412 marker: ::std::marker::PhantomData<&'a ()>,
2413}
2414impl<'a> ::std::ops::Deref for DescriptorImageInfoBuilder<'a> {
2415 type Target = DescriptorImageInfo;
2416 fn deref(&self) -> &Self::Target {
2417 &self.inner
2418 }
2419}
2420impl<'a> ::std::ops::DerefMut for DescriptorImageInfoBuilder<'a> {
2421 fn deref_mut(&mut self) -> &mut Self::Target {
2422 &mut self.inner
2423 }
2424}
2425impl<'a> DescriptorImageInfoBuilder<'a> {
2426 pub fn sampler(mut self, sampler: Sampler) -> Self {
2427 self.inner.sampler = sampler;
2428 self
2429 }
2430 pub fn image_view(mut self, image_view: ImageView) -> Self {
2431 self.inner.image_view = image_view;
2432 self
2433 }
2434 pub fn image_layout(mut self, image_layout: ImageLayout) -> Self {
2435 self.inner.image_layout = image_layout;
2436 self
2437 }
2438 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2439 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2440 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2441 pub fn build(self) -> DescriptorImageInfo {
2442 self.inner
2443 }
2444}
2445#[repr(C)]
2446#[cfg_attr(feature = "debug", derive(Debug))]
2447#[derive(Copy, Clone)]
2448#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWriteDescriptorSet.html>"]
2449pub struct WriteDescriptorSet {
2450 pub s_type: StructureType,
2451 pub p_next: *const c_void,
2452 pub dst_set: DescriptorSet,
2453 pub dst_binding: u32,
2454 pub dst_array_element: u32,
2455 pub descriptor_count: u32,
2456 pub descriptor_type: DescriptorType,
2457 pub p_image_info: *const DescriptorImageInfo,
2458 pub p_buffer_info: *const DescriptorBufferInfo,
2459 pub p_texel_buffer_view: *const BufferView,
2460}
2461impl ::std::default::Default for WriteDescriptorSet {
2462 fn default() -> Self {
2463 Self {
2464 s_type: StructureType::WRITE_DESCRIPTOR_SET,
2465 p_next: ::std::ptr::null(),
2466 dst_set: DescriptorSet::default(),
2467 dst_binding: u32::default(),
2468 dst_array_element: u32::default(),
2469 descriptor_count: u32::default(),
2470 descriptor_type: DescriptorType::default(),
2471 p_image_info: ::std::ptr::null(),
2472 p_buffer_info: ::std::ptr::null(),
2473 p_texel_buffer_view: ::std::ptr::null(),
2474 }
2475 }
2476}
2477impl WriteDescriptorSet {
2478 pub fn builder<'a>() -> WriteDescriptorSetBuilder<'a> {
2479 WriteDescriptorSetBuilder {
2480 inner: Self::default(),
2481 marker: ::std::marker::PhantomData,
2482 }
2483 }
2484}
2485#[repr(transparent)]
2486pub struct WriteDescriptorSetBuilder<'a> {
2487 inner: WriteDescriptorSet,
2488 marker: ::std::marker::PhantomData<&'a ()>,
2489}
2490pub unsafe trait ExtendsWriteDescriptorSet {}
2491impl<'a> ::std::ops::Deref for WriteDescriptorSetBuilder<'a> {
2492 type Target = WriteDescriptorSet;
2493 fn deref(&self) -> &Self::Target {
2494 &self.inner
2495 }
2496}
2497impl<'a> ::std::ops::DerefMut for WriteDescriptorSetBuilder<'a> {
2498 fn deref_mut(&mut self) -> &mut Self::Target {
2499 &mut self.inner
2500 }
2501}
2502impl<'a> WriteDescriptorSetBuilder<'a> {
2503 pub fn dst_set(mut self, dst_set: DescriptorSet) -> Self {
2504 self.inner.dst_set = dst_set;
2505 self
2506 }
2507 pub fn dst_binding(mut self, dst_binding: u32) -> Self {
2508 self.inner.dst_binding = dst_binding;
2509 self
2510 }
2511 pub fn dst_array_element(mut self, dst_array_element: u32) -> Self {
2512 self.inner.dst_array_element = dst_array_element;
2513 self
2514 }
2515 pub fn descriptor_type(mut self, descriptor_type: DescriptorType) -> Self {
2516 self.inner.descriptor_type = descriptor_type;
2517 self
2518 }
2519 pub fn image_info(mut self, image_info: &'a [DescriptorImageInfo]) -> Self {
2520 self.inner.descriptor_count = image_info.len() as _;
2521 self.inner.p_image_info = image_info.as_ptr();
2522 self
2523 }
2524 pub fn buffer_info(mut self, buffer_info: &'a [DescriptorBufferInfo]) -> Self {
2525 self.inner.descriptor_count = buffer_info.len() as _;
2526 self.inner.p_buffer_info = buffer_info.as_ptr();
2527 self
2528 }
2529 pub fn texel_buffer_view(mut self, texel_buffer_view: &'a [BufferView]) -> Self {
2530 self.inner.descriptor_count = texel_buffer_view.len() as _;
2531 self.inner.p_texel_buffer_view = texel_buffer_view.as_ptr();
2532 self
2533 }
2534 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
2535 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
2536 #[doc = r" valid extension structs can be pushed into the chain."]
2537 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
2538 #[doc = r" chain will look like `A -> D -> B -> C`."]
2539 pub fn push_next<T: ExtendsWriteDescriptorSet>(mut self, next: &'a mut T) -> Self {
2540 unsafe {
2541 let next_ptr = <*const T>::cast(next);
2542 let last_next = ptr_chain_iter(next).last().unwrap();
2543 (*last_next).p_next = self.inner.p_next as _;
2544 self.inner.p_next = next_ptr;
2545 }
2546 self
2547 }
2548 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2549 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2550 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2551 pub fn build(self) -> WriteDescriptorSet {
2552 self.inner
2553 }
2554}
2555#[repr(C)]
2556#[cfg_attr(feature = "debug", derive(Debug))]
2557#[derive(Copy, Clone)]
2558#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyDescriptorSet.html>"]
2559pub struct CopyDescriptorSet {
2560 pub s_type: StructureType,
2561 pub p_next: *const c_void,
2562 pub src_set: DescriptorSet,
2563 pub src_binding: u32,
2564 pub src_array_element: u32,
2565 pub dst_set: DescriptorSet,
2566 pub dst_binding: u32,
2567 pub dst_array_element: u32,
2568 pub descriptor_count: u32,
2569}
2570impl ::std::default::Default for CopyDescriptorSet {
2571 fn default() -> Self {
2572 Self {
2573 s_type: StructureType::COPY_DESCRIPTOR_SET,
2574 p_next: ::std::ptr::null(),
2575 src_set: DescriptorSet::default(),
2576 src_binding: u32::default(),
2577 src_array_element: u32::default(),
2578 dst_set: DescriptorSet::default(),
2579 dst_binding: u32::default(),
2580 dst_array_element: u32::default(),
2581 descriptor_count: u32::default(),
2582 }
2583 }
2584}
2585impl CopyDescriptorSet {
2586 pub fn builder<'a>() -> CopyDescriptorSetBuilder<'a> {
2587 CopyDescriptorSetBuilder {
2588 inner: Self::default(),
2589 marker: ::std::marker::PhantomData,
2590 }
2591 }
2592}
2593#[repr(transparent)]
2594pub struct CopyDescriptorSetBuilder<'a> {
2595 inner: CopyDescriptorSet,
2596 marker: ::std::marker::PhantomData<&'a ()>,
2597}
2598impl<'a> ::std::ops::Deref for CopyDescriptorSetBuilder<'a> {
2599 type Target = CopyDescriptorSet;
2600 fn deref(&self) -> &Self::Target {
2601 &self.inner
2602 }
2603}
2604impl<'a> ::std::ops::DerefMut for CopyDescriptorSetBuilder<'a> {
2605 fn deref_mut(&mut self) -> &mut Self::Target {
2606 &mut self.inner
2607 }
2608}
2609impl<'a> CopyDescriptorSetBuilder<'a> {
2610 pub fn src_set(mut self, src_set: DescriptorSet) -> Self {
2611 self.inner.src_set = src_set;
2612 self
2613 }
2614 pub fn src_binding(mut self, src_binding: u32) -> Self {
2615 self.inner.src_binding = src_binding;
2616 self
2617 }
2618 pub fn src_array_element(mut self, src_array_element: u32) -> Self {
2619 self.inner.src_array_element = src_array_element;
2620 self
2621 }
2622 pub fn dst_set(mut self, dst_set: DescriptorSet) -> Self {
2623 self.inner.dst_set = dst_set;
2624 self
2625 }
2626 pub fn dst_binding(mut self, dst_binding: u32) -> Self {
2627 self.inner.dst_binding = dst_binding;
2628 self
2629 }
2630 pub fn dst_array_element(mut self, dst_array_element: u32) -> Self {
2631 self.inner.dst_array_element = dst_array_element;
2632 self
2633 }
2634 pub fn descriptor_count(mut self, descriptor_count: u32) -> Self {
2635 self.inner.descriptor_count = descriptor_count;
2636 self
2637 }
2638 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2639 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2640 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2641 pub fn build(self) -> CopyDescriptorSet {
2642 self.inner
2643 }
2644}
2645#[repr(C)]
2646#[cfg_attr(feature = "debug", derive(Debug))]
2647#[derive(Copy, Clone)]
2648#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCreateInfo.html>"]
2649pub struct BufferCreateInfo {
2650 pub s_type: StructureType,
2651 pub p_next: *const c_void,
2652 pub flags: BufferCreateFlags,
2653 pub size: DeviceSize,
2654 pub usage: BufferUsageFlags,
2655 pub sharing_mode: SharingMode,
2656 pub queue_family_index_count: u32,
2657 pub p_queue_family_indices: *const u32,
2658}
2659impl ::std::default::Default for BufferCreateInfo {
2660 fn default() -> Self {
2661 Self {
2662 s_type: StructureType::BUFFER_CREATE_INFO,
2663 p_next: ::std::ptr::null(),
2664 flags: BufferCreateFlags::default(),
2665 size: DeviceSize::default(),
2666 usage: BufferUsageFlags::default(),
2667 sharing_mode: SharingMode::default(),
2668 queue_family_index_count: u32::default(),
2669 p_queue_family_indices: ::std::ptr::null(),
2670 }
2671 }
2672}
2673impl BufferCreateInfo {
2674 pub fn builder<'a>() -> BufferCreateInfoBuilder<'a> {
2675 BufferCreateInfoBuilder {
2676 inner: Self::default(),
2677 marker: ::std::marker::PhantomData,
2678 }
2679 }
2680}
2681#[repr(transparent)]
2682pub struct BufferCreateInfoBuilder<'a> {
2683 inner: BufferCreateInfo,
2684 marker: ::std::marker::PhantomData<&'a ()>,
2685}
2686pub unsafe trait ExtendsBufferCreateInfo {}
2687impl<'a> ::std::ops::Deref for BufferCreateInfoBuilder<'a> {
2688 type Target = BufferCreateInfo;
2689 fn deref(&self) -> &Self::Target {
2690 &self.inner
2691 }
2692}
2693impl<'a> ::std::ops::DerefMut for BufferCreateInfoBuilder<'a> {
2694 fn deref_mut(&mut self) -> &mut Self::Target {
2695 &mut self.inner
2696 }
2697}
2698impl<'a> BufferCreateInfoBuilder<'a> {
2699 pub fn flags(mut self, flags: BufferCreateFlags) -> Self {
2700 self.inner.flags = flags;
2701 self
2702 }
2703 pub fn size(mut self, size: DeviceSize) -> Self {
2704 self.inner.size = size;
2705 self
2706 }
2707 pub fn usage(mut self, usage: BufferUsageFlags) -> Self {
2708 self.inner.usage = usage;
2709 self
2710 }
2711 pub fn sharing_mode(mut self, sharing_mode: SharingMode) -> Self {
2712 self.inner.sharing_mode = sharing_mode;
2713 self
2714 }
2715 pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self {
2716 self.inner.queue_family_index_count = queue_family_indices.len() as _;
2717 self.inner.p_queue_family_indices = queue_family_indices.as_ptr();
2718 self
2719 }
2720 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
2721 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
2722 #[doc = r" valid extension structs can be pushed into the chain."]
2723 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
2724 #[doc = r" chain will look like `A -> D -> B -> C`."]
2725 pub fn push_next<T: ExtendsBufferCreateInfo>(mut self, next: &'a mut T) -> Self {
2726 unsafe {
2727 let next_ptr = <*const T>::cast(next);
2728 let last_next = ptr_chain_iter(next).last().unwrap();
2729 (*last_next).p_next = self.inner.p_next as _;
2730 self.inner.p_next = next_ptr;
2731 }
2732 self
2733 }
2734 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2735 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2736 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2737 pub fn build(self) -> BufferCreateInfo {
2738 self.inner
2739 }
2740}
2741#[repr(C)]
2742#[cfg_attr(feature = "debug", derive(Debug))]
2743#[derive(Copy, Clone)]
2744#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferViewCreateInfo.html>"]
2745pub struct BufferViewCreateInfo {
2746 pub s_type: StructureType,
2747 pub p_next: *const c_void,
2748 pub flags: BufferViewCreateFlags,
2749 pub buffer: Buffer,
2750 pub format: Format,
2751 pub offset: DeviceSize,
2752 pub range: DeviceSize,
2753}
2754impl ::std::default::Default for BufferViewCreateInfo {
2755 fn default() -> Self {
2756 Self {
2757 s_type: StructureType::BUFFER_VIEW_CREATE_INFO,
2758 p_next: ::std::ptr::null(),
2759 flags: BufferViewCreateFlags::default(),
2760 buffer: Buffer::default(),
2761 format: Format::default(),
2762 offset: DeviceSize::default(),
2763 range: DeviceSize::default(),
2764 }
2765 }
2766}
2767impl BufferViewCreateInfo {
2768 pub fn builder<'a>() -> BufferViewCreateInfoBuilder<'a> {
2769 BufferViewCreateInfoBuilder {
2770 inner: Self::default(),
2771 marker: ::std::marker::PhantomData,
2772 }
2773 }
2774}
2775#[repr(transparent)]
2776pub struct BufferViewCreateInfoBuilder<'a> {
2777 inner: BufferViewCreateInfo,
2778 marker: ::std::marker::PhantomData<&'a ()>,
2779}
2780impl<'a> ::std::ops::Deref for BufferViewCreateInfoBuilder<'a> {
2781 type Target = BufferViewCreateInfo;
2782 fn deref(&self) -> &Self::Target {
2783 &self.inner
2784 }
2785}
2786impl<'a> ::std::ops::DerefMut for BufferViewCreateInfoBuilder<'a> {
2787 fn deref_mut(&mut self) -> &mut Self::Target {
2788 &mut self.inner
2789 }
2790}
2791impl<'a> BufferViewCreateInfoBuilder<'a> {
2792 pub fn flags(mut self, flags: BufferViewCreateFlags) -> Self {
2793 self.inner.flags = flags;
2794 self
2795 }
2796 pub fn buffer(mut self, buffer: Buffer) -> Self {
2797 self.inner.buffer = buffer;
2798 self
2799 }
2800 pub fn format(mut self, format: Format) -> Self {
2801 self.inner.format = format;
2802 self
2803 }
2804 pub fn offset(mut self, offset: DeviceSize) -> Self {
2805 self.inner.offset = offset;
2806 self
2807 }
2808 pub fn range(mut self, range: DeviceSize) -> Self {
2809 self.inner.range = range;
2810 self
2811 }
2812 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2813 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2814 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2815 pub fn build(self) -> BufferViewCreateInfo {
2816 self.inner
2817 }
2818}
2819#[repr(C)]
2820#[cfg_attr(feature = "debug", derive(Debug))]
2821#[derive(Copy, Clone, Default)]
2822#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSubresource.html>"]
2823pub struct ImageSubresource {
2824 pub aspect_mask: ImageAspectFlags,
2825 pub mip_level: u32,
2826 pub array_layer: u32,
2827}
2828impl ImageSubresource {
2829 pub fn builder<'a>() -> ImageSubresourceBuilder<'a> {
2830 ImageSubresourceBuilder {
2831 inner: Self::default(),
2832 marker: ::std::marker::PhantomData,
2833 }
2834 }
2835}
2836#[repr(transparent)]
2837pub struct ImageSubresourceBuilder<'a> {
2838 inner: ImageSubresource,
2839 marker: ::std::marker::PhantomData<&'a ()>,
2840}
2841impl<'a> ::std::ops::Deref for ImageSubresourceBuilder<'a> {
2842 type Target = ImageSubresource;
2843 fn deref(&self) -> &Self::Target {
2844 &self.inner
2845 }
2846}
2847impl<'a> ::std::ops::DerefMut for ImageSubresourceBuilder<'a> {
2848 fn deref_mut(&mut self) -> &mut Self::Target {
2849 &mut self.inner
2850 }
2851}
2852impl<'a> ImageSubresourceBuilder<'a> {
2853 pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self {
2854 self.inner.aspect_mask = aspect_mask;
2855 self
2856 }
2857 pub fn mip_level(mut self, mip_level: u32) -> Self {
2858 self.inner.mip_level = mip_level;
2859 self
2860 }
2861 pub fn array_layer(mut self, array_layer: u32) -> Self {
2862 self.inner.array_layer = array_layer;
2863 self
2864 }
2865 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2866 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2867 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2868 pub fn build(self) -> ImageSubresource {
2869 self.inner
2870 }
2871}
2872#[repr(C)]
2873#[cfg_attr(feature = "debug", derive(Debug))]
2874#[derive(Copy, Clone, Default)]
2875#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSubresourceLayers.html>"]
2876pub struct ImageSubresourceLayers {
2877 pub aspect_mask: ImageAspectFlags,
2878 pub mip_level: u32,
2879 pub base_array_layer: u32,
2880 pub layer_count: u32,
2881}
2882impl ImageSubresourceLayers {
2883 pub fn builder<'a>() -> ImageSubresourceLayersBuilder<'a> {
2884 ImageSubresourceLayersBuilder {
2885 inner: Self::default(),
2886 marker: ::std::marker::PhantomData,
2887 }
2888 }
2889}
2890#[repr(transparent)]
2891pub struct ImageSubresourceLayersBuilder<'a> {
2892 inner: ImageSubresourceLayers,
2893 marker: ::std::marker::PhantomData<&'a ()>,
2894}
2895impl<'a> ::std::ops::Deref for ImageSubresourceLayersBuilder<'a> {
2896 type Target = ImageSubresourceLayers;
2897 fn deref(&self) -> &Self::Target {
2898 &self.inner
2899 }
2900}
2901impl<'a> ::std::ops::DerefMut for ImageSubresourceLayersBuilder<'a> {
2902 fn deref_mut(&mut self) -> &mut Self::Target {
2903 &mut self.inner
2904 }
2905}
2906impl<'a> ImageSubresourceLayersBuilder<'a> {
2907 pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self {
2908 self.inner.aspect_mask = aspect_mask;
2909 self
2910 }
2911 pub fn mip_level(mut self, mip_level: u32) -> Self {
2912 self.inner.mip_level = mip_level;
2913 self
2914 }
2915 pub fn base_array_layer(mut self, base_array_layer: u32) -> Self {
2916 self.inner.base_array_layer = base_array_layer;
2917 self
2918 }
2919 pub fn layer_count(mut self, layer_count: u32) -> Self {
2920 self.inner.layer_count = layer_count;
2921 self
2922 }
2923 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2924 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2925 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2926 pub fn build(self) -> ImageSubresourceLayers {
2927 self.inner
2928 }
2929}
2930#[repr(C)]
2931#[cfg_attr(feature = "debug", derive(Debug))]
2932#[derive(Copy, Clone, Default)]
2933#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSubresourceRange.html>"]
2934pub struct ImageSubresourceRange {
2935 pub aspect_mask: ImageAspectFlags,
2936 pub base_mip_level: u32,
2937 pub level_count: u32,
2938 pub base_array_layer: u32,
2939 pub layer_count: u32,
2940}
2941impl ImageSubresourceRange {
2942 pub fn builder<'a>() -> ImageSubresourceRangeBuilder<'a> {
2943 ImageSubresourceRangeBuilder {
2944 inner: Self::default(),
2945 marker: ::std::marker::PhantomData,
2946 }
2947 }
2948}
2949#[repr(transparent)]
2950pub struct ImageSubresourceRangeBuilder<'a> {
2951 inner: ImageSubresourceRange,
2952 marker: ::std::marker::PhantomData<&'a ()>,
2953}
2954impl<'a> ::std::ops::Deref for ImageSubresourceRangeBuilder<'a> {
2955 type Target = ImageSubresourceRange;
2956 fn deref(&self) -> &Self::Target {
2957 &self.inner
2958 }
2959}
2960impl<'a> ::std::ops::DerefMut for ImageSubresourceRangeBuilder<'a> {
2961 fn deref_mut(&mut self) -> &mut Self::Target {
2962 &mut self.inner
2963 }
2964}
2965impl<'a> ImageSubresourceRangeBuilder<'a> {
2966 pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self {
2967 self.inner.aspect_mask = aspect_mask;
2968 self
2969 }
2970 pub fn base_mip_level(mut self, base_mip_level: u32) -> Self {
2971 self.inner.base_mip_level = base_mip_level;
2972 self
2973 }
2974 pub fn level_count(mut self, level_count: u32) -> Self {
2975 self.inner.level_count = level_count;
2976 self
2977 }
2978 pub fn base_array_layer(mut self, base_array_layer: u32) -> Self {
2979 self.inner.base_array_layer = base_array_layer;
2980 self
2981 }
2982 pub fn layer_count(mut self, layer_count: u32) -> Self {
2983 self.inner.layer_count = layer_count;
2984 self
2985 }
2986 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2987 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2988 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2989 pub fn build(self) -> ImageSubresourceRange {
2990 self.inner
2991 }
2992}
2993#[repr(C)]
2994#[cfg_attr(feature = "debug", derive(Debug))]
2995#[derive(Copy, Clone)]
2996#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryBarrier.html>"]
2997pub struct MemoryBarrier {
2998 pub s_type: StructureType,
2999 pub p_next: *const c_void,
3000 pub src_access_mask: AccessFlags,
3001 pub dst_access_mask: AccessFlags,
3002}
3003impl ::std::default::Default for MemoryBarrier {
3004 fn default() -> Self {
3005 Self {
3006 s_type: StructureType::MEMORY_BARRIER,
3007 p_next: ::std::ptr::null(),
3008 src_access_mask: AccessFlags::default(),
3009 dst_access_mask: AccessFlags::default(),
3010 }
3011 }
3012}
3013impl MemoryBarrier {
3014 pub fn builder<'a>() -> MemoryBarrierBuilder<'a> {
3015 MemoryBarrierBuilder {
3016 inner: Self::default(),
3017 marker: ::std::marker::PhantomData,
3018 }
3019 }
3020}
3021#[repr(transparent)]
3022pub struct MemoryBarrierBuilder<'a> {
3023 inner: MemoryBarrier,
3024 marker: ::std::marker::PhantomData<&'a ()>,
3025}
3026impl<'a> ::std::ops::Deref for MemoryBarrierBuilder<'a> {
3027 type Target = MemoryBarrier;
3028 fn deref(&self) -> &Self::Target {
3029 &self.inner
3030 }
3031}
3032impl<'a> ::std::ops::DerefMut for MemoryBarrierBuilder<'a> {
3033 fn deref_mut(&mut self) -> &mut Self::Target {
3034 &mut self.inner
3035 }
3036}
3037impl<'a> MemoryBarrierBuilder<'a> {
3038 pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self {
3039 self.inner.src_access_mask = src_access_mask;
3040 self
3041 }
3042 pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self {
3043 self.inner.dst_access_mask = dst_access_mask;
3044 self
3045 }
3046 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3047 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3048 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
3049 pub fn build(self) -> MemoryBarrier {
3050 self.inner
3051 }
3052}
3053#[repr(C)]
3054#[cfg_attr(feature = "debug", derive(Debug))]
3055#[derive(Copy, Clone)]
3056#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferMemoryBarrier.html>"]
3057pub struct BufferMemoryBarrier {
3058 pub s_type: StructureType,
3059 pub p_next: *const c_void,
3060 pub src_access_mask: AccessFlags,
3061 pub dst_access_mask: AccessFlags,
3062 pub src_queue_family_index: u32,
3063 pub dst_queue_family_index: u32,
3064 pub buffer: Buffer,
3065 pub offset: DeviceSize,
3066 pub size: DeviceSize,
3067}
3068impl ::std::default::Default for BufferMemoryBarrier {
3069 fn default() -> Self {
3070 Self {
3071 s_type: StructureType::BUFFER_MEMORY_BARRIER,
3072 p_next: ::std::ptr::null(),
3073 src_access_mask: AccessFlags::default(),
3074 dst_access_mask: AccessFlags::default(),
3075 src_queue_family_index: u32::default(),
3076 dst_queue_family_index: u32::default(),
3077 buffer: Buffer::default(),
3078 offset: DeviceSize::default(),
3079 size: DeviceSize::default(),
3080 }
3081 }
3082}
3083impl BufferMemoryBarrier {
3084 pub fn builder<'a>() -> BufferMemoryBarrierBuilder<'a> {
3085 BufferMemoryBarrierBuilder {
3086 inner: Self::default(),
3087 marker: ::std::marker::PhantomData,
3088 }
3089 }
3090}
3091#[repr(transparent)]
3092pub struct BufferMemoryBarrierBuilder<'a> {
3093 inner: BufferMemoryBarrier,
3094 marker: ::std::marker::PhantomData<&'a ()>,
3095}
3096impl<'a> ::std::ops::Deref for BufferMemoryBarrierBuilder<'a> {
3097 type Target = BufferMemoryBarrier;
3098 fn deref(&self) -> &Self::Target {
3099 &self.inner
3100 }
3101}
3102impl<'a> ::std::ops::DerefMut for BufferMemoryBarrierBuilder<'a> {
3103 fn deref_mut(&mut self) -> &mut Self::Target {
3104 &mut self.inner
3105 }
3106}
3107impl<'a> BufferMemoryBarrierBuilder<'a> {
3108 pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self {
3109 self.inner.src_access_mask = src_access_mask;
3110 self
3111 }
3112 pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self {
3113 self.inner.dst_access_mask = dst_access_mask;
3114 self
3115 }
3116 pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self {
3117 self.inner.src_queue_family_index = src_queue_family_index;
3118 self
3119 }
3120 pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self {
3121 self.inner.dst_queue_family_index = dst_queue_family_index;
3122 self
3123 }
3124 pub fn buffer(mut self, buffer: Buffer) -> Self {
3125 self.inner.buffer = buffer;
3126 self
3127 }
3128 pub fn offset(mut self, offset: DeviceSize) -> Self {
3129 self.inner.offset = offset;
3130 self
3131 }
3132 pub fn size(mut self, size: DeviceSize) -> Self {
3133 self.inner.size = size;
3134 self
3135 }
3136 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3137 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3138 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
3139 pub fn build(self) -> BufferMemoryBarrier {
3140 self.inner
3141 }
3142}
3143#[repr(C)]
3144#[cfg_attr(feature = "debug", derive(Debug))]
3145#[derive(Copy, Clone)]
3146#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageMemoryBarrier.html>"]
3147pub struct ImageMemoryBarrier {
3148 pub s_type: StructureType,
3149 pub p_next: *const c_void,
3150 pub src_access_mask: AccessFlags,
3151 pub dst_access_mask: AccessFlags,
3152 pub old_layout: ImageLayout,
3153 pub new_layout: ImageLayout,
3154 pub src_queue_family_index: u32,
3155 pub dst_queue_family_index: u32,
3156 pub image: Image,
3157 pub subresource_range: ImageSubresourceRange,
3158}
3159impl ::std::default::Default for ImageMemoryBarrier {
3160 fn default() -> Self {
3161 Self {
3162 s_type: StructureType::IMAGE_MEMORY_BARRIER,
3163 p_next: ::std::ptr::null(),
3164 src_access_mask: AccessFlags::default(),
3165 dst_access_mask: AccessFlags::default(),
3166 old_layout: ImageLayout::default(),
3167 new_layout: ImageLayout::default(),
3168 src_queue_family_index: u32::default(),
3169 dst_queue_family_index: u32::default(),
3170 image: Image::default(),
3171 subresource_range: ImageSubresourceRange::default(),
3172 }
3173 }
3174}
3175impl ImageMemoryBarrier {
3176 pub fn builder<'a>() -> ImageMemoryBarrierBuilder<'a> {
3177 ImageMemoryBarrierBuilder {
3178 inner: Self::default(),
3179 marker: ::std::marker::PhantomData,
3180 }
3181 }
3182}
3183#[repr(transparent)]
3184pub struct ImageMemoryBarrierBuilder<'a> {
3185 inner: ImageMemoryBarrier,
3186 marker: ::std::marker::PhantomData<&'a ()>,
3187}
3188pub unsafe trait ExtendsImageMemoryBarrier {}
3189impl<'a> ::std::ops::Deref for ImageMemoryBarrierBuilder<'a> {
3190 type Target = ImageMemoryBarrier;
3191 fn deref(&self) -> &Self::Target {
3192 &self.inner
3193 }
3194}
3195impl<'a> ::std::ops::DerefMut for ImageMemoryBarrierBuilder<'a> {
3196 fn deref_mut(&mut self) -> &mut Self::Target {
3197 &mut self.inner
3198 }
3199}
3200impl<'a> ImageMemoryBarrierBuilder<'a> {
3201 pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self {
3202 self.inner.src_access_mask = src_access_mask;
3203 self
3204 }
3205 pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self {
3206 self.inner.dst_access_mask = dst_access_mask;
3207 self
3208 }
3209 pub fn old_layout(mut self, old_layout: ImageLayout) -> Self {
3210 self.inner.old_layout = old_layout;
3211 self
3212 }
3213 pub fn new_layout(mut self, new_layout: ImageLayout) -> Self {
3214 self.inner.new_layout = new_layout;
3215 self
3216 }
3217 pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self {
3218 self.inner.src_queue_family_index = src_queue_family_index;
3219 self
3220 }
3221 pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self {
3222 self.inner.dst_queue_family_index = dst_queue_family_index;
3223 self
3224 }
3225 pub fn image(mut self, image: Image) -> Self {
3226 self.inner.image = image;
3227 self
3228 }
3229 pub fn subresource_range(mut self, subresource_range: ImageSubresourceRange) -> Self {
3230 self.inner.subresource_range = subresource_range;
3231 self
3232 }
3233 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
3234 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
3235 #[doc = r" valid extension structs can be pushed into the chain."]
3236 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
3237 #[doc = r" chain will look like `A -> D -> B -> C`."]
3238 pub fn push_next<T: ExtendsImageMemoryBarrier>(mut self, next: &'a mut T) -> Self {
3239 unsafe {
3240 let next_ptr = <*const T>::cast(next);
3241 let last_next = ptr_chain_iter(next).last().unwrap();
3242 (*last_next).p_next = self.inner.p_next as _;
3243 self.inner.p_next = next_ptr;
3244 }
3245 self
3246 }
3247 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3248 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3249 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
3250 pub fn build(self) -> ImageMemoryBarrier {
3251 self.inner
3252 }
3253}
3254#[repr(C)]
3255#[cfg_attr(feature = "debug", derive(Debug))]
3256#[derive(Copy, Clone)]
3257#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCreateInfo.html>"]
3258pub struct ImageCreateInfo {
3259 pub s_type: StructureType,
3260 pub p_next: *const c_void,
3261 pub flags: ImageCreateFlags,
3262 pub image_type: ImageType,
3263 pub format: Format,
3264 pub extent: Extent3D,
3265 pub mip_levels: u32,
3266 pub array_layers: u32,
3267 pub samples: SampleCountFlags,
3268 pub tiling: ImageTiling,
3269 pub usage: ImageUsageFlags,
3270 pub sharing_mode: SharingMode,
3271 pub queue_family_index_count: u32,
3272 pub p_queue_family_indices: *const u32,
3273 pub initial_layout: ImageLayout,
3274}
3275impl ::std::default::Default for ImageCreateInfo {
3276 fn default() -> Self {
3277 Self {
3278 s_type: StructureType::IMAGE_CREATE_INFO,
3279 p_next: ::std::ptr::null(),
3280 flags: ImageCreateFlags::default(),
3281 image_type: ImageType::default(),
3282 format: Format::default(),
3283 extent: Extent3D::default(),
3284 mip_levels: u32::default(),
3285 array_layers: u32::default(),
3286 samples: SampleCountFlags::default(),
3287 tiling: ImageTiling::default(),
3288 usage: ImageUsageFlags::default(),
3289 sharing_mode: SharingMode::default(),
3290 queue_family_index_count: u32::default(),
3291 p_queue_family_indices: ::std::ptr::null(),
3292 initial_layout: ImageLayout::default(),
3293 }
3294 }
3295}
3296impl ImageCreateInfo {
3297 pub fn builder<'a>() -> ImageCreateInfoBuilder<'a> {
3298 ImageCreateInfoBuilder {
3299 inner: Self::default(),
3300 marker: ::std::marker::PhantomData,
3301 }
3302 }
3303}
3304#[repr(transparent)]
3305pub struct ImageCreateInfoBuilder<'a> {
3306 inner: ImageCreateInfo,
3307 marker: ::std::marker::PhantomData<&'a ()>,
3308}
3309pub unsafe trait ExtendsImageCreateInfo {}
3310impl<'a> ::std::ops::Deref for ImageCreateInfoBuilder<'a> {
3311 type Target = ImageCreateInfo;
3312 fn deref(&self) -> &Self::Target {
3313 &self.inner
3314 }
3315}
3316impl<'a> ::std::ops::DerefMut for ImageCreateInfoBuilder<'a> {
3317 fn deref_mut(&mut self) -> &mut Self::Target {
3318 &mut self.inner
3319 }
3320}
3321impl<'a> ImageCreateInfoBuilder<'a> {
3322 pub fn flags(mut self, flags: ImageCreateFlags) -> Self {
3323 self.inner.flags = flags;
3324 self
3325 }
3326 pub fn image_type(mut self, image_type: ImageType) -> Self {
3327 self.inner.image_type = image_type;
3328 self
3329 }
3330 pub fn format(mut self, format: Format) -> Self {
3331 self.inner.format = format;
3332 self
3333 }
3334 pub fn extent(mut self, extent: Extent3D) -> Self {
3335 self.inner.extent = extent;
3336 self
3337 }
3338 pub fn mip_levels(mut self, mip_levels: u32) -> Self {
3339 self.inner.mip_levels = mip_levels;
3340 self
3341 }
3342 pub fn array_layers(mut self, array_layers: u32) -> Self {
3343 self.inner.array_layers = array_layers;
3344 self
3345 }
3346 pub fn samples(mut self, samples: SampleCountFlags) -> Self {
3347 self.inner.samples = samples;
3348 self
3349 }
3350 pub fn tiling(mut self, tiling: ImageTiling) -> Self {
3351 self.inner.tiling = tiling;
3352 self
3353 }
3354 pub fn usage(mut self, usage: ImageUsageFlags) -> Self {
3355 self.inner.usage = usage;
3356 self
3357 }
3358 pub fn sharing_mode(mut self, sharing_mode: SharingMode) -> Self {
3359 self.inner.sharing_mode = sharing_mode;
3360 self
3361 }
3362 pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self {
3363 self.inner.queue_family_index_count = queue_family_indices.len() as _;
3364 self.inner.p_queue_family_indices = queue_family_indices.as_ptr();
3365 self
3366 }
3367 pub fn initial_layout(mut self, initial_layout: ImageLayout) -> Self {
3368 self.inner.initial_layout = initial_layout;
3369 self
3370 }
3371 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
3372 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
3373 #[doc = r" valid extension structs can be pushed into the chain."]
3374 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
3375 #[doc = r" chain will look like `A -> D -> B -> C`."]
3376 pub fn push_next<T: ExtendsImageCreateInfo>(mut self, next: &'a mut T) -> Self {
3377 unsafe {
3378 let next_ptr = <*const T>::cast(next);
3379 let last_next = ptr_chain_iter(next).last().unwrap();
3380 (*last_next).p_next = self.inner.p_next as _;
3381 self.inner.p_next = next_ptr;
3382 }
3383 self
3384 }
3385 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3386 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3387 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
3388 pub fn build(self) -> ImageCreateInfo {
3389 self.inner
3390 }
3391}
3392#[repr(C)]
3393#[cfg_attr(feature = "debug", derive(Debug))]
3394#[derive(Copy, Clone, Default)]
3395#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubresourceLayout.html>"]
3396pub struct SubresourceLayout {
3397 pub offset: DeviceSize,
3398 pub size: DeviceSize,
3399 pub row_pitch: DeviceSize,
3400 pub array_pitch: DeviceSize,
3401 pub depth_pitch: DeviceSize,
3402}
3403impl SubresourceLayout {
3404 pub fn builder<'a>() -> SubresourceLayoutBuilder<'a> {
3405 SubresourceLayoutBuilder {
3406 inner: Self::default(),
3407 marker: ::std::marker::PhantomData,
3408 }
3409 }
3410}
3411#[repr(transparent)]
3412pub struct SubresourceLayoutBuilder<'a> {
3413 inner: SubresourceLayout,
3414 marker: ::std::marker::PhantomData<&'a ()>,
3415}
3416impl<'a> ::std::ops::Deref for SubresourceLayoutBuilder<'a> {
3417 type Target = SubresourceLayout;
3418 fn deref(&self) -> &Self::Target {
3419 &self.inner
3420 }
3421}
3422impl<'a> ::std::ops::DerefMut for SubresourceLayoutBuilder<'a> {
3423 fn deref_mut(&mut self) -> &mut Self::Target {
3424 &mut self.inner
3425 }
3426}
3427impl<'a> SubresourceLayoutBuilder<'a> {
3428 pub fn offset(mut self, offset: DeviceSize) -> Self {
3429 self.inner.offset = offset;
3430 self
3431 }
3432 pub fn size(mut self, size: DeviceSize) -> Self {
3433 self.inner.size = size;
3434 self
3435 }
3436 pub fn row_pitch(mut self, row_pitch: DeviceSize) -> Self {
3437 self.inner.row_pitch = row_pitch;
3438 self
3439 }
3440 pub fn array_pitch(mut self, array_pitch: DeviceSize) -> Self {
3441 self.inner.array_pitch = array_pitch;
3442 self
3443 }
3444 pub fn depth_pitch(mut self, depth_pitch: DeviceSize) -> Self {
3445 self.inner.depth_pitch = depth_pitch;
3446 self
3447 }
3448 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3449 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3450 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
3451 pub fn build(self) -> SubresourceLayout {
3452 self.inner
3453 }
3454}
3455#[repr(C)]
3456#[cfg_attr(feature = "debug", derive(Debug))]
3457#[derive(Copy, Clone)]
3458#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewCreateInfo.html>"]
3459pub struct ImageViewCreateInfo {
3460 pub s_type: StructureType,
3461 pub p_next: *const c_void,
3462 pub flags: ImageViewCreateFlags,
3463 pub image: Image,
3464 pub view_type: ImageViewType,
3465 pub format: Format,
3466 pub components: ComponentMapping,
3467 pub subresource_range: ImageSubresourceRange,
3468}
3469impl ::std::default::Default for ImageViewCreateInfo {
3470 fn default() -> Self {
3471 Self {
3472 s_type: StructureType::IMAGE_VIEW_CREATE_INFO,
3473 p_next: ::std::ptr::null(),
3474 flags: ImageViewCreateFlags::default(),
3475 image: Image::default(),
3476 view_type: ImageViewType::default(),
3477 format: Format::default(),
3478 components: ComponentMapping::default(),
3479 subresource_range: ImageSubresourceRange::default(),
3480 }
3481 }
3482}
3483impl ImageViewCreateInfo {
3484 pub fn builder<'a>() -> ImageViewCreateInfoBuilder<'a> {
3485 ImageViewCreateInfoBuilder {
3486 inner: Self::default(),
3487 marker: ::std::marker::PhantomData,
3488 }
3489 }
3490}
3491#[repr(transparent)]
3492pub struct ImageViewCreateInfoBuilder<'a> {
3493 inner: ImageViewCreateInfo,
3494 marker: ::std::marker::PhantomData<&'a ()>,
3495}
3496pub unsafe trait ExtendsImageViewCreateInfo {}
3497impl<'a> ::std::ops::Deref for ImageViewCreateInfoBuilder<'a> {
3498 type Target = ImageViewCreateInfo;
3499 fn deref(&self) -> &Self::Target {
3500 &self.inner
3501 }
3502}
3503impl<'a> ::std::ops::DerefMut for ImageViewCreateInfoBuilder<'a> {
3504 fn deref_mut(&mut self) -> &mut Self::Target {
3505 &mut self.inner
3506 }
3507}
3508impl<'a> ImageViewCreateInfoBuilder<'a> {
3509 pub fn flags(mut self, flags: ImageViewCreateFlags) -> Self {
3510 self.inner.flags = flags;
3511 self
3512 }
3513 pub fn image(mut self, image: Image) -> Self {
3514 self.inner.image = image;
3515 self
3516 }
3517 pub fn view_type(mut self, view_type: ImageViewType) -> Self {
3518 self.inner.view_type = view_type;
3519 self
3520 }
3521 pub fn format(mut self, format: Format) -> Self {
3522 self.inner.format = format;
3523 self
3524 }
3525 pub fn components(mut self, components: ComponentMapping) -> Self {
3526 self.inner.components = components;
3527 self
3528 }
3529 pub fn subresource_range(mut self, subresource_range: ImageSubresourceRange) -> Self {
3530 self.inner.subresource_range = subresource_range;
3531 self
3532 }
3533 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
3534 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
3535 #[doc = r" valid extension structs can be pushed into the chain."]
3536 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
3537 #[doc = r" chain will look like `A -> D -> B -> C`."]
3538 pub fn push_next<T: ExtendsImageViewCreateInfo>(mut self, next: &'a mut T) -> Self {
3539 unsafe {
3540 let next_ptr = <*const T>::cast(next);
3541 let last_next = ptr_chain_iter(next).last().unwrap();
3542 (*last_next).p_next = self.inner.p_next as _;
3543 self.inner.p_next = next_ptr;
3544 }
3545 self
3546 }
3547 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3548 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3549 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
3550 pub fn build(self) -> ImageViewCreateInfo {
3551 self.inner
3552 }
3553}
3554#[repr(C)]
3555#[cfg_attr(feature = "debug", derive(Debug))]
3556#[derive(Copy, Clone, Default)]
3557#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCopy.html>"]
3558pub struct BufferCopy {
3559 pub src_offset: DeviceSize,
3560 pub dst_offset: DeviceSize,
3561 pub size: DeviceSize,
3562}
3563impl BufferCopy {
3564 pub fn builder<'a>() -> BufferCopyBuilder<'a> {
3565 BufferCopyBuilder {
3566 inner: Self::default(),
3567 marker: ::std::marker::PhantomData,
3568 }
3569 }
3570}
3571#[repr(transparent)]
3572pub struct BufferCopyBuilder<'a> {
3573 inner: BufferCopy,
3574 marker: ::std::marker::PhantomData<&'a ()>,
3575}
3576impl<'a> ::std::ops::Deref for BufferCopyBuilder<'a> {
3577 type Target = BufferCopy;
3578 fn deref(&self) -> &Self::Target {
3579 &self.inner
3580 }
3581}
3582impl<'a> ::std::ops::DerefMut for BufferCopyBuilder<'a> {
3583 fn deref_mut(&mut self) -> &mut Self::Target {
3584 &mut self.inner
3585 }
3586}
3587impl<'a> BufferCopyBuilder<'a> {
3588 pub fn src_offset(mut self, src_offset: DeviceSize) -> Self {
3589 self.inner.src_offset = src_offset;
3590 self
3591 }
3592 pub fn dst_offset(mut self, dst_offset: DeviceSize) -> Self {
3593 self.inner.dst_offset = dst_offset;
3594 self
3595 }
3596 pub fn size(mut self, size: DeviceSize) -> Self {
3597 self.inner.size = size;
3598 self
3599 }
3600 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3601 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3602 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
3603 pub fn build(self) -> BufferCopy {
3604 self.inner
3605 }
3606}
3607#[repr(C)]
3608#[cfg_attr(feature = "debug", derive(Debug))]
3609#[derive(Copy, Clone, Default)]
3610#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseMemoryBind.html>"]
3611pub struct SparseMemoryBind {
3612 pub resource_offset: DeviceSize,
3613 pub size: DeviceSize,
3614 pub memory: DeviceMemory,
3615 pub memory_offset: DeviceSize,
3616 pub flags: SparseMemoryBindFlags,
3617}
3618impl SparseMemoryBind {
3619 pub fn builder<'a>() -> SparseMemoryBindBuilder<'a> {
3620 SparseMemoryBindBuilder {
3621 inner: Self::default(),
3622 marker: ::std::marker::PhantomData,
3623 }
3624 }
3625}
3626#[repr(transparent)]
3627pub struct SparseMemoryBindBuilder<'a> {
3628 inner: SparseMemoryBind,
3629 marker: ::std::marker::PhantomData<&'a ()>,
3630}
3631impl<'a> ::std::ops::Deref for SparseMemoryBindBuilder<'a> {
3632 type Target = SparseMemoryBind;
3633 fn deref(&self) -> &Self::Target {
3634 &self.inner
3635 }
3636}
3637impl<'a> ::std::ops::DerefMut for SparseMemoryBindBuilder<'a> {
3638 fn deref_mut(&mut self) -> &mut Self::Target {
3639 &mut self.inner
3640 }
3641}
3642impl<'a> SparseMemoryBindBuilder<'a> {
3643 pub fn resource_offset(mut self, resource_offset: DeviceSize) -> Self {
3644 self.inner.resource_offset = resource_offset;
3645 self
3646 }
3647 pub fn size(mut self, size: DeviceSize) -> Self {
3648 self.inner.size = size;
3649 self
3650 }
3651 pub fn memory(mut self, memory: DeviceMemory) -> Self {
3652 self.inner.memory = memory;
3653 self
3654 }
3655 pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self {
3656 self.inner.memory_offset = memory_offset;
3657 self
3658 }
3659 pub fn flags(mut self, flags: SparseMemoryBindFlags) -> Self {
3660 self.inner.flags = flags;
3661 self
3662 }
3663 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3664 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3665 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
3666 pub fn build(self) -> SparseMemoryBind {
3667 self.inner
3668 }
3669}
3670#[repr(C)]
3671#[cfg_attr(feature = "debug", derive(Debug))]
3672#[derive(Copy, Clone, Default)]
3673#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageMemoryBind.html>"]
3674pub struct SparseImageMemoryBind {
3675 pub subresource: ImageSubresource,
3676 pub offset: Offset3D,
3677 pub extent: Extent3D,
3678 pub memory: DeviceMemory,
3679 pub memory_offset: DeviceSize,
3680 pub flags: SparseMemoryBindFlags,
3681}
3682impl SparseImageMemoryBind {
3683 pub fn builder<'a>() -> SparseImageMemoryBindBuilder<'a> {
3684 SparseImageMemoryBindBuilder {
3685 inner: Self::default(),
3686 marker: ::std::marker::PhantomData,
3687 }
3688 }
3689}
3690#[repr(transparent)]
3691pub struct SparseImageMemoryBindBuilder<'a> {
3692 inner: SparseImageMemoryBind,
3693 marker: ::std::marker::PhantomData<&'a ()>,
3694}
3695impl<'a> ::std::ops::Deref for SparseImageMemoryBindBuilder<'a> {
3696 type Target = SparseImageMemoryBind;
3697 fn deref(&self) -> &Self::Target {
3698 &self.inner
3699 }
3700}
3701impl<'a> ::std::ops::DerefMut for SparseImageMemoryBindBuilder<'a> {
3702 fn deref_mut(&mut self) -> &mut Self::Target {
3703 &mut self.inner
3704 }
3705}
3706impl<'a> SparseImageMemoryBindBuilder<'a> {
3707 pub fn subresource(mut self, subresource: ImageSubresource) -> Self {
3708 self.inner.subresource = subresource;
3709 self
3710 }
3711 pub fn offset(mut self, offset: Offset3D) -> Self {
3712 self.inner.offset = offset;
3713 self
3714 }
3715 pub fn extent(mut self, extent: Extent3D) -> Self {
3716 self.inner.extent = extent;
3717 self
3718 }
3719 pub fn memory(mut self, memory: DeviceMemory) -> Self {
3720 self.inner.memory = memory;
3721 self
3722 }
3723 pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self {
3724 self.inner.memory_offset = memory_offset;
3725 self
3726 }
3727 pub fn flags(mut self, flags: SparseMemoryBindFlags) -> Self {
3728 self.inner.flags = flags;
3729 self
3730 }
3731 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3732 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3733 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
3734 pub fn build(self) -> SparseImageMemoryBind {
3735 self.inner
3736 }
3737}
3738#[repr(C)]
3739#[cfg_attr(feature = "debug", derive(Debug))]
3740#[derive(Copy, Clone)]
3741#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseBufferMemoryBindInfo.html>"]
3742pub struct SparseBufferMemoryBindInfo {
3743 pub buffer: Buffer,
3744 pub bind_count: u32,
3745 pub p_binds: *const SparseMemoryBind,
3746}
3747impl ::std::default::Default for SparseBufferMemoryBindInfo {
3748 fn default() -> Self {
3749 Self {
3750 buffer: Buffer::default(),
3751 bind_count: u32::default(),
3752 p_binds: ::std::ptr::null(),
3753 }
3754 }
3755}
3756impl SparseBufferMemoryBindInfo {
3757 pub fn builder<'a>() -> SparseBufferMemoryBindInfoBuilder<'a> {
3758 SparseBufferMemoryBindInfoBuilder {
3759 inner: Self::default(),
3760 marker: ::std::marker::PhantomData,
3761 }
3762 }
3763}
3764#[repr(transparent)]
3765pub struct SparseBufferMemoryBindInfoBuilder<'a> {
3766 inner: SparseBufferMemoryBindInfo,
3767 marker: ::std::marker::PhantomData<&'a ()>,
3768}
3769impl<'a> ::std::ops::Deref for SparseBufferMemoryBindInfoBuilder<'a> {
3770 type Target = SparseBufferMemoryBindInfo;
3771 fn deref(&self) -> &Self::Target {
3772 &self.inner
3773 }
3774}
3775impl<'a> ::std::ops::DerefMut for SparseBufferMemoryBindInfoBuilder<'a> {
3776 fn deref_mut(&mut self) -> &mut Self::Target {
3777 &mut self.inner
3778 }
3779}
3780impl<'a> SparseBufferMemoryBindInfoBuilder<'a> {
3781 pub fn buffer(mut self, buffer: Buffer) -> Self {
3782 self.inner.buffer = buffer;
3783 self
3784 }
3785 pub fn binds(mut self, binds: &'a [SparseMemoryBind]) -> Self {
3786 self.inner.bind_count = binds.len() as _;
3787 self.inner.p_binds = binds.as_ptr();
3788 self
3789 }
3790 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3791 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3792 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
3793 pub fn build(self) -> SparseBufferMemoryBindInfo {
3794 self.inner
3795 }
3796}
3797#[repr(C)]
3798#[cfg_attr(feature = "debug", derive(Debug))]
3799#[derive(Copy, Clone)]
3800#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageOpaqueMemoryBindInfo.html>"]
3801pub struct SparseImageOpaqueMemoryBindInfo {
3802 pub image: Image,
3803 pub bind_count: u32,
3804 pub p_binds: *const SparseMemoryBind,
3805}
3806impl ::std::default::Default for SparseImageOpaqueMemoryBindInfo {
3807 fn default() -> Self {
3808 Self {
3809 image: Image::default(),
3810 bind_count: u32::default(),
3811 p_binds: ::std::ptr::null(),
3812 }
3813 }
3814}
3815impl SparseImageOpaqueMemoryBindInfo {
3816 pub fn builder<'a>() -> SparseImageOpaqueMemoryBindInfoBuilder<'a> {
3817 SparseImageOpaqueMemoryBindInfoBuilder {
3818 inner: Self::default(),
3819 marker: ::std::marker::PhantomData,
3820 }
3821 }
3822}
3823#[repr(transparent)]
3824pub struct SparseImageOpaqueMemoryBindInfoBuilder<'a> {
3825 inner: SparseImageOpaqueMemoryBindInfo,
3826 marker: ::std::marker::PhantomData<&'a ()>,
3827}
3828impl<'a> ::std::ops::Deref for SparseImageOpaqueMemoryBindInfoBuilder<'a> {
3829 type Target = SparseImageOpaqueMemoryBindInfo;
3830 fn deref(&self) -> &Self::Target {
3831 &self.inner
3832 }
3833}
3834impl<'a> ::std::ops::DerefMut for SparseImageOpaqueMemoryBindInfoBuilder<'a> {
3835 fn deref_mut(&mut self) -> &mut Self::Target {
3836 &mut self.inner
3837 }
3838}
3839impl<'a> SparseImageOpaqueMemoryBindInfoBuilder<'a> {
3840 pub fn image(mut self, image: Image) -> Self {
3841 self.inner.image = image;
3842 self
3843 }
3844 pub fn binds(mut self, binds: &'a [SparseMemoryBind]) -> Self {
3845 self.inner.bind_count = binds.len() as _;
3846 self.inner.p_binds = binds.as_ptr();
3847 self
3848 }
3849 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3850 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3851 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
3852 pub fn build(self) -> SparseImageOpaqueMemoryBindInfo {
3853 self.inner
3854 }
3855}
3856#[repr(C)]
3857#[cfg_attr(feature = "debug", derive(Debug))]
3858#[derive(Copy, Clone)]
3859#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageMemoryBindInfo.html>"]
3860pub struct SparseImageMemoryBindInfo {
3861 pub image: Image,
3862 pub bind_count: u32,
3863 pub p_binds: *const SparseImageMemoryBind,
3864}
3865impl ::std::default::Default for SparseImageMemoryBindInfo {
3866 fn default() -> Self {
3867 Self {
3868 image: Image::default(),
3869 bind_count: u32::default(),
3870 p_binds: ::std::ptr::null(),
3871 }
3872 }
3873}
3874impl SparseImageMemoryBindInfo {
3875 pub fn builder<'a>() -> SparseImageMemoryBindInfoBuilder<'a> {
3876 SparseImageMemoryBindInfoBuilder {
3877 inner: Self::default(),
3878 marker: ::std::marker::PhantomData,
3879 }
3880 }
3881}
3882#[repr(transparent)]
3883pub struct SparseImageMemoryBindInfoBuilder<'a> {
3884 inner: SparseImageMemoryBindInfo,
3885 marker: ::std::marker::PhantomData<&'a ()>,
3886}
3887impl<'a> ::std::ops::Deref for SparseImageMemoryBindInfoBuilder<'a> {
3888 type Target = SparseImageMemoryBindInfo;
3889 fn deref(&self) -> &Self::Target {
3890 &self.inner
3891 }
3892}
3893impl<'a> ::std::ops::DerefMut for SparseImageMemoryBindInfoBuilder<'a> {
3894 fn deref_mut(&mut self) -> &mut Self::Target {
3895 &mut self.inner
3896 }
3897}
3898impl<'a> SparseImageMemoryBindInfoBuilder<'a> {
3899 pub fn image(mut self, image: Image) -> Self {
3900 self.inner.image = image;
3901 self
3902 }
3903 pub fn binds(mut self, binds: &'a [SparseImageMemoryBind]) -> Self {
3904 self.inner.bind_count = binds.len() as _;
3905 self.inner.p_binds = binds.as_ptr();
3906 self
3907 }
3908 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3909 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3910 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
3911 pub fn build(self) -> SparseImageMemoryBindInfo {
3912 self.inner
3913 }
3914}
3915#[repr(C)]
3916#[cfg_attr(feature = "debug", derive(Debug))]
3917#[derive(Copy, Clone)]
3918#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindSparseInfo.html>"]
3919pub struct BindSparseInfo {
3920 pub s_type: StructureType,
3921 pub p_next: *const c_void,
3922 pub wait_semaphore_count: u32,
3923 pub p_wait_semaphores: *const Semaphore,
3924 pub buffer_bind_count: u32,
3925 pub p_buffer_binds: *const SparseBufferMemoryBindInfo,
3926 pub image_opaque_bind_count: u32,
3927 pub p_image_opaque_binds: *const SparseImageOpaqueMemoryBindInfo,
3928 pub image_bind_count: u32,
3929 pub p_image_binds: *const SparseImageMemoryBindInfo,
3930 pub signal_semaphore_count: u32,
3931 pub p_signal_semaphores: *const Semaphore,
3932}
3933impl ::std::default::Default for BindSparseInfo {
3934 fn default() -> Self {
3935 Self {
3936 s_type: StructureType::BIND_SPARSE_INFO,
3937 p_next: ::std::ptr::null(),
3938 wait_semaphore_count: u32::default(),
3939 p_wait_semaphores: ::std::ptr::null(),
3940 buffer_bind_count: u32::default(),
3941 p_buffer_binds: ::std::ptr::null(),
3942 image_opaque_bind_count: u32::default(),
3943 p_image_opaque_binds: ::std::ptr::null(),
3944 image_bind_count: u32::default(),
3945 p_image_binds: ::std::ptr::null(),
3946 signal_semaphore_count: u32::default(),
3947 p_signal_semaphores: ::std::ptr::null(),
3948 }
3949 }
3950}
3951impl BindSparseInfo {
3952 pub fn builder<'a>() -> BindSparseInfoBuilder<'a> {
3953 BindSparseInfoBuilder {
3954 inner: Self::default(),
3955 marker: ::std::marker::PhantomData,
3956 }
3957 }
3958}
3959#[repr(transparent)]
3960pub struct BindSparseInfoBuilder<'a> {
3961 inner: BindSparseInfo,
3962 marker: ::std::marker::PhantomData<&'a ()>,
3963}
3964pub unsafe trait ExtendsBindSparseInfo {}
3965impl<'a> ::std::ops::Deref for BindSparseInfoBuilder<'a> {
3966 type Target = BindSparseInfo;
3967 fn deref(&self) -> &Self::Target {
3968 &self.inner
3969 }
3970}
3971impl<'a> ::std::ops::DerefMut for BindSparseInfoBuilder<'a> {
3972 fn deref_mut(&mut self) -> &mut Self::Target {
3973 &mut self.inner
3974 }
3975}
3976impl<'a> BindSparseInfoBuilder<'a> {
3977 pub fn wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> Self {
3978 self.inner.wait_semaphore_count = wait_semaphores.len() as _;
3979 self.inner.p_wait_semaphores = wait_semaphores.as_ptr();
3980 self
3981 }
3982 pub fn buffer_binds(mut self, buffer_binds: &'a [SparseBufferMemoryBindInfo]) -> Self {
3983 self.inner.buffer_bind_count = buffer_binds.len() as _;
3984 self.inner.p_buffer_binds = buffer_binds.as_ptr();
3985 self
3986 }
3987 pub fn image_opaque_binds(
3988 mut self,
3989 image_opaque_binds: &'a [SparseImageOpaqueMemoryBindInfo],
3990 ) -> Self {
3991 self.inner.image_opaque_bind_count = image_opaque_binds.len() as _;
3992 self.inner.p_image_opaque_binds = image_opaque_binds.as_ptr();
3993 self
3994 }
3995 pub fn image_binds(mut self, image_binds: &'a [SparseImageMemoryBindInfo]) -> Self {
3996 self.inner.image_bind_count = image_binds.len() as _;
3997 self.inner.p_image_binds = image_binds.as_ptr();
3998 self
3999 }
4000 pub fn signal_semaphores(mut self, signal_semaphores: &'a [Semaphore]) -> Self {
4001 self.inner.signal_semaphore_count = signal_semaphores.len() as _;
4002 self.inner.p_signal_semaphores = signal_semaphores.as_ptr();
4003 self
4004 }
4005 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
4006 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
4007 #[doc = r" valid extension structs can be pushed into the chain."]
4008 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
4009 #[doc = r" chain will look like `A -> D -> B -> C`."]
4010 pub fn push_next<T: ExtendsBindSparseInfo>(mut self, next: &'a mut T) -> Self {
4011 unsafe {
4012 let next_ptr = <*const T>::cast(next);
4013 let last_next = ptr_chain_iter(next).last().unwrap();
4014 (*last_next).p_next = self.inner.p_next as _;
4015 self.inner.p_next = next_ptr;
4016 }
4017 self
4018 }
4019 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4020 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4021 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
4022 pub fn build(self) -> BindSparseInfo {
4023 self.inner
4024 }
4025}
4026#[repr(C)]
4027#[cfg_attr(feature = "debug", derive(Debug))]
4028#[derive(Copy, Clone, Default)]
4029#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCopy.html>"]
4030pub struct ImageCopy {
4031 pub src_subresource: ImageSubresourceLayers,
4032 pub src_offset: Offset3D,
4033 pub dst_subresource: ImageSubresourceLayers,
4034 pub dst_offset: Offset3D,
4035 pub extent: Extent3D,
4036}
4037impl ImageCopy {
4038 pub fn builder<'a>() -> ImageCopyBuilder<'a> {
4039 ImageCopyBuilder {
4040 inner: Self::default(),
4041 marker: ::std::marker::PhantomData,
4042 }
4043 }
4044}
4045#[repr(transparent)]
4046pub struct ImageCopyBuilder<'a> {
4047 inner: ImageCopy,
4048 marker: ::std::marker::PhantomData<&'a ()>,
4049}
4050impl<'a> ::std::ops::Deref for ImageCopyBuilder<'a> {
4051 type Target = ImageCopy;
4052 fn deref(&self) -> &Self::Target {
4053 &self.inner
4054 }
4055}
4056impl<'a> ::std::ops::DerefMut for ImageCopyBuilder<'a> {
4057 fn deref_mut(&mut self) -> &mut Self::Target {
4058 &mut self.inner
4059 }
4060}
4061impl<'a> ImageCopyBuilder<'a> {
4062 pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self {
4063 self.inner.src_subresource = src_subresource;
4064 self
4065 }
4066 pub fn src_offset(mut self, src_offset: Offset3D) -> Self {
4067 self.inner.src_offset = src_offset;
4068 self
4069 }
4070 pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self {
4071 self.inner.dst_subresource = dst_subresource;
4072 self
4073 }
4074 pub fn dst_offset(mut self, dst_offset: Offset3D) -> Self {
4075 self.inner.dst_offset = dst_offset;
4076 self
4077 }
4078 pub fn extent(mut self, extent: Extent3D) -> Self {
4079 self.inner.extent = extent;
4080 self
4081 }
4082 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4083 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4084 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
4085 pub fn build(self) -> ImageCopy {
4086 self.inner
4087 }
4088}
4089#[repr(C)]
4090#[cfg_attr(feature = "debug", derive(Debug))]
4091#[derive(Copy, Clone)]
4092#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageBlit.html>"]
4093pub struct ImageBlit {
4094 pub src_subresource: ImageSubresourceLayers,
4095 pub src_offsets: [Offset3D; 2],
4096 pub dst_subresource: ImageSubresourceLayers,
4097 pub dst_offsets: [Offset3D; 2],
4098}
4099impl ::std::default::Default for ImageBlit {
4100 fn default() -> Self {
4101 Self {
4102 src_subresource: ImageSubresourceLayers::default(),
4103 src_offsets: unsafe { ::std::mem::zeroed() },
4104 dst_subresource: ImageSubresourceLayers::default(),
4105 dst_offsets: unsafe { ::std::mem::zeroed() },
4106 }
4107 }
4108}
4109impl ImageBlit {
4110 pub fn builder<'a>() -> ImageBlitBuilder<'a> {
4111 ImageBlitBuilder {
4112 inner: Self::default(),
4113 marker: ::std::marker::PhantomData,
4114 }
4115 }
4116}
4117#[repr(transparent)]
4118pub struct ImageBlitBuilder<'a> {
4119 inner: ImageBlit,
4120 marker: ::std::marker::PhantomData<&'a ()>,
4121}
4122impl<'a> ::std::ops::Deref for ImageBlitBuilder<'a> {
4123 type Target = ImageBlit;
4124 fn deref(&self) -> &Self::Target {
4125 &self.inner
4126 }
4127}
4128impl<'a> ::std::ops::DerefMut for ImageBlitBuilder<'a> {
4129 fn deref_mut(&mut self) -> &mut Self::Target {
4130 &mut self.inner
4131 }
4132}
4133impl<'a> ImageBlitBuilder<'a> {
4134 pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self {
4135 self.inner.src_subresource = src_subresource;
4136 self
4137 }
4138 pub fn src_offsets(mut self, src_offsets: [Offset3D; 2]) -> Self {
4139 self.inner.src_offsets = src_offsets;
4140 self
4141 }
4142 pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self {
4143 self.inner.dst_subresource = dst_subresource;
4144 self
4145 }
4146 pub fn dst_offsets(mut self, dst_offsets: [Offset3D; 2]) -> Self {
4147 self.inner.dst_offsets = dst_offsets;
4148 self
4149 }
4150 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4151 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4152 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
4153 pub fn build(self) -> ImageBlit {
4154 self.inner
4155 }
4156}
4157#[repr(C)]
4158#[cfg_attr(feature = "debug", derive(Debug))]
4159#[derive(Copy, Clone, Default)]
4160#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferImageCopy.html>"]
4161pub struct BufferImageCopy {
4162 pub buffer_offset: DeviceSize,
4163 pub buffer_row_length: u32,
4164 pub buffer_image_height: u32,
4165 pub image_subresource: ImageSubresourceLayers,
4166 pub image_offset: Offset3D,
4167 pub image_extent: Extent3D,
4168}
4169impl BufferImageCopy {
4170 pub fn builder<'a>() -> BufferImageCopyBuilder<'a> {
4171 BufferImageCopyBuilder {
4172 inner: Self::default(),
4173 marker: ::std::marker::PhantomData,
4174 }
4175 }
4176}
4177#[repr(transparent)]
4178pub struct BufferImageCopyBuilder<'a> {
4179 inner: BufferImageCopy,
4180 marker: ::std::marker::PhantomData<&'a ()>,
4181}
4182impl<'a> ::std::ops::Deref for BufferImageCopyBuilder<'a> {
4183 type Target = BufferImageCopy;
4184 fn deref(&self) -> &Self::Target {
4185 &self.inner
4186 }
4187}
4188impl<'a> ::std::ops::DerefMut for BufferImageCopyBuilder<'a> {
4189 fn deref_mut(&mut self) -> &mut Self::Target {
4190 &mut self.inner
4191 }
4192}
4193impl<'a> BufferImageCopyBuilder<'a> {
4194 pub fn buffer_offset(mut self, buffer_offset: DeviceSize) -> Self {
4195 self.inner.buffer_offset = buffer_offset;
4196 self
4197 }
4198 pub fn buffer_row_length(mut self, buffer_row_length: u32) -> Self {
4199 self.inner.buffer_row_length = buffer_row_length;
4200 self
4201 }
4202 pub fn buffer_image_height(mut self, buffer_image_height: u32) -> Self {
4203 self.inner.buffer_image_height = buffer_image_height;
4204 self
4205 }
4206 pub fn image_subresource(mut self, image_subresource: ImageSubresourceLayers) -> Self {
4207 self.inner.image_subresource = image_subresource;
4208 self
4209 }
4210 pub fn image_offset(mut self, image_offset: Offset3D) -> Self {
4211 self.inner.image_offset = image_offset;
4212 self
4213 }
4214 pub fn image_extent(mut self, image_extent: Extent3D) -> Self {
4215 self.inner.image_extent = image_extent;
4216 self
4217 }
4218 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4219 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4220 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
4221 pub fn build(self) -> BufferImageCopy {
4222 self.inner
4223 }
4224}
4225#[repr(C)]
4226#[cfg_attr(feature = "debug", derive(Debug))]
4227#[derive(Copy, Clone, Default)]
4228#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageResolve.html>"]
4229pub struct ImageResolve {
4230 pub src_subresource: ImageSubresourceLayers,
4231 pub src_offset: Offset3D,
4232 pub dst_subresource: ImageSubresourceLayers,
4233 pub dst_offset: Offset3D,
4234 pub extent: Extent3D,
4235}
4236impl ImageResolve {
4237 pub fn builder<'a>() -> ImageResolveBuilder<'a> {
4238 ImageResolveBuilder {
4239 inner: Self::default(),
4240 marker: ::std::marker::PhantomData,
4241 }
4242 }
4243}
4244#[repr(transparent)]
4245pub struct ImageResolveBuilder<'a> {
4246 inner: ImageResolve,
4247 marker: ::std::marker::PhantomData<&'a ()>,
4248}
4249impl<'a> ::std::ops::Deref for ImageResolveBuilder<'a> {
4250 type Target = ImageResolve;
4251 fn deref(&self) -> &Self::Target {
4252 &self.inner
4253 }
4254}
4255impl<'a> ::std::ops::DerefMut for ImageResolveBuilder<'a> {
4256 fn deref_mut(&mut self) -> &mut Self::Target {
4257 &mut self.inner
4258 }
4259}
4260impl<'a> ImageResolveBuilder<'a> {
4261 pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self {
4262 self.inner.src_subresource = src_subresource;
4263 self
4264 }
4265 pub fn src_offset(mut self, src_offset: Offset3D) -> Self {
4266 self.inner.src_offset = src_offset;
4267 self
4268 }
4269 pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self {
4270 self.inner.dst_subresource = dst_subresource;
4271 self
4272 }
4273 pub fn dst_offset(mut self, dst_offset: Offset3D) -> Self {
4274 self.inner.dst_offset = dst_offset;
4275 self
4276 }
4277 pub fn extent(mut self, extent: Extent3D) -> Self {
4278 self.inner.extent = extent;
4279 self
4280 }
4281 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4282 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4283 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
4284 pub fn build(self) -> ImageResolve {
4285 self.inner
4286 }
4287}
4288#[repr(C)]
4289#[cfg_attr(feature = "debug", derive(Debug))]
4290#[derive(Copy, Clone)]
4291#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderModuleCreateInfo.html>"]
4292pub struct ShaderModuleCreateInfo {
4293 pub s_type: StructureType,
4294 pub p_next: *const c_void,
4295 pub flags: ShaderModuleCreateFlags,
4296 pub code_size: usize,
4297 pub p_code: *const u32,
4298}
4299impl ::std::default::Default for ShaderModuleCreateInfo {
4300 fn default() -> Self {
4301 Self {
4302 s_type: StructureType::SHADER_MODULE_CREATE_INFO,
4303 p_next: ::std::ptr::null(),
4304 flags: ShaderModuleCreateFlags::default(),
4305 code_size: usize::default(),
4306 p_code: ::std::ptr::null(),
4307 }
4308 }
4309}
4310impl ShaderModuleCreateInfo {
4311 pub fn builder<'a>() -> ShaderModuleCreateInfoBuilder<'a> {
4312 ShaderModuleCreateInfoBuilder {
4313 inner: Self::default(),
4314 marker: ::std::marker::PhantomData,
4315 }
4316 }
4317}
4318#[repr(transparent)]
4319pub struct ShaderModuleCreateInfoBuilder<'a> {
4320 inner: ShaderModuleCreateInfo,
4321 marker: ::std::marker::PhantomData<&'a ()>,
4322}
4323pub unsafe trait ExtendsShaderModuleCreateInfo {}
4324impl<'a> ::std::ops::Deref for ShaderModuleCreateInfoBuilder<'a> {
4325 type Target = ShaderModuleCreateInfo;
4326 fn deref(&self) -> &Self::Target {
4327 &self.inner
4328 }
4329}
4330impl<'a> ::std::ops::DerefMut for ShaderModuleCreateInfoBuilder<'a> {
4331 fn deref_mut(&mut self) -> &mut Self::Target {
4332 &mut self.inner
4333 }
4334}
4335impl<'a> ShaderModuleCreateInfoBuilder<'a> {
4336 pub fn flags(mut self, flags: ShaderModuleCreateFlags) -> Self {
4337 self.inner.flags = flags;
4338 self
4339 }
4340 pub fn code(mut self, code: &'a [u32]) -> Self {
4341 self.inner.code_size = code.len() * 4;
4342 self.inner.p_code = code.as_ptr();
4343 self
4344 }
4345 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
4346 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
4347 #[doc = r" valid extension structs can be pushed into the chain."]
4348 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
4349 #[doc = r" chain will look like `A -> D -> B -> C`."]
4350 pub fn push_next<T: ExtendsShaderModuleCreateInfo>(mut self, next: &'a mut T) -> Self {
4351 unsafe {
4352 let next_ptr = <*const T>::cast(next);
4353 let last_next = ptr_chain_iter(next).last().unwrap();
4354 (*last_next).p_next = self.inner.p_next as _;
4355 self.inner.p_next = next_ptr;
4356 }
4357 self
4358 }
4359 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4360 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4361 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
4362 pub fn build(self) -> ShaderModuleCreateInfo {
4363 self.inner
4364 }
4365}
4366#[repr(C)]
4367#[cfg_attr(feature = "debug", derive(Debug))]
4368#[derive(Copy, Clone)]
4369#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutBinding.html>"]
4370pub struct DescriptorSetLayoutBinding {
4371 pub binding: u32,
4372 pub descriptor_type: DescriptorType,
4373 pub descriptor_count: u32,
4374 pub stage_flags: ShaderStageFlags,
4375 pub p_immutable_samplers: *const Sampler,
4376}
4377impl ::std::default::Default for DescriptorSetLayoutBinding {
4378 fn default() -> Self {
4379 Self {
4380 binding: u32::default(),
4381 descriptor_type: DescriptorType::default(),
4382 descriptor_count: u32::default(),
4383 stage_flags: ShaderStageFlags::default(),
4384 p_immutable_samplers: ::std::ptr::null(),
4385 }
4386 }
4387}
4388impl DescriptorSetLayoutBinding {
4389 pub fn builder<'a>() -> DescriptorSetLayoutBindingBuilder<'a> {
4390 DescriptorSetLayoutBindingBuilder {
4391 inner: Self::default(),
4392 marker: ::std::marker::PhantomData,
4393 }
4394 }
4395}
4396#[repr(transparent)]
4397pub struct DescriptorSetLayoutBindingBuilder<'a> {
4398 inner: DescriptorSetLayoutBinding,
4399 marker: ::std::marker::PhantomData<&'a ()>,
4400}
4401impl<'a> ::std::ops::Deref for DescriptorSetLayoutBindingBuilder<'a> {
4402 type Target = DescriptorSetLayoutBinding;
4403 fn deref(&self) -> &Self::Target {
4404 &self.inner
4405 }
4406}
4407impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutBindingBuilder<'a> {
4408 fn deref_mut(&mut self) -> &mut Self::Target {
4409 &mut self.inner
4410 }
4411}
4412impl<'a> DescriptorSetLayoutBindingBuilder<'a> {
4413 pub fn binding(mut self, binding: u32) -> Self {
4414 self.inner.binding = binding;
4415 self
4416 }
4417 pub fn descriptor_type(mut self, descriptor_type: DescriptorType) -> Self {
4418 self.inner.descriptor_type = descriptor_type;
4419 self
4420 }
4421 pub fn descriptor_count(mut self, descriptor_count: u32) -> Self {
4422 self.inner.descriptor_count = descriptor_count;
4423 self
4424 }
4425 pub fn stage_flags(mut self, stage_flags: ShaderStageFlags) -> Self {
4426 self.inner.stage_flags = stage_flags;
4427 self
4428 }
4429 pub fn immutable_samplers(mut self, immutable_samplers: &'a [Sampler]) -> Self {
4430 self.inner.descriptor_count = immutable_samplers.len() as _;
4431 self.inner.p_immutable_samplers = immutable_samplers.as_ptr();
4432 self
4433 }
4434 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4435 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4436 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
4437 pub fn build(self) -> DescriptorSetLayoutBinding {
4438 self.inner
4439 }
4440}
4441#[repr(C)]
4442#[cfg_attr(feature = "debug", derive(Debug))]
4443#[derive(Copy, Clone)]
4444#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutCreateInfo.html>"]
4445pub struct DescriptorSetLayoutCreateInfo {
4446 pub s_type: StructureType,
4447 pub p_next: *const c_void,
4448 pub flags: DescriptorSetLayoutCreateFlags,
4449 pub binding_count: u32,
4450 pub p_bindings: *const DescriptorSetLayoutBinding,
4451}
4452impl ::std::default::Default for DescriptorSetLayoutCreateInfo {
4453 fn default() -> Self {
4454 Self {
4455 s_type: StructureType::DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
4456 p_next: ::std::ptr::null(),
4457 flags: DescriptorSetLayoutCreateFlags::default(),
4458 binding_count: u32::default(),
4459 p_bindings: ::std::ptr::null(),
4460 }
4461 }
4462}
4463impl DescriptorSetLayoutCreateInfo {
4464 pub fn builder<'a>() -> DescriptorSetLayoutCreateInfoBuilder<'a> {
4465 DescriptorSetLayoutCreateInfoBuilder {
4466 inner: Self::default(),
4467 marker: ::std::marker::PhantomData,
4468 }
4469 }
4470}
4471#[repr(transparent)]
4472pub struct DescriptorSetLayoutCreateInfoBuilder<'a> {
4473 inner: DescriptorSetLayoutCreateInfo,
4474 marker: ::std::marker::PhantomData<&'a ()>,
4475}
4476pub unsafe trait ExtendsDescriptorSetLayoutCreateInfo {}
4477impl<'a> ::std::ops::Deref for DescriptorSetLayoutCreateInfoBuilder<'a> {
4478 type Target = DescriptorSetLayoutCreateInfo;
4479 fn deref(&self) -> &Self::Target {
4480 &self.inner
4481 }
4482}
4483impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutCreateInfoBuilder<'a> {
4484 fn deref_mut(&mut self) -> &mut Self::Target {
4485 &mut self.inner
4486 }
4487}
4488impl<'a> DescriptorSetLayoutCreateInfoBuilder<'a> {
4489 pub fn flags(mut self, flags: DescriptorSetLayoutCreateFlags) -> Self {
4490 self.inner.flags = flags;
4491 self
4492 }
4493 pub fn bindings(mut self, bindings: &'a [DescriptorSetLayoutBinding]) -> Self {
4494 self.inner.binding_count = bindings.len() as _;
4495 self.inner.p_bindings = bindings.as_ptr();
4496 self
4497 }
4498 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
4499 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
4500 #[doc = r" valid extension structs can be pushed into the chain."]
4501 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
4502 #[doc = r" chain will look like `A -> D -> B -> C`."]
4503 pub fn push_next<T: ExtendsDescriptorSetLayoutCreateInfo>(mut self, next: &'a mut T) -> Self {
4504 unsafe {
4505 let next_ptr = <*const T>::cast(next);
4506 let last_next = ptr_chain_iter(next).last().unwrap();
4507 (*last_next).p_next = self.inner.p_next as _;
4508 self.inner.p_next = next_ptr;
4509 }
4510 self
4511 }
4512 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4513 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4514 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
4515 pub fn build(self) -> DescriptorSetLayoutCreateInfo {
4516 self.inner
4517 }
4518}
4519#[repr(C)]
4520#[cfg_attr(feature = "debug", derive(Debug))]
4521#[derive(Copy, Clone, Default)]
4522#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPoolSize.html>"]
4523pub struct DescriptorPoolSize {
4524 pub ty: DescriptorType,
4525 pub descriptor_count: u32,
4526}
4527impl DescriptorPoolSize {
4528 pub fn builder<'a>() -> DescriptorPoolSizeBuilder<'a> {
4529 DescriptorPoolSizeBuilder {
4530 inner: Self::default(),
4531 marker: ::std::marker::PhantomData,
4532 }
4533 }
4534}
4535#[repr(transparent)]
4536pub struct DescriptorPoolSizeBuilder<'a> {
4537 inner: DescriptorPoolSize,
4538 marker: ::std::marker::PhantomData<&'a ()>,
4539}
4540impl<'a> ::std::ops::Deref for DescriptorPoolSizeBuilder<'a> {
4541 type Target = DescriptorPoolSize;
4542 fn deref(&self) -> &Self::Target {
4543 &self.inner
4544 }
4545}
4546impl<'a> ::std::ops::DerefMut for DescriptorPoolSizeBuilder<'a> {
4547 fn deref_mut(&mut self) -> &mut Self::Target {
4548 &mut self.inner
4549 }
4550}
4551impl<'a> DescriptorPoolSizeBuilder<'a> {
4552 pub fn ty(mut self, ty: DescriptorType) -> Self {
4553 self.inner.ty = ty;
4554 self
4555 }
4556 pub fn descriptor_count(mut self, descriptor_count: u32) -> Self {
4557 self.inner.descriptor_count = descriptor_count;
4558 self
4559 }
4560 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4561 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4562 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
4563 pub fn build(self) -> DescriptorPoolSize {
4564 self.inner
4565 }
4566}
4567#[repr(C)]
4568#[cfg_attr(feature = "debug", derive(Debug))]
4569#[derive(Copy, Clone)]
4570#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPoolCreateInfo.html>"]
4571pub struct DescriptorPoolCreateInfo {
4572 pub s_type: StructureType,
4573 pub p_next: *const c_void,
4574 pub flags: DescriptorPoolCreateFlags,
4575 pub max_sets: u32,
4576 pub pool_size_count: u32,
4577 pub p_pool_sizes: *const DescriptorPoolSize,
4578}
4579impl ::std::default::Default for DescriptorPoolCreateInfo {
4580 fn default() -> Self {
4581 Self {
4582 s_type: StructureType::DESCRIPTOR_POOL_CREATE_INFO,
4583 p_next: ::std::ptr::null(),
4584 flags: DescriptorPoolCreateFlags::default(),
4585 max_sets: u32::default(),
4586 pool_size_count: u32::default(),
4587 p_pool_sizes: ::std::ptr::null(),
4588 }
4589 }
4590}
4591impl DescriptorPoolCreateInfo {
4592 pub fn builder<'a>() -> DescriptorPoolCreateInfoBuilder<'a> {
4593 DescriptorPoolCreateInfoBuilder {
4594 inner: Self::default(),
4595 marker: ::std::marker::PhantomData,
4596 }
4597 }
4598}
4599#[repr(transparent)]
4600pub struct DescriptorPoolCreateInfoBuilder<'a> {
4601 inner: DescriptorPoolCreateInfo,
4602 marker: ::std::marker::PhantomData<&'a ()>,
4603}
4604pub unsafe trait ExtendsDescriptorPoolCreateInfo {}
4605impl<'a> ::std::ops::Deref for DescriptorPoolCreateInfoBuilder<'a> {
4606 type Target = DescriptorPoolCreateInfo;
4607 fn deref(&self) -> &Self::Target {
4608 &self.inner
4609 }
4610}
4611impl<'a> ::std::ops::DerefMut for DescriptorPoolCreateInfoBuilder<'a> {
4612 fn deref_mut(&mut self) -> &mut Self::Target {
4613 &mut self.inner
4614 }
4615}
4616impl<'a> DescriptorPoolCreateInfoBuilder<'a> {
4617 pub fn flags(mut self, flags: DescriptorPoolCreateFlags) -> Self {
4618 self.inner.flags = flags;
4619 self
4620 }
4621 pub fn max_sets(mut self, max_sets: u32) -> Self {
4622 self.inner.max_sets = max_sets;
4623 self
4624 }
4625 pub fn pool_sizes(mut self, pool_sizes: &'a [DescriptorPoolSize]) -> Self {
4626 self.inner.pool_size_count = pool_sizes.len() as _;
4627 self.inner.p_pool_sizes = pool_sizes.as_ptr();
4628 self
4629 }
4630 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
4631 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
4632 #[doc = r" valid extension structs can be pushed into the chain."]
4633 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
4634 #[doc = r" chain will look like `A -> D -> B -> C`."]
4635 pub fn push_next<T: ExtendsDescriptorPoolCreateInfo>(mut self, next: &'a mut T) -> Self {
4636 unsafe {
4637 let next_ptr = <*const T>::cast(next);
4638 let last_next = ptr_chain_iter(next).last().unwrap();
4639 (*last_next).p_next = self.inner.p_next as _;
4640 self.inner.p_next = next_ptr;
4641 }
4642 self
4643 }
4644 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4645 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4646 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
4647 pub fn build(self) -> DescriptorPoolCreateInfo {
4648 self.inner
4649 }
4650}
4651#[repr(C)]
4652#[cfg_attr(feature = "debug", derive(Debug))]
4653#[derive(Copy, Clone)]
4654#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetAllocateInfo.html>"]
4655pub struct DescriptorSetAllocateInfo {
4656 pub s_type: StructureType,
4657 pub p_next: *const c_void,
4658 pub descriptor_pool: DescriptorPool,
4659 pub descriptor_set_count: u32,
4660 pub p_set_layouts: *const DescriptorSetLayout,
4661}
4662impl ::std::default::Default for DescriptorSetAllocateInfo {
4663 fn default() -> Self {
4664 Self {
4665 s_type: StructureType::DESCRIPTOR_SET_ALLOCATE_INFO,
4666 p_next: ::std::ptr::null(),
4667 descriptor_pool: DescriptorPool::default(),
4668 descriptor_set_count: u32::default(),
4669 p_set_layouts: ::std::ptr::null(),
4670 }
4671 }
4672}
4673impl DescriptorSetAllocateInfo {
4674 pub fn builder<'a>() -> DescriptorSetAllocateInfoBuilder<'a> {
4675 DescriptorSetAllocateInfoBuilder {
4676 inner: Self::default(),
4677 marker: ::std::marker::PhantomData,
4678 }
4679 }
4680}
4681#[repr(transparent)]
4682pub struct DescriptorSetAllocateInfoBuilder<'a> {
4683 inner: DescriptorSetAllocateInfo,
4684 marker: ::std::marker::PhantomData<&'a ()>,
4685}
4686pub unsafe trait ExtendsDescriptorSetAllocateInfo {}
4687impl<'a> ::std::ops::Deref for DescriptorSetAllocateInfoBuilder<'a> {
4688 type Target = DescriptorSetAllocateInfo;
4689 fn deref(&self) -> &Self::Target {
4690 &self.inner
4691 }
4692}
4693impl<'a> ::std::ops::DerefMut for DescriptorSetAllocateInfoBuilder<'a> {
4694 fn deref_mut(&mut self) -> &mut Self::Target {
4695 &mut self.inner
4696 }
4697}
4698impl<'a> DescriptorSetAllocateInfoBuilder<'a> {
4699 pub fn descriptor_pool(mut self, descriptor_pool: DescriptorPool) -> Self {
4700 self.inner.descriptor_pool = descriptor_pool;
4701 self
4702 }
4703 pub fn set_layouts(mut self, set_layouts: &'a [DescriptorSetLayout]) -> Self {
4704 self.inner.descriptor_set_count = set_layouts.len() as _;
4705 self.inner.p_set_layouts = set_layouts.as_ptr();
4706 self
4707 }
4708 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
4709 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
4710 #[doc = r" valid extension structs can be pushed into the chain."]
4711 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
4712 #[doc = r" chain will look like `A -> D -> B -> C`."]
4713 pub fn push_next<T: ExtendsDescriptorSetAllocateInfo>(mut self, next: &'a mut T) -> Self {
4714 unsafe {
4715 let next_ptr = <*const T>::cast(next);
4716 let last_next = ptr_chain_iter(next).last().unwrap();
4717 (*last_next).p_next = self.inner.p_next as _;
4718 self.inner.p_next = next_ptr;
4719 }
4720 self
4721 }
4722 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4723 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4724 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
4725 pub fn build(self) -> DescriptorSetAllocateInfo {
4726 self.inner
4727 }
4728}
4729#[repr(C)]
4730#[cfg_attr(feature = "debug", derive(Debug))]
4731#[derive(Copy, Clone, Default)]
4732#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSpecializationMapEntry.html>"]
4733pub struct SpecializationMapEntry {
4734 pub constant_id: u32,
4735 pub offset: u32,
4736 pub size: usize,
4737}
4738impl SpecializationMapEntry {
4739 pub fn builder<'a>() -> SpecializationMapEntryBuilder<'a> {
4740 SpecializationMapEntryBuilder {
4741 inner: Self::default(),
4742 marker: ::std::marker::PhantomData,
4743 }
4744 }
4745}
4746#[repr(transparent)]
4747pub struct SpecializationMapEntryBuilder<'a> {
4748 inner: SpecializationMapEntry,
4749 marker: ::std::marker::PhantomData<&'a ()>,
4750}
4751impl<'a> ::std::ops::Deref for SpecializationMapEntryBuilder<'a> {
4752 type Target = SpecializationMapEntry;
4753 fn deref(&self) -> &Self::Target {
4754 &self.inner
4755 }
4756}
4757impl<'a> ::std::ops::DerefMut for SpecializationMapEntryBuilder<'a> {
4758 fn deref_mut(&mut self) -> &mut Self::Target {
4759 &mut self.inner
4760 }
4761}
4762impl<'a> SpecializationMapEntryBuilder<'a> {
4763 pub fn constant_id(mut self, constant_id: u32) -> Self {
4764 self.inner.constant_id = constant_id;
4765 self
4766 }
4767 pub fn offset(mut self, offset: u32) -> Self {
4768 self.inner.offset = offset;
4769 self
4770 }
4771 pub fn size(mut self, size: usize) -> Self {
4772 self.inner.size = size;
4773 self
4774 }
4775 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4776 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4777 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
4778 pub fn build(self) -> SpecializationMapEntry {
4779 self.inner
4780 }
4781}
4782#[repr(C)]
4783#[cfg_attr(feature = "debug", derive(Debug))]
4784#[derive(Copy, Clone)]
4785#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSpecializationInfo.html>"]
4786pub struct SpecializationInfo {
4787 pub map_entry_count: u32,
4788 pub p_map_entries: *const SpecializationMapEntry,
4789 pub data_size: usize,
4790 pub p_data: *const c_void,
4791}
4792impl ::std::default::Default for SpecializationInfo {
4793 fn default() -> Self {
4794 Self {
4795 map_entry_count: u32::default(),
4796 p_map_entries: ::std::ptr::null(),
4797 data_size: usize::default(),
4798 p_data: ::std::ptr::null(),
4799 }
4800 }
4801}
4802impl SpecializationInfo {
4803 pub fn builder<'a>() -> SpecializationInfoBuilder<'a> {
4804 SpecializationInfoBuilder {
4805 inner: Self::default(),
4806 marker: ::std::marker::PhantomData,
4807 }
4808 }
4809}
4810#[repr(transparent)]
4811pub struct SpecializationInfoBuilder<'a> {
4812 inner: SpecializationInfo,
4813 marker: ::std::marker::PhantomData<&'a ()>,
4814}
4815impl<'a> ::std::ops::Deref for SpecializationInfoBuilder<'a> {
4816 type Target = SpecializationInfo;
4817 fn deref(&self) -> &Self::Target {
4818 &self.inner
4819 }
4820}
4821impl<'a> ::std::ops::DerefMut for SpecializationInfoBuilder<'a> {
4822 fn deref_mut(&mut self) -> &mut Self::Target {
4823 &mut self.inner
4824 }
4825}
4826impl<'a> SpecializationInfoBuilder<'a> {
4827 pub fn map_entries(mut self, map_entries: &'a [SpecializationMapEntry]) -> Self {
4828 self.inner.map_entry_count = map_entries.len() as _;
4829 self.inner.p_map_entries = map_entries.as_ptr();
4830 self
4831 }
4832 pub fn data(mut self, data: &'a [u8]) -> Self {
4833 self.inner.data_size = data.len();
4834 self.inner.p_data = data.as_ptr() as *const c_void;
4835 self
4836 }
4837 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4838 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4839 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
4840 pub fn build(self) -> SpecializationInfo {
4841 self.inner
4842 }
4843}
4844#[repr(C)]
4845#[cfg_attr(feature = "debug", derive(Debug))]
4846#[derive(Copy, Clone)]
4847#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineShaderStageCreateInfo.html>"]
4848pub struct PipelineShaderStageCreateInfo {
4849 pub s_type: StructureType,
4850 pub p_next: *const c_void,
4851 pub flags: PipelineShaderStageCreateFlags,
4852 pub stage: ShaderStageFlags,
4853 pub module: ShaderModule,
4854 pub p_name: *const c_char,
4855 pub p_specialization_info: *const SpecializationInfo,
4856}
4857impl ::std::default::Default for PipelineShaderStageCreateInfo {
4858 fn default() -> Self {
4859 Self {
4860 s_type: StructureType::PIPELINE_SHADER_STAGE_CREATE_INFO,
4861 p_next: ::std::ptr::null(),
4862 flags: PipelineShaderStageCreateFlags::default(),
4863 stage: ShaderStageFlags::default(),
4864 module: ShaderModule::default(),
4865 p_name: ::std::ptr::null(),
4866 p_specialization_info: ::std::ptr::null(),
4867 }
4868 }
4869}
4870impl PipelineShaderStageCreateInfo {
4871 pub fn builder<'a>() -> PipelineShaderStageCreateInfoBuilder<'a> {
4872 PipelineShaderStageCreateInfoBuilder {
4873 inner: Self::default(),
4874 marker: ::std::marker::PhantomData,
4875 }
4876 }
4877}
4878#[repr(transparent)]
4879pub struct PipelineShaderStageCreateInfoBuilder<'a> {
4880 inner: PipelineShaderStageCreateInfo,
4881 marker: ::std::marker::PhantomData<&'a ()>,
4882}
4883pub unsafe trait ExtendsPipelineShaderStageCreateInfo {}
4884impl<'a> ::std::ops::Deref for PipelineShaderStageCreateInfoBuilder<'a> {
4885 type Target = PipelineShaderStageCreateInfo;
4886 fn deref(&self) -> &Self::Target {
4887 &self.inner
4888 }
4889}
4890impl<'a> ::std::ops::DerefMut for PipelineShaderStageCreateInfoBuilder<'a> {
4891 fn deref_mut(&mut self) -> &mut Self::Target {
4892 &mut self.inner
4893 }
4894}
4895impl<'a> PipelineShaderStageCreateInfoBuilder<'a> {
4896 pub fn flags(mut self, flags: PipelineShaderStageCreateFlags) -> Self {
4897 self.inner.flags = flags;
4898 self
4899 }
4900 pub fn stage(mut self, stage: ShaderStageFlags) -> Self {
4901 self.inner.stage = stage;
4902 self
4903 }
4904 pub fn module(mut self, module: ShaderModule) -> Self {
4905 self.inner.module = module;
4906 self
4907 }
4908 pub fn name(mut self, name: &'a ::std::ffi::CStr) -> Self {
4909 self.inner.p_name = name.as_ptr();
4910 self
4911 }
4912 pub fn specialization_info(mut self, specialization_info: &'a SpecializationInfo) -> Self {
4913 self.inner.p_specialization_info = specialization_info;
4914 self
4915 }
4916 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
4917 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
4918 #[doc = r" valid extension structs can be pushed into the chain."]
4919 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
4920 #[doc = r" chain will look like `A -> D -> B -> C`."]
4921 pub fn push_next<T: ExtendsPipelineShaderStageCreateInfo>(mut self, next: &'a mut T) -> Self {
4922 unsafe {
4923 let next_ptr = <*const T>::cast(next);
4924 let last_next = ptr_chain_iter(next).last().unwrap();
4925 (*last_next).p_next = self.inner.p_next as _;
4926 self.inner.p_next = next_ptr;
4927 }
4928 self
4929 }
4930 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4931 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4932 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
4933 pub fn build(self) -> PipelineShaderStageCreateInfo {
4934 self.inner
4935 }
4936}
4937#[repr(C)]
4938#[cfg_attr(feature = "debug", derive(Debug))]
4939#[derive(Copy, Clone)]
4940#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkComputePipelineCreateInfo.html>"]
4941pub struct ComputePipelineCreateInfo {
4942 pub s_type: StructureType,
4943 pub p_next: *const c_void,
4944 pub flags: PipelineCreateFlags,
4945 pub stage: PipelineShaderStageCreateInfo,
4946 pub layout: PipelineLayout,
4947 pub base_pipeline_handle: Pipeline,
4948 pub base_pipeline_index: i32,
4949}
4950impl ::std::default::Default for ComputePipelineCreateInfo {
4951 fn default() -> Self {
4952 Self {
4953 s_type: StructureType::COMPUTE_PIPELINE_CREATE_INFO,
4954 p_next: ::std::ptr::null(),
4955 flags: PipelineCreateFlags::default(),
4956 stage: PipelineShaderStageCreateInfo::default(),
4957 layout: PipelineLayout::default(),
4958 base_pipeline_handle: Pipeline::default(),
4959 base_pipeline_index: i32::default(),
4960 }
4961 }
4962}
4963impl ComputePipelineCreateInfo {
4964 pub fn builder<'a>() -> ComputePipelineCreateInfoBuilder<'a> {
4965 ComputePipelineCreateInfoBuilder {
4966 inner: Self::default(),
4967 marker: ::std::marker::PhantomData,
4968 }
4969 }
4970}
4971#[repr(transparent)]
4972pub struct ComputePipelineCreateInfoBuilder<'a> {
4973 inner: ComputePipelineCreateInfo,
4974 marker: ::std::marker::PhantomData<&'a ()>,
4975}
4976pub unsafe trait ExtendsComputePipelineCreateInfo {}
4977impl<'a> ::std::ops::Deref for ComputePipelineCreateInfoBuilder<'a> {
4978 type Target = ComputePipelineCreateInfo;
4979 fn deref(&self) -> &Self::Target {
4980 &self.inner
4981 }
4982}
4983impl<'a> ::std::ops::DerefMut for ComputePipelineCreateInfoBuilder<'a> {
4984 fn deref_mut(&mut self) -> &mut Self::Target {
4985 &mut self.inner
4986 }
4987}
4988impl<'a> ComputePipelineCreateInfoBuilder<'a> {
4989 pub fn flags(mut self, flags: PipelineCreateFlags) -> Self {
4990 self.inner.flags = flags;
4991 self
4992 }
4993 pub fn stage(mut self, stage: PipelineShaderStageCreateInfo) -> Self {
4994 self.inner.stage = stage;
4995 self
4996 }
4997 pub fn layout(mut self, layout: PipelineLayout) -> Self {
4998 self.inner.layout = layout;
4999 self
5000 }
5001 pub fn base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self {
5002 self.inner.base_pipeline_handle = base_pipeline_handle;
5003 self
5004 }
5005 pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self {
5006 self.inner.base_pipeline_index = base_pipeline_index;
5007 self
5008 }
5009 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
5010 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
5011 #[doc = r" valid extension structs can be pushed into the chain."]
5012 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
5013 #[doc = r" chain will look like `A -> D -> B -> C`."]
5014 pub fn push_next<T: ExtendsComputePipelineCreateInfo>(mut self, next: &'a mut T) -> Self {
5015 unsafe {
5016 let next_ptr = <*const T>::cast(next);
5017 let last_next = ptr_chain_iter(next).last().unwrap();
5018 (*last_next).p_next = self.inner.p_next as _;
5019 self.inner.p_next = next_ptr;
5020 }
5021 self
5022 }
5023 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5024 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5025 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
5026 pub fn build(self) -> ComputePipelineCreateInfo {
5027 self.inner
5028 }
5029}
5030#[repr(C)]
5031#[cfg_attr(feature = "debug", derive(Debug))]
5032#[derive(Copy, Clone, Default)]
5033#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVertexInputBindingDescription.html>"]
5034pub struct VertexInputBindingDescription {
5035 pub binding: u32,
5036 pub stride: u32,
5037 pub input_rate: VertexInputRate,
5038}
5039impl VertexInputBindingDescription {
5040 pub fn builder<'a>() -> VertexInputBindingDescriptionBuilder<'a> {
5041 VertexInputBindingDescriptionBuilder {
5042 inner: Self::default(),
5043 marker: ::std::marker::PhantomData,
5044 }
5045 }
5046}
5047#[repr(transparent)]
5048pub struct VertexInputBindingDescriptionBuilder<'a> {
5049 inner: VertexInputBindingDescription,
5050 marker: ::std::marker::PhantomData<&'a ()>,
5051}
5052impl<'a> ::std::ops::Deref for VertexInputBindingDescriptionBuilder<'a> {
5053 type Target = VertexInputBindingDescription;
5054 fn deref(&self) -> &Self::Target {
5055 &self.inner
5056 }
5057}
5058impl<'a> ::std::ops::DerefMut for VertexInputBindingDescriptionBuilder<'a> {
5059 fn deref_mut(&mut self) -> &mut Self::Target {
5060 &mut self.inner
5061 }
5062}
5063impl<'a> VertexInputBindingDescriptionBuilder<'a> {
5064 pub fn binding(mut self, binding: u32) -> Self {
5065 self.inner.binding = binding;
5066 self
5067 }
5068 pub fn stride(mut self, stride: u32) -> Self {
5069 self.inner.stride = stride;
5070 self
5071 }
5072 pub fn input_rate(mut self, input_rate: VertexInputRate) -> Self {
5073 self.inner.input_rate = input_rate;
5074 self
5075 }
5076 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5077 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5078 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
5079 pub fn build(self) -> VertexInputBindingDescription {
5080 self.inner
5081 }
5082}
5083#[repr(C)]
5084#[cfg_attr(feature = "debug", derive(Debug))]
5085#[derive(Copy, Clone, Default)]
5086#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVertexInputAttributeDescription.html>"]
5087pub struct VertexInputAttributeDescription {
5088 pub location: u32,
5089 pub binding: u32,
5090 pub format: Format,
5091 pub offset: u32,
5092}
5093impl VertexInputAttributeDescription {
5094 pub fn builder<'a>() -> VertexInputAttributeDescriptionBuilder<'a> {
5095 VertexInputAttributeDescriptionBuilder {
5096 inner: Self::default(),
5097 marker: ::std::marker::PhantomData,
5098 }
5099 }
5100}
5101#[repr(transparent)]
5102pub struct VertexInputAttributeDescriptionBuilder<'a> {
5103 inner: VertexInputAttributeDescription,
5104 marker: ::std::marker::PhantomData<&'a ()>,
5105}
5106impl<'a> ::std::ops::Deref for VertexInputAttributeDescriptionBuilder<'a> {
5107 type Target = VertexInputAttributeDescription;
5108 fn deref(&self) -> &Self::Target {
5109 &self.inner
5110 }
5111}
5112impl<'a> ::std::ops::DerefMut for VertexInputAttributeDescriptionBuilder<'a> {
5113 fn deref_mut(&mut self) -> &mut Self::Target {
5114 &mut self.inner
5115 }
5116}
5117impl<'a> VertexInputAttributeDescriptionBuilder<'a> {
5118 pub fn location(mut self, location: u32) -> Self {
5119 self.inner.location = location;
5120 self
5121 }
5122 pub fn binding(mut self, binding: u32) -> Self {
5123 self.inner.binding = binding;
5124 self
5125 }
5126 pub fn format(mut self, format: Format) -> Self {
5127 self.inner.format = format;
5128 self
5129 }
5130 pub fn offset(mut self, offset: u32) -> Self {
5131 self.inner.offset = offset;
5132 self
5133 }
5134 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5135 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5136 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
5137 pub fn build(self) -> VertexInputAttributeDescription {
5138 self.inner
5139 }
5140}
5141#[repr(C)]
5142#[cfg_attr(feature = "debug", derive(Debug))]
5143#[derive(Copy, Clone)]
5144#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineVertexInputStateCreateInfo.html>"]
5145pub struct PipelineVertexInputStateCreateInfo {
5146 pub s_type: StructureType,
5147 pub p_next: *const c_void,
5148 pub flags: PipelineVertexInputStateCreateFlags,
5149 pub vertex_binding_description_count: u32,
5150 pub p_vertex_binding_descriptions: *const VertexInputBindingDescription,
5151 pub vertex_attribute_description_count: u32,
5152 pub p_vertex_attribute_descriptions: *const VertexInputAttributeDescription,
5153}
5154impl ::std::default::Default for PipelineVertexInputStateCreateInfo {
5155 fn default() -> Self {
5156 Self {
5157 s_type: StructureType::PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
5158 p_next: ::std::ptr::null(),
5159 flags: PipelineVertexInputStateCreateFlags::default(),
5160 vertex_binding_description_count: u32::default(),
5161 p_vertex_binding_descriptions: ::std::ptr::null(),
5162 vertex_attribute_description_count: u32::default(),
5163 p_vertex_attribute_descriptions: ::std::ptr::null(),
5164 }
5165 }
5166}
5167impl PipelineVertexInputStateCreateInfo {
5168 pub fn builder<'a>() -> PipelineVertexInputStateCreateInfoBuilder<'a> {
5169 PipelineVertexInputStateCreateInfoBuilder {
5170 inner: Self::default(),
5171 marker: ::std::marker::PhantomData,
5172 }
5173 }
5174}
5175#[repr(transparent)]
5176pub struct PipelineVertexInputStateCreateInfoBuilder<'a> {
5177 inner: PipelineVertexInputStateCreateInfo,
5178 marker: ::std::marker::PhantomData<&'a ()>,
5179}
5180pub unsafe trait ExtendsPipelineVertexInputStateCreateInfo {}
5181impl<'a> ::std::ops::Deref for PipelineVertexInputStateCreateInfoBuilder<'a> {
5182 type Target = PipelineVertexInputStateCreateInfo;
5183 fn deref(&self) -> &Self::Target {
5184 &self.inner
5185 }
5186}
5187impl<'a> ::std::ops::DerefMut for PipelineVertexInputStateCreateInfoBuilder<'a> {
5188 fn deref_mut(&mut self) -> &mut Self::Target {
5189 &mut self.inner
5190 }
5191}
5192impl<'a> PipelineVertexInputStateCreateInfoBuilder<'a> {
5193 pub fn flags(mut self, flags: PipelineVertexInputStateCreateFlags) -> Self {
5194 self.inner.flags = flags;
5195 self
5196 }
5197 pub fn vertex_binding_descriptions(
5198 mut self,
5199 vertex_binding_descriptions: &'a [VertexInputBindingDescription],
5200 ) -> Self {
5201 self.inner.vertex_binding_description_count = vertex_binding_descriptions.len() as _;
5202 self.inner.p_vertex_binding_descriptions = vertex_binding_descriptions.as_ptr();
5203 self
5204 }
5205 pub fn vertex_attribute_descriptions(
5206 mut self,
5207 vertex_attribute_descriptions: &'a [VertexInputAttributeDescription],
5208 ) -> Self {
5209 self.inner.vertex_attribute_description_count = vertex_attribute_descriptions.len() as _;
5210 self.inner.p_vertex_attribute_descriptions = vertex_attribute_descriptions.as_ptr();
5211 self
5212 }
5213 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
5214 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
5215 #[doc = r" valid extension structs can be pushed into the chain."]
5216 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
5217 #[doc = r" chain will look like `A -> D -> B -> C`."]
5218 pub fn push_next<T: ExtendsPipelineVertexInputStateCreateInfo>(
5219 mut self,
5220 next: &'a mut T,
5221 ) -> Self {
5222 unsafe {
5223 let next_ptr = <*const T>::cast(next);
5224 let last_next = ptr_chain_iter(next).last().unwrap();
5225 (*last_next).p_next = self.inner.p_next as _;
5226 self.inner.p_next = next_ptr;
5227 }
5228 self
5229 }
5230 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5231 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5232 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
5233 pub fn build(self) -> PipelineVertexInputStateCreateInfo {
5234 self.inner
5235 }
5236}
5237#[repr(C)]
5238#[cfg_attr(feature = "debug", derive(Debug))]
5239#[derive(Copy, Clone)]
5240#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineInputAssemblyStateCreateInfo.html>"]
5241pub struct PipelineInputAssemblyStateCreateInfo {
5242 pub s_type: StructureType,
5243 pub p_next: *const c_void,
5244 pub flags: PipelineInputAssemblyStateCreateFlags,
5245 pub topology: PrimitiveTopology,
5246 pub primitive_restart_enable: Bool32,
5247}
5248impl ::std::default::Default for PipelineInputAssemblyStateCreateInfo {
5249 fn default() -> Self {
5250 Self {
5251 s_type: StructureType::PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
5252 p_next: ::std::ptr::null(),
5253 flags: PipelineInputAssemblyStateCreateFlags::default(),
5254 topology: PrimitiveTopology::default(),
5255 primitive_restart_enable: Bool32::default(),
5256 }
5257 }
5258}
5259impl PipelineInputAssemblyStateCreateInfo {
5260 pub fn builder<'a>() -> PipelineInputAssemblyStateCreateInfoBuilder<'a> {
5261 PipelineInputAssemblyStateCreateInfoBuilder {
5262 inner: Self::default(),
5263 marker: ::std::marker::PhantomData,
5264 }
5265 }
5266}
5267#[repr(transparent)]
5268pub struct PipelineInputAssemblyStateCreateInfoBuilder<'a> {
5269 inner: PipelineInputAssemblyStateCreateInfo,
5270 marker: ::std::marker::PhantomData<&'a ()>,
5271}
5272impl<'a> ::std::ops::Deref for PipelineInputAssemblyStateCreateInfoBuilder<'a> {
5273 type Target = PipelineInputAssemblyStateCreateInfo;
5274 fn deref(&self) -> &Self::Target {
5275 &self.inner
5276 }
5277}
5278impl<'a> ::std::ops::DerefMut for PipelineInputAssemblyStateCreateInfoBuilder<'a> {
5279 fn deref_mut(&mut self) -> &mut Self::Target {
5280 &mut self.inner
5281 }
5282}
5283impl<'a> PipelineInputAssemblyStateCreateInfoBuilder<'a> {
5284 pub fn flags(mut self, flags: PipelineInputAssemblyStateCreateFlags) -> Self {
5285 self.inner.flags = flags;
5286 self
5287 }
5288 pub fn topology(mut self, topology: PrimitiveTopology) -> Self {
5289 self.inner.topology = topology;
5290 self
5291 }
5292 pub fn primitive_restart_enable(mut self, primitive_restart_enable: bool) -> Self {
5293 self.inner.primitive_restart_enable = primitive_restart_enable.into();
5294 self
5295 }
5296 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5297 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5298 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
5299 pub fn build(self) -> PipelineInputAssemblyStateCreateInfo {
5300 self.inner
5301 }
5302}
5303#[repr(C)]
5304#[cfg_attr(feature = "debug", derive(Debug))]
5305#[derive(Copy, Clone)]
5306#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineTessellationStateCreateInfo.html>"]
5307pub struct PipelineTessellationStateCreateInfo {
5308 pub s_type: StructureType,
5309 pub p_next: *const c_void,
5310 pub flags: PipelineTessellationStateCreateFlags,
5311 pub patch_control_points: u32,
5312}
5313impl ::std::default::Default for PipelineTessellationStateCreateInfo {
5314 fn default() -> Self {
5315 Self {
5316 s_type: StructureType::PIPELINE_TESSELLATION_STATE_CREATE_INFO,
5317 p_next: ::std::ptr::null(),
5318 flags: PipelineTessellationStateCreateFlags::default(),
5319 patch_control_points: u32::default(),
5320 }
5321 }
5322}
5323impl PipelineTessellationStateCreateInfo {
5324 pub fn builder<'a>() -> PipelineTessellationStateCreateInfoBuilder<'a> {
5325 PipelineTessellationStateCreateInfoBuilder {
5326 inner: Self::default(),
5327 marker: ::std::marker::PhantomData,
5328 }
5329 }
5330}
5331#[repr(transparent)]
5332pub struct PipelineTessellationStateCreateInfoBuilder<'a> {
5333 inner: PipelineTessellationStateCreateInfo,
5334 marker: ::std::marker::PhantomData<&'a ()>,
5335}
5336pub unsafe trait ExtendsPipelineTessellationStateCreateInfo {}
5337impl<'a> ::std::ops::Deref for PipelineTessellationStateCreateInfoBuilder<'a> {
5338 type Target = PipelineTessellationStateCreateInfo;
5339 fn deref(&self) -> &Self::Target {
5340 &self.inner
5341 }
5342}
5343impl<'a> ::std::ops::DerefMut for PipelineTessellationStateCreateInfoBuilder<'a> {
5344 fn deref_mut(&mut self) -> &mut Self::Target {
5345 &mut self.inner
5346 }
5347}
5348impl<'a> PipelineTessellationStateCreateInfoBuilder<'a> {
5349 pub fn flags(mut self, flags: PipelineTessellationStateCreateFlags) -> Self {
5350 self.inner.flags = flags;
5351 self
5352 }
5353 pub fn patch_control_points(mut self, patch_control_points: u32) -> Self {
5354 self.inner.patch_control_points = patch_control_points;
5355 self
5356 }
5357 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
5358 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
5359 #[doc = r" valid extension structs can be pushed into the chain."]
5360 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
5361 #[doc = r" chain will look like `A -> D -> B -> C`."]
5362 pub fn push_next<T: ExtendsPipelineTessellationStateCreateInfo>(
5363 mut self,
5364 next: &'a mut T,
5365 ) -> Self {
5366 unsafe {
5367 let next_ptr = <*const T>::cast(next);
5368 let last_next = ptr_chain_iter(next).last().unwrap();
5369 (*last_next).p_next = self.inner.p_next as _;
5370 self.inner.p_next = next_ptr;
5371 }
5372 self
5373 }
5374 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5375 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5376 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
5377 pub fn build(self) -> PipelineTessellationStateCreateInfo {
5378 self.inner
5379 }
5380}
5381#[repr(C)]
5382#[cfg_attr(feature = "debug", derive(Debug))]
5383#[derive(Copy, Clone)]
5384#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportStateCreateInfo.html>"]
5385pub struct PipelineViewportStateCreateInfo {
5386 pub s_type: StructureType,
5387 pub p_next: *const c_void,
5388 pub flags: PipelineViewportStateCreateFlags,
5389 pub viewport_count: u32,
5390 pub p_viewports: *const Viewport,
5391 pub scissor_count: u32,
5392 pub p_scissors: *const Rect2D,
5393}
5394impl ::std::default::Default for PipelineViewportStateCreateInfo {
5395 fn default() -> Self {
5396 Self {
5397 s_type: StructureType::PIPELINE_VIEWPORT_STATE_CREATE_INFO,
5398 p_next: ::std::ptr::null(),
5399 flags: PipelineViewportStateCreateFlags::default(),
5400 viewport_count: u32::default(),
5401 p_viewports: ::std::ptr::null(),
5402 scissor_count: u32::default(),
5403 p_scissors: ::std::ptr::null(),
5404 }
5405 }
5406}
5407impl PipelineViewportStateCreateInfo {
5408 pub fn builder<'a>() -> PipelineViewportStateCreateInfoBuilder<'a> {
5409 PipelineViewportStateCreateInfoBuilder {
5410 inner: Self::default(),
5411 marker: ::std::marker::PhantomData,
5412 }
5413 }
5414}
5415#[repr(transparent)]
5416pub struct PipelineViewportStateCreateInfoBuilder<'a> {
5417 inner: PipelineViewportStateCreateInfo,
5418 marker: ::std::marker::PhantomData<&'a ()>,
5419}
5420pub unsafe trait ExtendsPipelineViewportStateCreateInfo {}
5421impl<'a> ::std::ops::Deref for PipelineViewportStateCreateInfoBuilder<'a> {
5422 type Target = PipelineViewportStateCreateInfo;
5423 fn deref(&self) -> &Self::Target {
5424 &self.inner
5425 }
5426}
5427impl<'a> ::std::ops::DerefMut for PipelineViewportStateCreateInfoBuilder<'a> {
5428 fn deref_mut(&mut self) -> &mut Self::Target {
5429 &mut self.inner
5430 }
5431}
5432impl<'a> PipelineViewportStateCreateInfoBuilder<'a> {
5433 pub fn flags(mut self, flags: PipelineViewportStateCreateFlags) -> Self {
5434 self.inner.flags = flags;
5435 self
5436 }
5437 pub fn viewport_count(mut self, viewport_count: u32) -> Self {
5438 self.inner.viewport_count = viewport_count;
5439 self
5440 }
5441 pub fn viewports(mut self, viewports: &'a [Viewport]) -> Self {
5442 self.inner.viewport_count = viewports.len() as _;
5443 self.inner.p_viewports = viewports.as_ptr();
5444 self
5445 }
5446 pub fn scissor_count(mut self, scissor_count: u32) -> Self {
5447 self.inner.scissor_count = scissor_count;
5448 self
5449 }
5450 pub fn scissors(mut self, scissors: &'a [Rect2D]) -> Self {
5451 self.inner.scissor_count = scissors.len() as _;
5452 self.inner.p_scissors = scissors.as_ptr();
5453 self
5454 }
5455 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
5456 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
5457 #[doc = r" valid extension structs can be pushed into the chain."]
5458 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
5459 #[doc = r" chain will look like `A -> D -> B -> C`."]
5460 pub fn push_next<T: ExtendsPipelineViewportStateCreateInfo>(mut self, next: &'a mut T) -> Self {
5461 unsafe {
5462 let next_ptr = <*const T>::cast(next);
5463 let last_next = ptr_chain_iter(next).last().unwrap();
5464 (*last_next).p_next = self.inner.p_next as _;
5465 self.inner.p_next = next_ptr;
5466 }
5467 self
5468 }
5469 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5470 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5471 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
5472 pub fn build(self) -> PipelineViewportStateCreateInfo {
5473 self.inner
5474 }
5475}
5476#[repr(C)]
5477#[cfg_attr(feature = "debug", derive(Debug))]
5478#[derive(Copy, Clone)]
5479#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationStateCreateInfo.html>"]
5480pub struct PipelineRasterizationStateCreateInfo {
5481 pub s_type: StructureType,
5482 pub p_next: *const c_void,
5483 pub flags: PipelineRasterizationStateCreateFlags,
5484 pub depth_clamp_enable: Bool32,
5485 pub rasterizer_discard_enable: Bool32,
5486 pub polygon_mode: PolygonMode,
5487 pub cull_mode: CullModeFlags,
5488 pub front_face: FrontFace,
5489 pub depth_bias_enable: Bool32,
5490 pub depth_bias_constant_factor: f32,
5491 pub depth_bias_clamp: f32,
5492 pub depth_bias_slope_factor: f32,
5493 pub line_width: f32,
5494}
5495impl ::std::default::Default for PipelineRasterizationStateCreateInfo {
5496 fn default() -> Self {
5497 Self {
5498 s_type: StructureType::PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
5499 p_next: ::std::ptr::null(),
5500 flags: PipelineRasterizationStateCreateFlags::default(),
5501 depth_clamp_enable: Bool32::default(),
5502 rasterizer_discard_enable: Bool32::default(),
5503 polygon_mode: PolygonMode::default(),
5504 cull_mode: CullModeFlags::default(),
5505 front_face: FrontFace::default(),
5506 depth_bias_enable: Bool32::default(),
5507 depth_bias_constant_factor: f32::default(),
5508 depth_bias_clamp: f32::default(),
5509 depth_bias_slope_factor: f32::default(),
5510 line_width: f32::default(),
5511 }
5512 }
5513}
5514impl PipelineRasterizationStateCreateInfo {
5515 pub fn builder<'a>() -> PipelineRasterizationStateCreateInfoBuilder<'a> {
5516 PipelineRasterizationStateCreateInfoBuilder {
5517 inner: Self::default(),
5518 marker: ::std::marker::PhantomData,
5519 }
5520 }
5521}
5522#[repr(transparent)]
5523pub struct PipelineRasterizationStateCreateInfoBuilder<'a> {
5524 inner: PipelineRasterizationStateCreateInfo,
5525 marker: ::std::marker::PhantomData<&'a ()>,
5526}
5527pub unsafe trait ExtendsPipelineRasterizationStateCreateInfo {}
5528impl<'a> ::std::ops::Deref for PipelineRasterizationStateCreateInfoBuilder<'a> {
5529 type Target = PipelineRasterizationStateCreateInfo;
5530 fn deref(&self) -> &Self::Target {
5531 &self.inner
5532 }
5533}
5534impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateCreateInfoBuilder<'a> {
5535 fn deref_mut(&mut self) -> &mut Self::Target {
5536 &mut self.inner
5537 }
5538}
5539impl<'a> PipelineRasterizationStateCreateInfoBuilder<'a> {
5540 pub fn flags(mut self, flags: PipelineRasterizationStateCreateFlags) -> Self {
5541 self.inner.flags = flags;
5542 self
5543 }
5544 pub fn depth_clamp_enable(mut self, depth_clamp_enable: bool) -> Self {
5545 self.inner.depth_clamp_enable = depth_clamp_enable.into();
5546 self
5547 }
5548 pub fn rasterizer_discard_enable(mut self, rasterizer_discard_enable: bool) -> Self {
5549 self.inner.rasterizer_discard_enable = rasterizer_discard_enable.into();
5550 self
5551 }
5552 pub fn polygon_mode(mut self, polygon_mode: PolygonMode) -> Self {
5553 self.inner.polygon_mode = polygon_mode;
5554 self
5555 }
5556 pub fn cull_mode(mut self, cull_mode: CullModeFlags) -> Self {
5557 self.inner.cull_mode = cull_mode;
5558 self
5559 }
5560 pub fn front_face(mut self, front_face: FrontFace) -> Self {
5561 self.inner.front_face = front_face;
5562 self
5563 }
5564 pub fn depth_bias_enable(mut self, depth_bias_enable: bool) -> Self {
5565 self.inner.depth_bias_enable = depth_bias_enable.into();
5566 self
5567 }
5568 pub fn depth_bias_constant_factor(mut self, depth_bias_constant_factor: f32) -> Self {
5569 self.inner.depth_bias_constant_factor = depth_bias_constant_factor;
5570 self
5571 }
5572 pub fn depth_bias_clamp(mut self, depth_bias_clamp: f32) -> Self {
5573 self.inner.depth_bias_clamp = depth_bias_clamp;
5574 self
5575 }
5576 pub fn depth_bias_slope_factor(mut self, depth_bias_slope_factor: f32) -> Self {
5577 self.inner.depth_bias_slope_factor = depth_bias_slope_factor;
5578 self
5579 }
5580 pub fn line_width(mut self, line_width: f32) -> Self {
5581 self.inner.line_width = line_width;
5582 self
5583 }
5584 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
5585 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
5586 #[doc = r" valid extension structs can be pushed into the chain."]
5587 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
5588 #[doc = r" chain will look like `A -> D -> B -> C`."]
5589 pub fn push_next<T: ExtendsPipelineRasterizationStateCreateInfo>(
5590 mut self,
5591 next: &'a mut T,
5592 ) -> Self {
5593 unsafe {
5594 let next_ptr = <*const T>::cast(next);
5595 let last_next = ptr_chain_iter(next).last().unwrap();
5596 (*last_next).p_next = self.inner.p_next as _;
5597 self.inner.p_next = next_ptr;
5598 }
5599 self
5600 }
5601 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5602 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5603 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
5604 pub fn build(self) -> PipelineRasterizationStateCreateInfo {
5605 self.inner
5606 }
5607}
5608#[repr(C)]
5609#[cfg_attr(feature = "debug", derive(Debug))]
5610#[derive(Copy, Clone)]
5611#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineMultisampleStateCreateInfo.html>"]
5612pub struct PipelineMultisampleStateCreateInfo {
5613 pub s_type: StructureType,
5614 pub p_next: *const c_void,
5615 pub flags: PipelineMultisampleStateCreateFlags,
5616 pub rasterization_samples: SampleCountFlags,
5617 pub sample_shading_enable: Bool32,
5618 pub min_sample_shading: f32,
5619 pub p_sample_mask: *const SampleMask,
5620 pub alpha_to_coverage_enable: Bool32,
5621 pub alpha_to_one_enable: Bool32,
5622}
5623impl ::std::default::Default for PipelineMultisampleStateCreateInfo {
5624 fn default() -> Self {
5625 Self {
5626 s_type: StructureType::PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
5627 p_next: ::std::ptr::null(),
5628 flags: PipelineMultisampleStateCreateFlags::default(),
5629 rasterization_samples: SampleCountFlags::default(),
5630 sample_shading_enable: Bool32::default(),
5631 min_sample_shading: f32::default(),
5632 p_sample_mask: ::std::ptr::null(),
5633 alpha_to_coverage_enable: Bool32::default(),
5634 alpha_to_one_enable: Bool32::default(),
5635 }
5636 }
5637}
5638impl PipelineMultisampleStateCreateInfo {
5639 pub fn builder<'a>() -> PipelineMultisampleStateCreateInfoBuilder<'a> {
5640 PipelineMultisampleStateCreateInfoBuilder {
5641 inner: Self::default(),
5642 marker: ::std::marker::PhantomData,
5643 }
5644 }
5645}
5646#[repr(transparent)]
5647pub struct PipelineMultisampleStateCreateInfoBuilder<'a> {
5648 inner: PipelineMultisampleStateCreateInfo,
5649 marker: ::std::marker::PhantomData<&'a ()>,
5650}
5651pub unsafe trait ExtendsPipelineMultisampleStateCreateInfo {}
5652impl<'a> ::std::ops::Deref for PipelineMultisampleStateCreateInfoBuilder<'a> {
5653 type Target = PipelineMultisampleStateCreateInfo;
5654 fn deref(&self) -> &Self::Target {
5655 &self.inner
5656 }
5657}
5658impl<'a> ::std::ops::DerefMut for PipelineMultisampleStateCreateInfoBuilder<'a> {
5659 fn deref_mut(&mut self) -> &mut Self::Target {
5660 &mut self.inner
5661 }
5662}
5663impl<'a> PipelineMultisampleStateCreateInfoBuilder<'a> {
5664 pub fn flags(mut self, flags: PipelineMultisampleStateCreateFlags) -> Self {
5665 self.inner.flags = flags;
5666 self
5667 }
5668 pub fn rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self {
5669 self.inner.rasterization_samples = rasterization_samples;
5670 self
5671 }
5672 pub fn sample_shading_enable(mut self, sample_shading_enable: bool) -> Self {
5673 self.inner.sample_shading_enable = sample_shading_enable.into();
5674 self
5675 }
5676 pub fn min_sample_shading(mut self, min_sample_shading: f32) -> Self {
5677 self.inner.min_sample_shading = min_sample_shading;
5678 self
5679 }
5680 #[doc = r" Sets `p_sample_mask` to `null` if the slice is empty. The mask will"]
5681 #[doc = r" be treated as if it has all bits set to `1`."]
5682 #[doc = r""]
5683 #[doc = r" See <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineMultisampleStateCreateInfo.html#_description>"]
5684 #[doc = r" for more details."]
5685 pub fn sample_mask(mut self, sample_mask: &'a [SampleMask]) -> Self {
5686 self.inner.p_sample_mask = if sample_mask.is_empty() {
5687 std::ptr::null()
5688 } else {
5689 sample_mask.as_ptr()
5690 };
5691 self
5692 }
5693 pub fn alpha_to_coverage_enable(mut self, alpha_to_coverage_enable: bool) -> Self {
5694 self.inner.alpha_to_coverage_enable = alpha_to_coverage_enable.into();
5695 self
5696 }
5697 pub fn alpha_to_one_enable(mut self, alpha_to_one_enable: bool) -> Self {
5698 self.inner.alpha_to_one_enable = alpha_to_one_enable.into();
5699 self
5700 }
5701 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
5702 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
5703 #[doc = r" valid extension structs can be pushed into the chain."]
5704 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
5705 #[doc = r" chain will look like `A -> D -> B -> C`."]
5706 pub fn push_next<T: ExtendsPipelineMultisampleStateCreateInfo>(
5707 mut self,
5708 next: &'a mut T,
5709 ) -> Self {
5710 unsafe {
5711 let next_ptr = <*const T>::cast(next);
5712 let last_next = ptr_chain_iter(next).last().unwrap();
5713 (*last_next).p_next = self.inner.p_next as _;
5714 self.inner.p_next = next_ptr;
5715 }
5716 self
5717 }
5718 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5719 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5720 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
5721 pub fn build(self) -> PipelineMultisampleStateCreateInfo {
5722 self.inner
5723 }
5724}
5725#[repr(C)]
5726#[cfg_attr(feature = "debug", derive(Debug))]
5727#[derive(Copy, Clone, Default)]
5728#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineColorBlendAttachmentState.html>"]
5729pub struct PipelineColorBlendAttachmentState {
5730 pub blend_enable: Bool32,
5731 pub src_color_blend_factor: BlendFactor,
5732 pub dst_color_blend_factor: BlendFactor,
5733 pub color_blend_op: BlendOp,
5734 pub src_alpha_blend_factor: BlendFactor,
5735 pub dst_alpha_blend_factor: BlendFactor,
5736 pub alpha_blend_op: BlendOp,
5737 pub color_write_mask: ColorComponentFlags,
5738}
5739impl PipelineColorBlendAttachmentState {
5740 pub fn builder<'a>() -> PipelineColorBlendAttachmentStateBuilder<'a> {
5741 PipelineColorBlendAttachmentStateBuilder {
5742 inner: Self::default(),
5743 marker: ::std::marker::PhantomData,
5744 }
5745 }
5746}
5747#[repr(transparent)]
5748pub struct PipelineColorBlendAttachmentStateBuilder<'a> {
5749 inner: PipelineColorBlendAttachmentState,
5750 marker: ::std::marker::PhantomData<&'a ()>,
5751}
5752impl<'a> ::std::ops::Deref for PipelineColorBlendAttachmentStateBuilder<'a> {
5753 type Target = PipelineColorBlendAttachmentState;
5754 fn deref(&self) -> &Self::Target {
5755 &self.inner
5756 }
5757}
5758impl<'a> ::std::ops::DerefMut for PipelineColorBlendAttachmentStateBuilder<'a> {
5759 fn deref_mut(&mut self) -> &mut Self::Target {
5760 &mut self.inner
5761 }
5762}
5763impl<'a> PipelineColorBlendAttachmentStateBuilder<'a> {
5764 pub fn blend_enable(mut self, blend_enable: bool) -> Self {
5765 self.inner.blend_enable = blend_enable.into();
5766 self
5767 }
5768 pub fn src_color_blend_factor(mut self, src_color_blend_factor: BlendFactor) -> Self {
5769 self.inner.src_color_blend_factor = src_color_blend_factor;
5770 self
5771 }
5772 pub fn dst_color_blend_factor(mut self, dst_color_blend_factor: BlendFactor) -> Self {
5773 self.inner.dst_color_blend_factor = dst_color_blend_factor;
5774 self
5775 }
5776 pub fn color_blend_op(mut self, color_blend_op: BlendOp) -> Self {
5777 self.inner.color_blend_op = color_blend_op;
5778 self
5779 }
5780 pub fn src_alpha_blend_factor(mut self, src_alpha_blend_factor: BlendFactor) -> Self {
5781 self.inner.src_alpha_blend_factor = src_alpha_blend_factor;
5782 self
5783 }
5784 pub fn dst_alpha_blend_factor(mut self, dst_alpha_blend_factor: BlendFactor) -> Self {
5785 self.inner.dst_alpha_blend_factor = dst_alpha_blend_factor;
5786 self
5787 }
5788 pub fn alpha_blend_op(mut self, alpha_blend_op: BlendOp) -> Self {
5789 self.inner.alpha_blend_op = alpha_blend_op;
5790 self
5791 }
5792 pub fn color_write_mask(mut self, color_write_mask: ColorComponentFlags) -> Self {
5793 self.inner.color_write_mask = color_write_mask;
5794 self
5795 }
5796 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5797 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5798 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
5799 pub fn build(self) -> PipelineColorBlendAttachmentState {
5800 self.inner
5801 }
5802}
5803#[repr(C)]
5804#[cfg_attr(feature = "debug", derive(Debug))]
5805#[derive(Copy, Clone)]
5806#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineColorBlendStateCreateInfo.html>"]
5807pub struct PipelineColorBlendStateCreateInfo {
5808 pub s_type: StructureType,
5809 pub p_next: *const c_void,
5810 pub flags: PipelineColorBlendStateCreateFlags,
5811 pub logic_op_enable: Bool32,
5812 pub logic_op: LogicOp,
5813 pub attachment_count: u32,
5814 pub p_attachments: *const PipelineColorBlendAttachmentState,
5815 pub blend_constants: [f32; 4],
5816}
5817impl ::std::default::Default for PipelineColorBlendStateCreateInfo {
5818 fn default() -> Self {
5819 Self {
5820 s_type: StructureType::PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
5821 p_next: ::std::ptr::null(),
5822 flags: PipelineColorBlendStateCreateFlags::default(),
5823 logic_op_enable: Bool32::default(),
5824 logic_op: LogicOp::default(),
5825 attachment_count: u32::default(),
5826 p_attachments: ::std::ptr::null(),
5827 blend_constants: unsafe { ::std::mem::zeroed() },
5828 }
5829 }
5830}
5831impl PipelineColorBlendStateCreateInfo {
5832 pub fn builder<'a>() -> PipelineColorBlendStateCreateInfoBuilder<'a> {
5833 PipelineColorBlendStateCreateInfoBuilder {
5834 inner: Self::default(),
5835 marker: ::std::marker::PhantomData,
5836 }
5837 }
5838}
5839#[repr(transparent)]
5840pub struct PipelineColorBlendStateCreateInfoBuilder<'a> {
5841 inner: PipelineColorBlendStateCreateInfo,
5842 marker: ::std::marker::PhantomData<&'a ()>,
5843}
5844pub unsafe trait ExtendsPipelineColorBlendStateCreateInfo {}
5845impl<'a> ::std::ops::Deref for PipelineColorBlendStateCreateInfoBuilder<'a> {
5846 type Target = PipelineColorBlendStateCreateInfo;
5847 fn deref(&self) -> &Self::Target {
5848 &self.inner
5849 }
5850}
5851impl<'a> ::std::ops::DerefMut for PipelineColorBlendStateCreateInfoBuilder<'a> {
5852 fn deref_mut(&mut self) -> &mut Self::Target {
5853 &mut self.inner
5854 }
5855}
5856impl<'a> PipelineColorBlendStateCreateInfoBuilder<'a> {
5857 pub fn flags(mut self, flags: PipelineColorBlendStateCreateFlags) -> Self {
5858 self.inner.flags = flags;
5859 self
5860 }
5861 pub fn logic_op_enable(mut self, logic_op_enable: bool) -> Self {
5862 self.inner.logic_op_enable = logic_op_enable.into();
5863 self
5864 }
5865 pub fn logic_op(mut self, logic_op: LogicOp) -> Self {
5866 self.inner.logic_op = logic_op;
5867 self
5868 }
5869 pub fn attachments(mut self, attachments: &'a [PipelineColorBlendAttachmentState]) -> Self {
5870 self.inner.attachment_count = attachments.len() as _;
5871 self.inner.p_attachments = attachments.as_ptr();
5872 self
5873 }
5874 pub fn blend_constants(mut self, blend_constants: [f32; 4]) -> Self {
5875 self.inner.blend_constants = blend_constants;
5876 self
5877 }
5878 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
5879 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
5880 #[doc = r" valid extension structs can be pushed into the chain."]
5881 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
5882 #[doc = r" chain will look like `A -> D -> B -> C`."]
5883 pub fn push_next<T: ExtendsPipelineColorBlendStateCreateInfo>(
5884 mut self,
5885 next: &'a mut T,
5886 ) -> Self {
5887 unsafe {
5888 let next_ptr = <*const T>::cast(next);
5889 let last_next = ptr_chain_iter(next).last().unwrap();
5890 (*last_next).p_next = self.inner.p_next as _;
5891 self.inner.p_next = next_ptr;
5892 }
5893 self
5894 }
5895 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5896 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5897 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
5898 pub fn build(self) -> PipelineColorBlendStateCreateInfo {
5899 self.inner
5900 }
5901}
5902#[repr(C)]
5903#[cfg_attr(feature = "debug", derive(Debug))]
5904#[derive(Copy, Clone)]
5905#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDynamicStateCreateInfo.html>"]
5906pub struct PipelineDynamicStateCreateInfo {
5907 pub s_type: StructureType,
5908 pub p_next: *const c_void,
5909 pub flags: PipelineDynamicStateCreateFlags,
5910 pub dynamic_state_count: u32,
5911 pub p_dynamic_states: *const DynamicState,
5912}
5913impl ::std::default::Default for PipelineDynamicStateCreateInfo {
5914 fn default() -> Self {
5915 Self {
5916 s_type: StructureType::PIPELINE_DYNAMIC_STATE_CREATE_INFO,
5917 p_next: ::std::ptr::null(),
5918 flags: PipelineDynamicStateCreateFlags::default(),
5919 dynamic_state_count: u32::default(),
5920 p_dynamic_states: ::std::ptr::null(),
5921 }
5922 }
5923}
5924impl PipelineDynamicStateCreateInfo {
5925 pub fn builder<'a>() -> PipelineDynamicStateCreateInfoBuilder<'a> {
5926 PipelineDynamicStateCreateInfoBuilder {
5927 inner: Self::default(),
5928 marker: ::std::marker::PhantomData,
5929 }
5930 }
5931}
5932#[repr(transparent)]
5933pub struct PipelineDynamicStateCreateInfoBuilder<'a> {
5934 inner: PipelineDynamicStateCreateInfo,
5935 marker: ::std::marker::PhantomData<&'a ()>,
5936}
5937impl<'a> ::std::ops::Deref for PipelineDynamicStateCreateInfoBuilder<'a> {
5938 type Target = PipelineDynamicStateCreateInfo;
5939 fn deref(&self) -> &Self::Target {
5940 &self.inner
5941 }
5942}
5943impl<'a> ::std::ops::DerefMut for PipelineDynamicStateCreateInfoBuilder<'a> {
5944 fn deref_mut(&mut self) -> &mut Self::Target {
5945 &mut self.inner
5946 }
5947}
5948impl<'a> PipelineDynamicStateCreateInfoBuilder<'a> {
5949 pub fn flags(mut self, flags: PipelineDynamicStateCreateFlags) -> Self {
5950 self.inner.flags = flags;
5951 self
5952 }
5953 pub fn dynamic_states(mut self, dynamic_states: &'a [DynamicState]) -> Self {
5954 self.inner.dynamic_state_count = dynamic_states.len() as _;
5955 self.inner.p_dynamic_states = dynamic_states.as_ptr();
5956 self
5957 }
5958 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5959 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5960 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
5961 pub fn build(self) -> PipelineDynamicStateCreateInfo {
5962 self.inner
5963 }
5964}
5965#[repr(C)]
5966#[cfg_attr(feature = "debug", derive(Debug))]
5967#[derive(Copy, Clone, Default)]
5968#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkStencilOpState.html>"]
5969pub struct StencilOpState {
5970 pub fail_op: StencilOp,
5971 pub pass_op: StencilOp,
5972 pub depth_fail_op: StencilOp,
5973 pub compare_op: CompareOp,
5974 pub compare_mask: u32,
5975 pub write_mask: u32,
5976 pub reference: u32,
5977}
5978impl StencilOpState {
5979 pub fn builder<'a>() -> StencilOpStateBuilder<'a> {
5980 StencilOpStateBuilder {
5981 inner: Self::default(),
5982 marker: ::std::marker::PhantomData,
5983 }
5984 }
5985}
5986#[repr(transparent)]
5987pub struct StencilOpStateBuilder<'a> {
5988 inner: StencilOpState,
5989 marker: ::std::marker::PhantomData<&'a ()>,
5990}
5991impl<'a> ::std::ops::Deref for StencilOpStateBuilder<'a> {
5992 type Target = StencilOpState;
5993 fn deref(&self) -> &Self::Target {
5994 &self.inner
5995 }
5996}
5997impl<'a> ::std::ops::DerefMut for StencilOpStateBuilder<'a> {
5998 fn deref_mut(&mut self) -> &mut Self::Target {
5999 &mut self.inner
6000 }
6001}
6002impl<'a> StencilOpStateBuilder<'a> {
6003 pub fn fail_op(mut self, fail_op: StencilOp) -> Self {
6004 self.inner.fail_op = fail_op;
6005 self
6006 }
6007 pub fn pass_op(mut self, pass_op: StencilOp) -> Self {
6008 self.inner.pass_op = pass_op;
6009 self
6010 }
6011 pub fn depth_fail_op(mut self, depth_fail_op: StencilOp) -> Self {
6012 self.inner.depth_fail_op = depth_fail_op;
6013 self
6014 }
6015 pub fn compare_op(mut self, compare_op: CompareOp) -> Self {
6016 self.inner.compare_op = compare_op;
6017 self
6018 }
6019 pub fn compare_mask(mut self, compare_mask: u32) -> Self {
6020 self.inner.compare_mask = compare_mask;
6021 self
6022 }
6023 pub fn write_mask(mut self, write_mask: u32) -> Self {
6024 self.inner.write_mask = write_mask;
6025 self
6026 }
6027 pub fn reference(mut self, reference: u32) -> Self {
6028 self.inner.reference = reference;
6029 self
6030 }
6031 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6032 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6033 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
6034 pub fn build(self) -> StencilOpState {
6035 self.inner
6036 }
6037}
6038#[repr(C)]
6039#[cfg_attr(feature = "debug", derive(Debug))]
6040#[derive(Copy, Clone)]
6041#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDepthStencilStateCreateInfo.html>"]
6042pub struct PipelineDepthStencilStateCreateInfo {
6043 pub s_type: StructureType,
6044 pub p_next: *const c_void,
6045 pub flags: PipelineDepthStencilStateCreateFlags,
6046 pub depth_test_enable: Bool32,
6047 pub depth_write_enable: Bool32,
6048 pub depth_compare_op: CompareOp,
6049 pub depth_bounds_test_enable: Bool32,
6050 pub stencil_test_enable: Bool32,
6051 pub front: StencilOpState,
6052 pub back: StencilOpState,
6053 pub min_depth_bounds: f32,
6054 pub max_depth_bounds: f32,
6055}
6056impl ::std::default::Default for PipelineDepthStencilStateCreateInfo {
6057 fn default() -> Self {
6058 Self {
6059 s_type: StructureType::PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
6060 p_next: ::std::ptr::null(),
6061 flags: PipelineDepthStencilStateCreateFlags::default(),
6062 depth_test_enable: Bool32::default(),
6063 depth_write_enable: Bool32::default(),
6064 depth_compare_op: CompareOp::default(),
6065 depth_bounds_test_enable: Bool32::default(),
6066 stencil_test_enable: Bool32::default(),
6067 front: StencilOpState::default(),
6068 back: StencilOpState::default(),
6069 min_depth_bounds: f32::default(),
6070 max_depth_bounds: f32::default(),
6071 }
6072 }
6073}
6074impl PipelineDepthStencilStateCreateInfo {
6075 pub fn builder<'a>() -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
6076 PipelineDepthStencilStateCreateInfoBuilder {
6077 inner: Self::default(),
6078 marker: ::std::marker::PhantomData,
6079 }
6080 }
6081}
6082#[repr(transparent)]
6083pub struct PipelineDepthStencilStateCreateInfoBuilder<'a> {
6084 inner: PipelineDepthStencilStateCreateInfo,
6085 marker: ::std::marker::PhantomData<&'a ()>,
6086}
6087impl<'a> ::std::ops::Deref for PipelineDepthStencilStateCreateInfoBuilder<'a> {
6088 type Target = PipelineDepthStencilStateCreateInfo;
6089 fn deref(&self) -> &Self::Target {
6090 &self.inner
6091 }
6092}
6093impl<'a> ::std::ops::DerefMut for PipelineDepthStencilStateCreateInfoBuilder<'a> {
6094 fn deref_mut(&mut self) -> &mut Self::Target {
6095 &mut self.inner
6096 }
6097}
6098impl<'a> PipelineDepthStencilStateCreateInfoBuilder<'a> {
6099 pub fn flags(mut self, flags: PipelineDepthStencilStateCreateFlags) -> Self {
6100 self.inner.flags = flags;
6101 self
6102 }
6103 pub fn depth_test_enable(mut self, depth_test_enable: bool) -> Self {
6104 self.inner.depth_test_enable = depth_test_enable.into();
6105 self
6106 }
6107 pub fn depth_write_enable(mut self, depth_write_enable: bool) -> Self {
6108 self.inner.depth_write_enable = depth_write_enable.into();
6109 self
6110 }
6111 pub fn depth_compare_op(mut self, depth_compare_op: CompareOp) -> Self {
6112 self.inner.depth_compare_op = depth_compare_op;
6113 self
6114 }
6115 pub fn depth_bounds_test_enable(mut self, depth_bounds_test_enable: bool) -> Self {
6116 self.inner.depth_bounds_test_enable = depth_bounds_test_enable.into();
6117 self
6118 }
6119 pub fn stencil_test_enable(mut self, stencil_test_enable: bool) -> Self {
6120 self.inner.stencil_test_enable = stencil_test_enable.into();
6121 self
6122 }
6123 pub fn front(mut self, front: StencilOpState) -> Self {
6124 self.inner.front = front;
6125 self
6126 }
6127 pub fn back(mut self, back: StencilOpState) -> Self {
6128 self.inner.back = back;
6129 self
6130 }
6131 pub fn min_depth_bounds(mut self, min_depth_bounds: f32) -> Self {
6132 self.inner.min_depth_bounds = min_depth_bounds;
6133 self
6134 }
6135 pub fn max_depth_bounds(mut self, max_depth_bounds: f32) -> Self {
6136 self.inner.max_depth_bounds = max_depth_bounds;
6137 self
6138 }
6139 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6140 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6141 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
6142 pub fn build(self) -> PipelineDepthStencilStateCreateInfo {
6143 self.inner
6144 }
6145}
6146#[repr(C)]
6147#[cfg_attr(feature = "debug", derive(Debug))]
6148#[derive(Copy, Clone)]
6149#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGraphicsPipelineCreateInfo.html>"]
6150pub struct GraphicsPipelineCreateInfo {
6151 pub s_type: StructureType,
6152 pub p_next: *const c_void,
6153 pub flags: PipelineCreateFlags,
6154 pub stage_count: u32,
6155 pub p_stages: *const PipelineShaderStageCreateInfo,
6156 pub p_vertex_input_state: *const PipelineVertexInputStateCreateInfo,
6157 pub p_input_assembly_state: *const PipelineInputAssemblyStateCreateInfo,
6158 pub p_tessellation_state: *const PipelineTessellationStateCreateInfo,
6159 pub p_viewport_state: *const PipelineViewportStateCreateInfo,
6160 pub p_rasterization_state: *const PipelineRasterizationStateCreateInfo,
6161 pub p_multisample_state: *const PipelineMultisampleStateCreateInfo,
6162 pub p_depth_stencil_state: *const PipelineDepthStencilStateCreateInfo,
6163 pub p_color_blend_state: *const PipelineColorBlendStateCreateInfo,
6164 pub p_dynamic_state: *const PipelineDynamicStateCreateInfo,
6165 pub layout: PipelineLayout,
6166 pub render_pass: RenderPass,
6167 pub subpass: u32,
6168 pub base_pipeline_handle: Pipeline,
6169 pub base_pipeline_index: i32,
6170}
6171impl ::std::default::Default for GraphicsPipelineCreateInfo {
6172 fn default() -> Self {
6173 Self {
6174 s_type: StructureType::GRAPHICS_PIPELINE_CREATE_INFO,
6175 p_next: ::std::ptr::null(),
6176 flags: PipelineCreateFlags::default(),
6177 stage_count: u32::default(),
6178 p_stages: ::std::ptr::null(),
6179 p_vertex_input_state: ::std::ptr::null(),
6180 p_input_assembly_state: ::std::ptr::null(),
6181 p_tessellation_state: ::std::ptr::null(),
6182 p_viewport_state: ::std::ptr::null(),
6183 p_rasterization_state: ::std::ptr::null(),
6184 p_multisample_state: ::std::ptr::null(),
6185 p_depth_stencil_state: ::std::ptr::null(),
6186 p_color_blend_state: ::std::ptr::null(),
6187 p_dynamic_state: ::std::ptr::null(),
6188 layout: PipelineLayout::default(),
6189 render_pass: RenderPass::default(),
6190 subpass: u32::default(),
6191 base_pipeline_handle: Pipeline::default(),
6192 base_pipeline_index: i32::default(),
6193 }
6194 }
6195}
6196impl GraphicsPipelineCreateInfo {
6197 pub fn builder<'a>() -> GraphicsPipelineCreateInfoBuilder<'a> {
6198 GraphicsPipelineCreateInfoBuilder {
6199 inner: Self::default(),
6200 marker: ::std::marker::PhantomData,
6201 }
6202 }
6203}
6204#[repr(transparent)]
6205pub struct GraphicsPipelineCreateInfoBuilder<'a> {
6206 inner: GraphicsPipelineCreateInfo,
6207 marker: ::std::marker::PhantomData<&'a ()>,
6208}
6209pub unsafe trait ExtendsGraphicsPipelineCreateInfo {}
6210impl<'a> ::std::ops::Deref for GraphicsPipelineCreateInfoBuilder<'a> {
6211 type Target = GraphicsPipelineCreateInfo;
6212 fn deref(&self) -> &Self::Target {
6213 &self.inner
6214 }
6215}
6216impl<'a> ::std::ops::DerefMut for GraphicsPipelineCreateInfoBuilder<'a> {
6217 fn deref_mut(&mut self) -> &mut Self::Target {
6218 &mut self.inner
6219 }
6220}
6221impl<'a> GraphicsPipelineCreateInfoBuilder<'a> {
6222 pub fn flags(mut self, flags: PipelineCreateFlags) -> Self {
6223 self.inner.flags = flags;
6224 self
6225 }
6226 pub fn stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self {
6227 self.inner.stage_count = stages.len() as _;
6228 self.inner.p_stages = stages.as_ptr();
6229 self
6230 }
6231 pub fn vertex_input_state(
6232 mut self,
6233 vertex_input_state: &'a PipelineVertexInputStateCreateInfo,
6234 ) -> Self {
6235 self.inner.p_vertex_input_state = vertex_input_state;
6236 self
6237 }
6238 pub fn input_assembly_state(
6239 mut self,
6240 input_assembly_state: &'a PipelineInputAssemblyStateCreateInfo,
6241 ) -> Self {
6242 self.inner.p_input_assembly_state = input_assembly_state;
6243 self
6244 }
6245 pub fn tessellation_state(
6246 mut self,
6247 tessellation_state: &'a PipelineTessellationStateCreateInfo,
6248 ) -> Self {
6249 self.inner.p_tessellation_state = tessellation_state;
6250 self
6251 }
6252 pub fn viewport_state(mut self, viewport_state: &'a PipelineViewportStateCreateInfo) -> Self {
6253 self.inner.p_viewport_state = viewport_state;
6254 self
6255 }
6256 pub fn rasterization_state(
6257 mut self,
6258 rasterization_state: &'a PipelineRasterizationStateCreateInfo,
6259 ) -> Self {
6260 self.inner.p_rasterization_state = rasterization_state;
6261 self
6262 }
6263 pub fn multisample_state(
6264 mut self,
6265 multisample_state: &'a PipelineMultisampleStateCreateInfo,
6266 ) -> Self {
6267 self.inner.p_multisample_state = multisample_state;
6268 self
6269 }
6270 pub fn depth_stencil_state(
6271 mut self,
6272 depth_stencil_state: &'a PipelineDepthStencilStateCreateInfo,
6273 ) -> Self {
6274 self.inner.p_depth_stencil_state = depth_stencil_state;
6275 self
6276 }
6277 pub fn color_blend_state(
6278 mut self,
6279 color_blend_state: &'a PipelineColorBlendStateCreateInfo,
6280 ) -> Self {
6281 self.inner.p_color_blend_state = color_blend_state;
6282 self
6283 }
6284 pub fn dynamic_state(mut self, dynamic_state: &'a PipelineDynamicStateCreateInfo) -> Self {
6285 self.inner.p_dynamic_state = dynamic_state;
6286 self
6287 }
6288 pub fn layout(mut self, layout: PipelineLayout) -> Self {
6289 self.inner.layout = layout;
6290 self
6291 }
6292 pub fn render_pass(mut self, render_pass: RenderPass) -> Self {
6293 self.inner.render_pass = render_pass;
6294 self
6295 }
6296 pub fn subpass(mut self, subpass: u32) -> Self {
6297 self.inner.subpass = subpass;
6298 self
6299 }
6300 pub fn base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self {
6301 self.inner.base_pipeline_handle = base_pipeline_handle;
6302 self
6303 }
6304 pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self {
6305 self.inner.base_pipeline_index = base_pipeline_index;
6306 self
6307 }
6308 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
6309 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
6310 #[doc = r" valid extension structs can be pushed into the chain."]
6311 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
6312 #[doc = r" chain will look like `A -> D -> B -> C`."]
6313 pub fn push_next<T: ExtendsGraphicsPipelineCreateInfo>(mut self, next: &'a mut T) -> Self {
6314 unsafe {
6315 let next_ptr = <*const T>::cast(next);
6316 let last_next = ptr_chain_iter(next).last().unwrap();
6317 (*last_next).p_next = self.inner.p_next as _;
6318 self.inner.p_next = next_ptr;
6319 }
6320 self
6321 }
6322 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6323 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6324 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
6325 pub fn build(self) -> GraphicsPipelineCreateInfo {
6326 self.inner
6327 }
6328}
6329#[repr(C)]
6330#[cfg_attr(feature = "debug", derive(Debug))]
6331#[derive(Copy, Clone)]
6332#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCacheCreateInfo.html>"]
6333pub struct PipelineCacheCreateInfo {
6334 pub s_type: StructureType,
6335 pub p_next: *const c_void,
6336 pub flags: PipelineCacheCreateFlags,
6337 pub initial_data_size: usize,
6338 pub p_initial_data: *const c_void,
6339}
6340impl ::std::default::Default for PipelineCacheCreateInfo {
6341 fn default() -> Self {
6342 Self {
6343 s_type: StructureType::PIPELINE_CACHE_CREATE_INFO,
6344 p_next: ::std::ptr::null(),
6345 flags: PipelineCacheCreateFlags::default(),
6346 initial_data_size: usize::default(),
6347 p_initial_data: ::std::ptr::null(),
6348 }
6349 }
6350}
6351impl PipelineCacheCreateInfo {
6352 pub fn builder<'a>() -> PipelineCacheCreateInfoBuilder<'a> {
6353 PipelineCacheCreateInfoBuilder {
6354 inner: Self::default(),
6355 marker: ::std::marker::PhantomData,
6356 }
6357 }
6358}
6359#[repr(transparent)]
6360pub struct PipelineCacheCreateInfoBuilder<'a> {
6361 inner: PipelineCacheCreateInfo,
6362 marker: ::std::marker::PhantomData<&'a ()>,
6363}
6364impl<'a> ::std::ops::Deref for PipelineCacheCreateInfoBuilder<'a> {
6365 type Target = PipelineCacheCreateInfo;
6366 fn deref(&self) -> &Self::Target {
6367 &self.inner
6368 }
6369}
6370impl<'a> ::std::ops::DerefMut for PipelineCacheCreateInfoBuilder<'a> {
6371 fn deref_mut(&mut self) -> &mut Self::Target {
6372 &mut self.inner
6373 }
6374}
6375impl<'a> PipelineCacheCreateInfoBuilder<'a> {
6376 pub fn flags(mut self, flags: PipelineCacheCreateFlags) -> Self {
6377 self.inner.flags = flags;
6378 self
6379 }
6380 pub fn initial_data(mut self, initial_data: &'a [u8]) -> Self {
6381 self.inner.initial_data_size = initial_data.len();
6382 self.inner.p_initial_data = initial_data.as_ptr() as *const c_void;
6383 self
6384 }
6385 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6386 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6387 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
6388 pub fn build(self) -> PipelineCacheCreateInfo {
6389 self.inner
6390 }
6391}
6392#[repr(C)]
6393#[cfg_attr(feature = "debug", derive(Debug))]
6394#[derive(Copy, Clone)]
6395#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCacheHeaderVersionOne.html>"]
6396pub struct PipelineCacheHeaderVersionOne {
6397 pub header_size: u32,
6398 pub header_version: PipelineCacheHeaderVersion,
6399 pub vendor_id: u32,
6400 pub device_id: u32,
6401 pub pipeline_cache_uuid: [u8; UUID_SIZE],
6402}
6403impl ::std::default::Default for PipelineCacheHeaderVersionOne {
6404 fn default() -> Self {
6405 Self {
6406 header_size: u32::default(),
6407 header_version: PipelineCacheHeaderVersion::default(),
6408 vendor_id: u32::default(),
6409 device_id: u32::default(),
6410 pipeline_cache_uuid: unsafe { ::std::mem::zeroed() },
6411 }
6412 }
6413}
6414impl PipelineCacheHeaderVersionOne {
6415 pub fn builder<'a>() -> PipelineCacheHeaderVersionOneBuilder<'a> {
6416 PipelineCacheHeaderVersionOneBuilder {
6417 inner: Self::default(),
6418 marker: ::std::marker::PhantomData,
6419 }
6420 }
6421}
6422#[repr(transparent)]
6423pub struct PipelineCacheHeaderVersionOneBuilder<'a> {
6424 inner: PipelineCacheHeaderVersionOne,
6425 marker: ::std::marker::PhantomData<&'a ()>,
6426}
6427impl<'a> ::std::ops::Deref for PipelineCacheHeaderVersionOneBuilder<'a> {
6428 type Target = PipelineCacheHeaderVersionOne;
6429 fn deref(&self) -> &Self::Target {
6430 &self.inner
6431 }
6432}
6433impl<'a> ::std::ops::DerefMut for PipelineCacheHeaderVersionOneBuilder<'a> {
6434 fn deref_mut(&mut self) -> &mut Self::Target {
6435 &mut self.inner
6436 }
6437}
6438impl<'a> PipelineCacheHeaderVersionOneBuilder<'a> {
6439 pub fn header_size(mut self, header_size: u32) -> Self {
6440 self.inner.header_size = header_size;
6441 self
6442 }
6443 pub fn header_version(mut self, header_version: PipelineCacheHeaderVersion) -> Self {
6444 self.inner.header_version = header_version;
6445 self
6446 }
6447 pub fn vendor_id(mut self, vendor_id: u32) -> Self {
6448 self.inner.vendor_id = vendor_id;
6449 self
6450 }
6451 pub fn device_id(mut self, device_id: u32) -> Self {
6452 self.inner.device_id = device_id;
6453 self
6454 }
6455 pub fn pipeline_cache_uuid(mut self, pipeline_cache_uuid: [u8; UUID_SIZE]) -> Self {
6456 self.inner.pipeline_cache_uuid = pipeline_cache_uuid;
6457 self
6458 }
6459 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6460 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6461 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
6462 pub fn build(self) -> PipelineCacheHeaderVersionOne {
6463 self.inner
6464 }
6465}
6466#[repr(C)]
6467#[cfg_attr(feature = "debug", derive(Debug))]
6468#[derive(Copy, Clone, Default)]
6469#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPushConstantRange.html>"]
6470pub struct PushConstantRange {
6471 pub stage_flags: ShaderStageFlags,
6472 pub offset: u32,
6473 pub size: u32,
6474}
6475impl PushConstantRange {
6476 pub fn builder<'a>() -> PushConstantRangeBuilder<'a> {
6477 PushConstantRangeBuilder {
6478 inner: Self::default(),
6479 marker: ::std::marker::PhantomData,
6480 }
6481 }
6482}
6483#[repr(transparent)]
6484pub struct PushConstantRangeBuilder<'a> {
6485 inner: PushConstantRange,
6486 marker: ::std::marker::PhantomData<&'a ()>,
6487}
6488impl<'a> ::std::ops::Deref for PushConstantRangeBuilder<'a> {
6489 type Target = PushConstantRange;
6490 fn deref(&self) -> &Self::Target {
6491 &self.inner
6492 }
6493}
6494impl<'a> ::std::ops::DerefMut for PushConstantRangeBuilder<'a> {
6495 fn deref_mut(&mut self) -> &mut Self::Target {
6496 &mut self.inner
6497 }
6498}
6499impl<'a> PushConstantRangeBuilder<'a> {
6500 pub fn stage_flags(mut self, stage_flags: ShaderStageFlags) -> Self {
6501 self.inner.stage_flags = stage_flags;
6502 self
6503 }
6504 pub fn offset(mut self, offset: u32) -> Self {
6505 self.inner.offset = offset;
6506 self
6507 }
6508 pub fn size(mut self, size: u32) -> Self {
6509 self.inner.size = size;
6510 self
6511 }
6512 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6513 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6514 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
6515 pub fn build(self) -> PushConstantRange {
6516 self.inner
6517 }
6518}
6519#[repr(C)]
6520#[cfg_attr(feature = "debug", derive(Debug))]
6521#[derive(Copy, Clone)]
6522#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineLayoutCreateInfo.html>"]
6523pub struct PipelineLayoutCreateInfo {
6524 pub s_type: StructureType,
6525 pub p_next: *const c_void,
6526 pub flags: PipelineLayoutCreateFlags,
6527 pub set_layout_count: u32,
6528 pub p_set_layouts: *const DescriptorSetLayout,
6529 pub push_constant_range_count: u32,
6530 pub p_push_constant_ranges: *const PushConstantRange,
6531}
6532impl ::std::default::Default for PipelineLayoutCreateInfo {
6533 fn default() -> Self {
6534 Self {
6535 s_type: StructureType::PIPELINE_LAYOUT_CREATE_INFO,
6536 p_next: ::std::ptr::null(),
6537 flags: PipelineLayoutCreateFlags::default(),
6538 set_layout_count: u32::default(),
6539 p_set_layouts: ::std::ptr::null(),
6540 push_constant_range_count: u32::default(),
6541 p_push_constant_ranges: ::std::ptr::null(),
6542 }
6543 }
6544}
6545impl PipelineLayoutCreateInfo {
6546 pub fn builder<'a>() -> PipelineLayoutCreateInfoBuilder<'a> {
6547 PipelineLayoutCreateInfoBuilder {
6548 inner: Self::default(),
6549 marker: ::std::marker::PhantomData,
6550 }
6551 }
6552}
6553#[repr(transparent)]
6554pub struct PipelineLayoutCreateInfoBuilder<'a> {
6555 inner: PipelineLayoutCreateInfo,
6556 marker: ::std::marker::PhantomData<&'a ()>,
6557}
6558impl<'a> ::std::ops::Deref for PipelineLayoutCreateInfoBuilder<'a> {
6559 type Target = PipelineLayoutCreateInfo;
6560 fn deref(&self) -> &Self::Target {
6561 &self.inner
6562 }
6563}
6564impl<'a> ::std::ops::DerefMut for PipelineLayoutCreateInfoBuilder<'a> {
6565 fn deref_mut(&mut self) -> &mut Self::Target {
6566 &mut self.inner
6567 }
6568}
6569impl<'a> PipelineLayoutCreateInfoBuilder<'a> {
6570 pub fn flags(mut self, flags: PipelineLayoutCreateFlags) -> Self {
6571 self.inner.flags = flags;
6572 self
6573 }
6574 pub fn set_layouts(mut self, set_layouts: &'a [DescriptorSetLayout]) -> Self {
6575 self.inner.set_layout_count = set_layouts.len() as _;
6576 self.inner.p_set_layouts = set_layouts.as_ptr();
6577 self
6578 }
6579 pub fn push_constant_ranges(mut self, push_constant_ranges: &'a [PushConstantRange]) -> Self {
6580 self.inner.push_constant_range_count = push_constant_ranges.len() as _;
6581 self.inner.p_push_constant_ranges = push_constant_ranges.as_ptr();
6582 self
6583 }
6584 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6585 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6586 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
6587 pub fn build(self) -> PipelineLayoutCreateInfo {
6588 self.inner
6589 }
6590}
6591#[repr(C)]
6592#[cfg_attr(feature = "debug", derive(Debug))]
6593#[derive(Copy, Clone)]
6594#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerCreateInfo.html>"]
6595pub struct SamplerCreateInfo {
6596 pub s_type: StructureType,
6597 pub p_next: *const c_void,
6598 pub flags: SamplerCreateFlags,
6599 pub mag_filter: Filter,
6600 pub min_filter: Filter,
6601 pub mipmap_mode: SamplerMipmapMode,
6602 pub address_mode_u: SamplerAddressMode,
6603 pub address_mode_v: SamplerAddressMode,
6604 pub address_mode_w: SamplerAddressMode,
6605 pub mip_lod_bias: f32,
6606 pub anisotropy_enable: Bool32,
6607 pub max_anisotropy: f32,
6608 pub compare_enable: Bool32,
6609 pub compare_op: CompareOp,
6610 pub min_lod: f32,
6611 pub max_lod: f32,
6612 pub border_color: BorderColor,
6613 pub unnormalized_coordinates: Bool32,
6614}
6615impl ::std::default::Default for SamplerCreateInfo {
6616 fn default() -> Self {
6617 Self {
6618 s_type: StructureType::SAMPLER_CREATE_INFO,
6619 p_next: ::std::ptr::null(),
6620 flags: SamplerCreateFlags::default(),
6621 mag_filter: Filter::default(),
6622 min_filter: Filter::default(),
6623 mipmap_mode: SamplerMipmapMode::default(),
6624 address_mode_u: SamplerAddressMode::default(),
6625 address_mode_v: SamplerAddressMode::default(),
6626 address_mode_w: SamplerAddressMode::default(),
6627 mip_lod_bias: f32::default(),
6628 anisotropy_enable: Bool32::default(),
6629 max_anisotropy: f32::default(),
6630 compare_enable: Bool32::default(),
6631 compare_op: CompareOp::default(),
6632 min_lod: f32::default(),
6633 max_lod: f32::default(),
6634 border_color: BorderColor::default(),
6635 unnormalized_coordinates: Bool32::default(),
6636 }
6637 }
6638}
6639impl SamplerCreateInfo {
6640 pub fn builder<'a>() -> SamplerCreateInfoBuilder<'a> {
6641 SamplerCreateInfoBuilder {
6642 inner: Self::default(),
6643 marker: ::std::marker::PhantomData,
6644 }
6645 }
6646}
6647#[repr(transparent)]
6648pub struct SamplerCreateInfoBuilder<'a> {
6649 inner: SamplerCreateInfo,
6650 marker: ::std::marker::PhantomData<&'a ()>,
6651}
6652pub unsafe trait ExtendsSamplerCreateInfo {}
6653impl<'a> ::std::ops::Deref for SamplerCreateInfoBuilder<'a> {
6654 type Target = SamplerCreateInfo;
6655 fn deref(&self) -> &Self::Target {
6656 &self.inner
6657 }
6658}
6659impl<'a> ::std::ops::DerefMut for SamplerCreateInfoBuilder<'a> {
6660 fn deref_mut(&mut self) -> &mut Self::Target {
6661 &mut self.inner
6662 }
6663}
6664impl<'a> SamplerCreateInfoBuilder<'a> {
6665 pub fn flags(mut self, flags: SamplerCreateFlags) -> Self {
6666 self.inner.flags = flags;
6667 self
6668 }
6669 pub fn mag_filter(mut self, mag_filter: Filter) -> Self {
6670 self.inner.mag_filter = mag_filter;
6671 self
6672 }
6673 pub fn min_filter(mut self, min_filter: Filter) -> Self {
6674 self.inner.min_filter = min_filter;
6675 self
6676 }
6677 pub fn mipmap_mode(mut self, mipmap_mode: SamplerMipmapMode) -> Self {
6678 self.inner.mipmap_mode = mipmap_mode;
6679 self
6680 }
6681 pub fn address_mode_u(mut self, address_mode_u: SamplerAddressMode) -> Self {
6682 self.inner.address_mode_u = address_mode_u;
6683 self
6684 }
6685 pub fn address_mode_v(mut self, address_mode_v: SamplerAddressMode) -> Self {
6686 self.inner.address_mode_v = address_mode_v;
6687 self
6688 }
6689 pub fn address_mode_w(mut self, address_mode_w: SamplerAddressMode) -> Self {
6690 self.inner.address_mode_w = address_mode_w;
6691 self
6692 }
6693 pub fn mip_lod_bias(mut self, mip_lod_bias: f32) -> Self {
6694 self.inner.mip_lod_bias = mip_lod_bias;
6695 self
6696 }
6697 pub fn anisotropy_enable(mut self, anisotropy_enable: bool) -> Self {
6698 self.inner.anisotropy_enable = anisotropy_enable.into();
6699 self
6700 }
6701 pub fn max_anisotropy(mut self, max_anisotropy: f32) -> Self {
6702 self.inner.max_anisotropy = max_anisotropy;
6703 self
6704 }
6705 pub fn compare_enable(mut self, compare_enable: bool) -> Self {
6706 self.inner.compare_enable = compare_enable.into();
6707 self
6708 }
6709 pub fn compare_op(mut self, compare_op: CompareOp) -> Self {
6710 self.inner.compare_op = compare_op;
6711 self
6712 }
6713 pub fn min_lod(mut self, min_lod: f32) -> Self {
6714 self.inner.min_lod = min_lod;
6715 self
6716 }
6717 pub fn max_lod(mut self, max_lod: f32) -> Self {
6718 self.inner.max_lod = max_lod;
6719 self
6720 }
6721 pub fn border_color(mut self, border_color: BorderColor) -> Self {
6722 self.inner.border_color = border_color;
6723 self
6724 }
6725 pub fn unnormalized_coordinates(mut self, unnormalized_coordinates: bool) -> Self {
6726 self.inner.unnormalized_coordinates = unnormalized_coordinates.into();
6727 self
6728 }
6729 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
6730 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
6731 #[doc = r" valid extension structs can be pushed into the chain."]
6732 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
6733 #[doc = r" chain will look like `A -> D -> B -> C`."]
6734 pub fn push_next<T: ExtendsSamplerCreateInfo>(mut self, next: &'a mut T) -> Self {
6735 unsafe {
6736 let next_ptr = <*const T>::cast(next);
6737 let last_next = ptr_chain_iter(next).last().unwrap();
6738 (*last_next).p_next = self.inner.p_next as _;
6739 self.inner.p_next = next_ptr;
6740 }
6741 self
6742 }
6743 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6744 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6745 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
6746 pub fn build(self) -> SamplerCreateInfo {
6747 self.inner
6748 }
6749}
6750#[repr(C)]
6751#[cfg_attr(feature = "debug", derive(Debug))]
6752#[derive(Copy, Clone)]
6753#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandPoolCreateInfo.html>"]
6754pub struct CommandPoolCreateInfo {
6755 pub s_type: StructureType,
6756 pub p_next: *const c_void,
6757 pub flags: CommandPoolCreateFlags,
6758 pub queue_family_index: u32,
6759}
6760impl ::std::default::Default for CommandPoolCreateInfo {
6761 fn default() -> Self {
6762 Self {
6763 s_type: StructureType::COMMAND_POOL_CREATE_INFO,
6764 p_next: ::std::ptr::null(),
6765 flags: CommandPoolCreateFlags::default(),
6766 queue_family_index: u32::default(),
6767 }
6768 }
6769}
6770impl CommandPoolCreateInfo {
6771 pub fn builder<'a>() -> CommandPoolCreateInfoBuilder<'a> {
6772 CommandPoolCreateInfoBuilder {
6773 inner: Self::default(),
6774 marker: ::std::marker::PhantomData,
6775 }
6776 }
6777}
6778#[repr(transparent)]
6779pub struct CommandPoolCreateInfoBuilder<'a> {
6780 inner: CommandPoolCreateInfo,
6781 marker: ::std::marker::PhantomData<&'a ()>,
6782}
6783impl<'a> ::std::ops::Deref for CommandPoolCreateInfoBuilder<'a> {
6784 type Target = CommandPoolCreateInfo;
6785 fn deref(&self) -> &Self::Target {
6786 &self.inner
6787 }
6788}
6789impl<'a> ::std::ops::DerefMut for CommandPoolCreateInfoBuilder<'a> {
6790 fn deref_mut(&mut self) -> &mut Self::Target {
6791 &mut self.inner
6792 }
6793}
6794impl<'a> CommandPoolCreateInfoBuilder<'a> {
6795 pub fn flags(mut self, flags: CommandPoolCreateFlags) -> Self {
6796 self.inner.flags = flags;
6797 self
6798 }
6799 pub fn queue_family_index(mut self, queue_family_index: u32) -> Self {
6800 self.inner.queue_family_index = queue_family_index;
6801 self
6802 }
6803 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6804 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6805 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
6806 pub fn build(self) -> CommandPoolCreateInfo {
6807 self.inner
6808 }
6809}
6810#[repr(C)]
6811#[cfg_attr(feature = "debug", derive(Debug))]
6812#[derive(Copy, Clone)]
6813#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferAllocateInfo.html>"]
6814pub struct CommandBufferAllocateInfo {
6815 pub s_type: StructureType,
6816 pub p_next: *const c_void,
6817 pub command_pool: CommandPool,
6818 pub level: CommandBufferLevel,
6819 pub command_buffer_count: u32,
6820}
6821impl ::std::default::Default for CommandBufferAllocateInfo {
6822 fn default() -> Self {
6823 Self {
6824 s_type: StructureType::COMMAND_BUFFER_ALLOCATE_INFO,
6825 p_next: ::std::ptr::null(),
6826 command_pool: CommandPool::default(),
6827 level: CommandBufferLevel::default(),
6828 command_buffer_count: u32::default(),
6829 }
6830 }
6831}
6832impl CommandBufferAllocateInfo {
6833 pub fn builder<'a>() -> CommandBufferAllocateInfoBuilder<'a> {
6834 CommandBufferAllocateInfoBuilder {
6835 inner: Self::default(),
6836 marker: ::std::marker::PhantomData,
6837 }
6838 }
6839}
6840#[repr(transparent)]
6841pub struct CommandBufferAllocateInfoBuilder<'a> {
6842 inner: CommandBufferAllocateInfo,
6843 marker: ::std::marker::PhantomData<&'a ()>,
6844}
6845impl<'a> ::std::ops::Deref for CommandBufferAllocateInfoBuilder<'a> {
6846 type Target = CommandBufferAllocateInfo;
6847 fn deref(&self) -> &Self::Target {
6848 &self.inner
6849 }
6850}
6851impl<'a> ::std::ops::DerefMut for CommandBufferAllocateInfoBuilder<'a> {
6852 fn deref_mut(&mut self) -> &mut Self::Target {
6853 &mut self.inner
6854 }
6855}
6856impl<'a> CommandBufferAllocateInfoBuilder<'a> {
6857 pub fn command_pool(mut self, command_pool: CommandPool) -> Self {
6858 self.inner.command_pool = command_pool;
6859 self
6860 }
6861 pub fn level(mut self, level: CommandBufferLevel) -> Self {
6862 self.inner.level = level;
6863 self
6864 }
6865 pub fn command_buffer_count(mut self, command_buffer_count: u32) -> Self {
6866 self.inner.command_buffer_count = command_buffer_count;
6867 self
6868 }
6869 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6870 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6871 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
6872 pub fn build(self) -> CommandBufferAllocateInfo {
6873 self.inner
6874 }
6875}
6876#[repr(C)]
6877#[cfg_attr(feature = "debug", derive(Debug))]
6878#[derive(Copy, Clone)]
6879#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferInheritanceInfo.html>"]
6880pub struct CommandBufferInheritanceInfo {
6881 pub s_type: StructureType,
6882 pub p_next: *const c_void,
6883 pub render_pass: RenderPass,
6884 pub subpass: u32,
6885 pub framebuffer: Framebuffer,
6886 pub occlusion_query_enable: Bool32,
6887 pub query_flags: QueryControlFlags,
6888 pub pipeline_statistics: QueryPipelineStatisticFlags,
6889}
6890impl ::std::default::Default for CommandBufferInheritanceInfo {
6891 fn default() -> Self {
6892 Self {
6893 s_type: StructureType::COMMAND_BUFFER_INHERITANCE_INFO,
6894 p_next: ::std::ptr::null(),
6895 render_pass: RenderPass::default(),
6896 subpass: u32::default(),
6897 framebuffer: Framebuffer::default(),
6898 occlusion_query_enable: Bool32::default(),
6899 query_flags: QueryControlFlags::default(),
6900 pipeline_statistics: QueryPipelineStatisticFlags::default(),
6901 }
6902 }
6903}
6904impl CommandBufferInheritanceInfo {
6905 pub fn builder<'a>() -> CommandBufferInheritanceInfoBuilder<'a> {
6906 CommandBufferInheritanceInfoBuilder {
6907 inner: Self::default(),
6908 marker: ::std::marker::PhantomData,
6909 }
6910 }
6911}
6912#[repr(transparent)]
6913pub struct CommandBufferInheritanceInfoBuilder<'a> {
6914 inner: CommandBufferInheritanceInfo,
6915 marker: ::std::marker::PhantomData<&'a ()>,
6916}
6917pub unsafe trait ExtendsCommandBufferInheritanceInfo {}
6918impl<'a> ::std::ops::Deref for CommandBufferInheritanceInfoBuilder<'a> {
6919 type Target = CommandBufferInheritanceInfo;
6920 fn deref(&self) -> &Self::Target {
6921 &self.inner
6922 }
6923}
6924impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceInfoBuilder<'a> {
6925 fn deref_mut(&mut self) -> &mut Self::Target {
6926 &mut self.inner
6927 }
6928}
6929impl<'a> CommandBufferInheritanceInfoBuilder<'a> {
6930 pub fn render_pass(mut self, render_pass: RenderPass) -> Self {
6931 self.inner.render_pass = render_pass;
6932 self
6933 }
6934 pub fn subpass(mut self, subpass: u32) -> Self {
6935 self.inner.subpass = subpass;
6936 self
6937 }
6938 pub fn framebuffer(mut self, framebuffer: Framebuffer) -> Self {
6939 self.inner.framebuffer = framebuffer;
6940 self
6941 }
6942 pub fn occlusion_query_enable(mut self, occlusion_query_enable: bool) -> Self {
6943 self.inner.occlusion_query_enable = occlusion_query_enable.into();
6944 self
6945 }
6946 pub fn query_flags(mut self, query_flags: QueryControlFlags) -> Self {
6947 self.inner.query_flags = query_flags;
6948 self
6949 }
6950 pub fn pipeline_statistics(mut self, pipeline_statistics: QueryPipelineStatisticFlags) -> Self {
6951 self.inner.pipeline_statistics = pipeline_statistics;
6952 self
6953 }
6954 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
6955 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
6956 #[doc = r" valid extension structs can be pushed into the chain."]
6957 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
6958 #[doc = r" chain will look like `A -> D -> B -> C`."]
6959 pub fn push_next<T: ExtendsCommandBufferInheritanceInfo>(mut self, next: &'a mut T) -> Self {
6960 unsafe {
6961 let next_ptr = <*const T>::cast(next);
6962 let last_next = ptr_chain_iter(next).last().unwrap();
6963 (*last_next).p_next = self.inner.p_next as _;
6964 self.inner.p_next = next_ptr;
6965 }
6966 self
6967 }
6968 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6969 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6970 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
6971 pub fn build(self) -> CommandBufferInheritanceInfo {
6972 self.inner
6973 }
6974}
6975#[repr(C)]
6976#[cfg_attr(feature = "debug", derive(Debug))]
6977#[derive(Copy, Clone)]
6978#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferBeginInfo.html>"]
6979pub struct CommandBufferBeginInfo {
6980 pub s_type: StructureType,
6981 pub p_next: *const c_void,
6982 pub flags: CommandBufferUsageFlags,
6983 pub p_inheritance_info: *const CommandBufferInheritanceInfo,
6984}
6985impl ::std::default::Default for CommandBufferBeginInfo {
6986 fn default() -> Self {
6987 Self {
6988 s_type: StructureType::COMMAND_BUFFER_BEGIN_INFO,
6989 p_next: ::std::ptr::null(),
6990 flags: CommandBufferUsageFlags::default(),
6991 p_inheritance_info: ::std::ptr::null(),
6992 }
6993 }
6994}
6995impl CommandBufferBeginInfo {
6996 pub fn builder<'a>() -> CommandBufferBeginInfoBuilder<'a> {
6997 CommandBufferBeginInfoBuilder {
6998 inner: Self::default(),
6999 marker: ::std::marker::PhantomData,
7000 }
7001 }
7002}
7003#[repr(transparent)]
7004pub struct CommandBufferBeginInfoBuilder<'a> {
7005 inner: CommandBufferBeginInfo,
7006 marker: ::std::marker::PhantomData<&'a ()>,
7007}
7008pub unsafe trait ExtendsCommandBufferBeginInfo {}
7009impl<'a> ::std::ops::Deref for CommandBufferBeginInfoBuilder<'a> {
7010 type Target = CommandBufferBeginInfo;
7011 fn deref(&self) -> &Self::Target {
7012 &self.inner
7013 }
7014}
7015impl<'a> ::std::ops::DerefMut for CommandBufferBeginInfoBuilder<'a> {
7016 fn deref_mut(&mut self) -> &mut Self::Target {
7017 &mut self.inner
7018 }
7019}
7020impl<'a> CommandBufferBeginInfoBuilder<'a> {
7021 pub fn flags(mut self, flags: CommandBufferUsageFlags) -> Self {
7022 self.inner.flags = flags;
7023 self
7024 }
7025 pub fn inheritance_info(mut self, inheritance_info: &'a CommandBufferInheritanceInfo) -> Self {
7026 self.inner.p_inheritance_info = inheritance_info;
7027 self
7028 }
7029 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
7030 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
7031 #[doc = r" valid extension structs can be pushed into the chain."]
7032 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
7033 #[doc = r" chain will look like `A -> D -> B -> C`."]
7034 pub fn push_next<T: ExtendsCommandBufferBeginInfo>(mut self, next: &'a mut T) -> Self {
7035 unsafe {
7036 let next_ptr = <*const T>::cast(next);
7037 let last_next = ptr_chain_iter(next).last().unwrap();
7038 (*last_next).p_next = self.inner.p_next as _;
7039 self.inner.p_next = next_ptr;
7040 }
7041 self
7042 }
7043 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7044 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7045 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
7046 pub fn build(self) -> CommandBufferBeginInfo {
7047 self.inner
7048 }
7049}
7050#[repr(C)]
7051#[derive(Copy, Clone)]
7052#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassBeginInfo.html>"]
7053pub struct RenderPassBeginInfo {
7054 pub s_type: StructureType,
7055 pub p_next: *const c_void,
7056 pub render_pass: RenderPass,
7057 pub framebuffer: Framebuffer,
7058 pub render_area: Rect2D,
7059 pub clear_value_count: u32,
7060 pub p_clear_values: *const ClearValue,
7061}
7062#[cfg(feature = "debug")]
7063impl fmt::Debug for RenderPassBeginInfo {
7064 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
7065 fmt.debug_struct("RenderPassBeginInfo")
7066 .field("s_type", &self.s_type)
7067 .field("p_next", &self.p_next)
7068 .field("render_pass", &self.render_pass)
7069 .field("framebuffer", &self.framebuffer)
7070 .field("render_area", &self.render_area)
7071 .field("clear_value_count", &self.clear_value_count)
7072 .field("p_clear_values", &"union")
7073 .finish()
7074 }
7075}
7076impl ::std::default::Default for RenderPassBeginInfo {
7077 fn default() -> Self {
7078 Self {
7079 s_type: StructureType::RENDER_PASS_BEGIN_INFO,
7080 p_next: ::std::ptr::null(),
7081 render_pass: RenderPass::default(),
7082 framebuffer: Framebuffer::default(),
7083 render_area: Rect2D::default(),
7084 clear_value_count: u32::default(),
7085 p_clear_values: ::std::ptr::null(),
7086 }
7087 }
7088}
7089impl RenderPassBeginInfo {
7090 pub fn builder<'a>() -> RenderPassBeginInfoBuilder<'a> {
7091 RenderPassBeginInfoBuilder {
7092 inner: Self::default(),
7093 marker: ::std::marker::PhantomData,
7094 }
7095 }
7096}
7097#[repr(transparent)]
7098pub struct RenderPassBeginInfoBuilder<'a> {
7099 inner: RenderPassBeginInfo,
7100 marker: ::std::marker::PhantomData<&'a ()>,
7101}
7102pub unsafe trait ExtendsRenderPassBeginInfo {}
7103impl<'a> ::std::ops::Deref for RenderPassBeginInfoBuilder<'a> {
7104 type Target = RenderPassBeginInfo;
7105 fn deref(&self) -> &Self::Target {
7106 &self.inner
7107 }
7108}
7109impl<'a> ::std::ops::DerefMut for RenderPassBeginInfoBuilder<'a> {
7110 fn deref_mut(&mut self) -> &mut Self::Target {
7111 &mut self.inner
7112 }
7113}
7114impl<'a> RenderPassBeginInfoBuilder<'a> {
7115 pub fn render_pass(mut self, render_pass: RenderPass) -> Self {
7116 self.inner.render_pass = render_pass;
7117 self
7118 }
7119 pub fn framebuffer(mut self, framebuffer: Framebuffer) -> Self {
7120 self.inner.framebuffer = framebuffer;
7121 self
7122 }
7123 pub fn render_area(mut self, render_area: Rect2D) -> Self {
7124 self.inner.render_area = render_area;
7125 self
7126 }
7127 pub fn clear_values(mut self, clear_values: &'a [ClearValue]) -> Self {
7128 self.inner.clear_value_count = clear_values.len() as _;
7129 self.inner.p_clear_values = clear_values.as_ptr();
7130 self
7131 }
7132 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
7133 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
7134 #[doc = r" valid extension structs can be pushed into the chain."]
7135 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
7136 #[doc = r" chain will look like `A -> D -> B -> C`."]
7137 pub fn push_next<T: ExtendsRenderPassBeginInfo>(mut self, next: &'a mut T) -> Self {
7138 unsafe {
7139 let next_ptr = <*const T>::cast(next);
7140 let last_next = ptr_chain_iter(next).last().unwrap();
7141 (*last_next).p_next = self.inner.p_next as _;
7142 self.inner.p_next = next_ptr;
7143 }
7144 self
7145 }
7146 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7147 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7148 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
7149 pub fn build(self) -> RenderPassBeginInfo {
7150 self.inner
7151 }
7152}
7153#[repr(C)]
7154#[derive(Copy, Clone)]
7155#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkClearColorValue.html>"]
7156pub union ClearColorValue {
7157 pub float32: [f32; 4],
7158 pub int32: [i32; 4],
7159 pub uint32: [u32; 4],
7160}
7161impl ::std::default::Default for ClearColorValue {
7162 fn default() -> Self {
7163 unsafe { ::std::mem::zeroed() }
7164 }
7165}
7166#[repr(C)]
7167#[cfg_attr(feature = "debug", derive(Debug))]
7168#[derive(Copy, Clone, Default)]
7169#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkClearDepthStencilValue.html>"]
7170pub struct ClearDepthStencilValue {
7171 pub depth: f32,
7172 pub stencil: u32,
7173}
7174impl ClearDepthStencilValue {
7175 pub fn builder<'a>() -> ClearDepthStencilValueBuilder<'a> {
7176 ClearDepthStencilValueBuilder {
7177 inner: Self::default(),
7178 marker: ::std::marker::PhantomData,
7179 }
7180 }
7181}
7182#[repr(transparent)]
7183pub struct ClearDepthStencilValueBuilder<'a> {
7184 inner: ClearDepthStencilValue,
7185 marker: ::std::marker::PhantomData<&'a ()>,
7186}
7187impl<'a> ::std::ops::Deref for ClearDepthStencilValueBuilder<'a> {
7188 type Target = ClearDepthStencilValue;
7189 fn deref(&self) -> &Self::Target {
7190 &self.inner
7191 }
7192}
7193impl<'a> ::std::ops::DerefMut for ClearDepthStencilValueBuilder<'a> {
7194 fn deref_mut(&mut self) -> &mut Self::Target {
7195 &mut self.inner
7196 }
7197}
7198impl<'a> ClearDepthStencilValueBuilder<'a> {
7199 pub fn depth(mut self, depth: f32) -> Self {
7200 self.inner.depth = depth;
7201 self
7202 }
7203 pub fn stencil(mut self, stencil: u32) -> Self {
7204 self.inner.stencil = stencil;
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."]
7210 pub fn build(self) -> ClearDepthStencilValue {
7211 self.inner
7212 }
7213}
7214#[repr(C)]
7215#[derive(Copy, Clone)]
7216#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkClearValue.html>"]
7217pub union ClearValue {
7218 pub color: ClearColorValue,
7219 pub depth_stencil: ClearDepthStencilValue,
7220}
7221impl ::std::default::Default for ClearValue {
7222 fn default() -> Self {
7223 unsafe { ::std::mem::zeroed() }
7224 }
7225}
7226#[repr(C)]
7227#[derive(Copy, Clone, Default)]
7228#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkClearAttachment.html>"]
7229pub struct ClearAttachment {
7230 pub aspect_mask: ImageAspectFlags,
7231 pub color_attachment: u32,
7232 pub clear_value: ClearValue,
7233}
7234#[cfg(feature = "debug")]
7235impl fmt::Debug for ClearAttachment {
7236 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
7237 fmt.debug_struct("ClearAttachment")
7238 .field("aspect_mask", &self.aspect_mask)
7239 .field("color_attachment", &self.color_attachment)
7240 .field("clear_value", &"union")
7241 .finish()
7242 }
7243}
7244impl ClearAttachment {
7245 pub fn builder<'a>() -> ClearAttachmentBuilder<'a> {
7246 ClearAttachmentBuilder {
7247 inner: Self::default(),
7248 marker: ::std::marker::PhantomData,
7249 }
7250 }
7251}
7252#[repr(transparent)]
7253pub struct ClearAttachmentBuilder<'a> {
7254 inner: ClearAttachment,
7255 marker: ::std::marker::PhantomData<&'a ()>,
7256}
7257impl<'a> ::std::ops::Deref for ClearAttachmentBuilder<'a> {
7258 type Target = ClearAttachment;
7259 fn deref(&self) -> &Self::Target {
7260 &self.inner
7261 }
7262}
7263impl<'a> ::std::ops::DerefMut for ClearAttachmentBuilder<'a> {
7264 fn deref_mut(&mut self) -> &mut Self::Target {
7265 &mut self.inner
7266 }
7267}
7268impl<'a> ClearAttachmentBuilder<'a> {
7269 pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self {
7270 self.inner.aspect_mask = aspect_mask;
7271 self
7272 }
7273 pub fn color_attachment(mut self, color_attachment: u32) -> Self {
7274 self.inner.color_attachment = color_attachment;
7275 self
7276 }
7277 pub fn clear_value(mut self, clear_value: ClearValue) -> Self {
7278 self.inner.clear_value = clear_value;
7279 self
7280 }
7281 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7282 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7283 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
7284 pub fn build(self) -> ClearAttachment {
7285 self.inner
7286 }
7287}
7288#[repr(C)]
7289#[cfg_attr(feature = "debug", derive(Debug))]
7290#[derive(Copy, Clone, Default)]
7291#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentDescription.html>"]
7292pub struct AttachmentDescription {
7293 pub flags: AttachmentDescriptionFlags,
7294 pub format: Format,
7295 pub samples: SampleCountFlags,
7296 pub load_op: AttachmentLoadOp,
7297 pub store_op: AttachmentStoreOp,
7298 pub stencil_load_op: AttachmentLoadOp,
7299 pub stencil_store_op: AttachmentStoreOp,
7300 pub initial_layout: ImageLayout,
7301 pub final_layout: ImageLayout,
7302}
7303impl AttachmentDescription {
7304 pub fn builder<'a>() -> AttachmentDescriptionBuilder<'a> {
7305 AttachmentDescriptionBuilder {
7306 inner: Self::default(),
7307 marker: ::std::marker::PhantomData,
7308 }
7309 }
7310}
7311#[repr(transparent)]
7312pub struct AttachmentDescriptionBuilder<'a> {
7313 inner: AttachmentDescription,
7314 marker: ::std::marker::PhantomData<&'a ()>,
7315}
7316impl<'a> ::std::ops::Deref for AttachmentDescriptionBuilder<'a> {
7317 type Target = AttachmentDescription;
7318 fn deref(&self) -> &Self::Target {
7319 &self.inner
7320 }
7321}
7322impl<'a> ::std::ops::DerefMut for AttachmentDescriptionBuilder<'a> {
7323 fn deref_mut(&mut self) -> &mut Self::Target {
7324 &mut self.inner
7325 }
7326}
7327impl<'a> AttachmentDescriptionBuilder<'a> {
7328 pub fn flags(mut self, flags: AttachmentDescriptionFlags) -> Self {
7329 self.inner.flags = flags;
7330 self
7331 }
7332 pub fn format(mut self, format: Format) -> Self {
7333 self.inner.format = format;
7334 self
7335 }
7336 pub fn samples(mut self, samples: SampleCountFlags) -> Self {
7337 self.inner.samples = samples;
7338 self
7339 }
7340 pub fn load_op(mut self, load_op: AttachmentLoadOp) -> Self {
7341 self.inner.load_op = load_op;
7342 self
7343 }
7344 pub fn store_op(mut self, store_op: AttachmentStoreOp) -> Self {
7345 self.inner.store_op = store_op;
7346 self
7347 }
7348 pub fn stencil_load_op(mut self, stencil_load_op: AttachmentLoadOp) -> Self {
7349 self.inner.stencil_load_op = stencil_load_op;
7350 self
7351 }
7352 pub fn stencil_store_op(mut self, stencil_store_op: AttachmentStoreOp) -> Self {
7353 self.inner.stencil_store_op = stencil_store_op;
7354 self
7355 }
7356 pub fn initial_layout(mut self, initial_layout: ImageLayout) -> Self {
7357 self.inner.initial_layout = initial_layout;
7358 self
7359 }
7360 pub fn final_layout(mut self, final_layout: ImageLayout) -> Self {
7361 self.inner.final_layout = final_layout;
7362 self
7363 }
7364 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7365 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7366 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
7367 pub fn build(self) -> AttachmentDescription {
7368 self.inner
7369 }
7370}
7371#[repr(C)]
7372#[cfg_attr(feature = "debug", derive(Debug))]
7373#[derive(Copy, Clone, Default)]
7374#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentReference.html>"]
7375pub struct AttachmentReference {
7376 pub attachment: u32,
7377 pub layout: ImageLayout,
7378}
7379impl AttachmentReference {
7380 pub fn builder<'a>() -> AttachmentReferenceBuilder<'a> {
7381 AttachmentReferenceBuilder {
7382 inner: Self::default(),
7383 marker: ::std::marker::PhantomData,
7384 }
7385 }
7386}
7387#[repr(transparent)]
7388pub struct AttachmentReferenceBuilder<'a> {
7389 inner: AttachmentReference,
7390 marker: ::std::marker::PhantomData<&'a ()>,
7391}
7392impl<'a> ::std::ops::Deref for AttachmentReferenceBuilder<'a> {
7393 type Target = AttachmentReference;
7394 fn deref(&self) -> &Self::Target {
7395 &self.inner
7396 }
7397}
7398impl<'a> ::std::ops::DerefMut for AttachmentReferenceBuilder<'a> {
7399 fn deref_mut(&mut self) -> &mut Self::Target {
7400 &mut self.inner
7401 }
7402}
7403impl<'a> AttachmentReferenceBuilder<'a> {
7404 pub fn attachment(mut self, attachment: u32) -> Self {
7405 self.inner.attachment = attachment;
7406 self
7407 }
7408 pub fn layout(mut self, layout: ImageLayout) -> Self {
7409 self.inner.layout = layout;
7410 self
7411 }
7412 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7413 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7414 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
7415 pub fn build(self) -> AttachmentReference {
7416 self.inner
7417 }
7418}
7419#[repr(C)]
7420#[cfg_attr(feature = "debug", derive(Debug))]
7421#[derive(Copy, Clone)]
7422#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDescription.html>"]
7423pub struct SubpassDescription {
7424 pub flags: SubpassDescriptionFlags,
7425 pub pipeline_bind_point: PipelineBindPoint,
7426 pub input_attachment_count: u32,
7427 pub p_input_attachments: *const AttachmentReference,
7428 pub color_attachment_count: u32,
7429 pub p_color_attachments: *const AttachmentReference,
7430 pub p_resolve_attachments: *const AttachmentReference,
7431 pub p_depth_stencil_attachment: *const AttachmentReference,
7432 pub preserve_attachment_count: u32,
7433 pub p_preserve_attachments: *const u32,
7434}
7435impl ::std::default::Default for SubpassDescription {
7436 fn default() -> Self {
7437 Self {
7438 flags: SubpassDescriptionFlags::default(),
7439 pipeline_bind_point: PipelineBindPoint::default(),
7440 input_attachment_count: u32::default(),
7441 p_input_attachments: ::std::ptr::null(),
7442 color_attachment_count: u32::default(),
7443 p_color_attachments: ::std::ptr::null(),
7444 p_resolve_attachments: ::std::ptr::null(),
7445 p_depth_stencil_attachment: ::std::ptr::null(),
7446 preserve_attachment_count: u32::default(),
7447 p_preserve_attachments: ::std::ptr::null(),
7448 }
7449 }
7450}
7451impl SubpassDescription {
7452 pub fn builder<'a>() -> SubpassDescriptionBuilder<'a> {
7453 SubpassDescriptionBuilder {
7454 inner: Self::default(),
7455 marker: ::std::marker::PhantomData,
7456 }
7457 }
7458}
7459#[repr(transparent)]
7460pub struct SubpassDescriptionBuilder<'a> {
7461 inner: SubpassDescription,
7462 marker: ::std::marker::PhantomData<&'a ()>,
7463}
7464impl<'a> ::std::ops::Deref for SubpassDescriptionBuilder<'a> {
7465 type Target = SubpassDescription;
7466 fn deref(&self) -> &Self::Target {
7467 &self.inner
7468 }
7469}
7470impl<'a> ::std::ops::DerefMut for SubpassDescriptionBuilder<'a> {
7471 fn deref_mut(&mut self) -> &mut Self::Target {
7472 &mut self.inner
7473 }
7474}
7475impl<'a> SubpassDescriptionBuilder<'a> {
7476 pub fn flags(mut self, flags: SubpassDescriptionFlags) -> Self {
7477 self.inner.flags = flags;
7478 self
7479 }
7480 pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self {
7481 self.inner.pipeline_bind_point = pipeline_bind_point;
7482 self
7483 }
7484 pub fn input_attachments(mut self, input_attachments: &'a [AttachmentReference]) -> Self {
7485 self.inner.input_attachment_count = input_attachments.len() as _;
7486 self.inner.p_input_attachments = input_attachments.as_ptr();
7487 self
7488 }
7489 pub fn color_attachments(mut self, color_attachments: &'a [AttachmentReference]) -> Self {
7490 self.inner.color_attachment_count = color_attachments.len() as _;
7491 self.inner.p_color_attachments = color_attachments.as_ptr();
7492 self
7493 }
7494 pub fn resolve_attachments(mut self, resolve_attachments: &'a [AttachmentReference]) -> Self {
7495 self.inner.color_attachment_count = resolve_attachments.len() as _;
7496 self.inner.p_resolve_attachments = resolve_attachments.as_ptr();
7497 self
7498 }
7499 pub fn depth_stencil_attachment(
7500 mut self,
7501 depth_stencil_attachment: &'a AttachmentReference,
7502 ) -> Self {
7503 self.inner.p_depth_stencil_attachment = depth_stencil_attachment;
7504 self
7505 }
7506 pub fn preserve_attachments(mut self, preserve_attachments: &'a [u32]) -> Self {
7507 self.inner.preserve_attachment_count = preserve_attachments.len() as _;
7508 self.inner.p_preserve_attachments = preserve_attachments.as_ptr();
7509 self
7510 }
7511 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7512 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7513 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
7514 pub fn build(self) -> SubpassDescription {
7515 self.inner
7516 }
7517}
7518#[repr(C)]
7519#[cfg_attr(feature = "debug", derive(Debug))]
7520#[derive(Copy, Clone, Default)]
7521#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDependency.html>"]
7522pub struct SubpassDependency {
7523 pub src_subpass: u32,
7524 pub dst_subpass: u32,
7525 pub src_stage_mask: PipelineStageFlags,
7526 pub dst_stage_mask: PipelineStageFlags,
7527 pub src_access_mask: AccessFlags,
7528 pub dst_access_mask: AccessFlags,
7529 pub dependency_flags: DependencyFlags,
7530}
7531impl SubpassDependency {
7532 pub fn builder<'a>() -> SubpassDependencyBuilder<'a> {
7533 SubpassDependencyBuilder {
7534 inner: Self::default(),
7535 marker: ::std::marker::PhantomData,
7536 }
7537 }
7538}
7539#[repr(transparent)]
7540pub struct SubpassDependencyBuilder<'a> {
7541 inner: SubpassDependency,
7542 marker: ::std::marker::PhantomData<&'a ()>,
7543}
7544impl<'a> ::std::ops::Deref for SubpassDependencyBuilder<'a> {
7545 type Target = SubpassDependency;
7546 fn deref(&self) -> &Self::Target {
7547 &self.inner
7548 }
7549}
7550impl<'a> ::std::ops::DerefMut for SubpassDependencyBuilder<'a> {
7551 fn deref_mut(&mut self) -> &mut Self::Target {
7552 &mut self.inner
7553 }
7554}
7555impl<'a> SubpassDependencyBuilder<'a> {
7556 pub fn src_subpass(mut self, src_subpass: u32) -> Self {
7557 self.inner.src_subpass = src_subpass;
7558 self
7559 }
7560 pub fn dst_subpass(mut self, dst_subpass: u32) -> Self {
7561 self.inner.dst_subpass = dst_subpass;
7562 self
7563 }
7564 pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags) -> Self {
7565 self.inner.src_stage_mask = src_stage_mask;
7566 self
7567 }
7568 pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags) -> Self {
7569 self.inner.dst_stage_mask = dst_stage_mask;
7570 self
7571 }
7572 pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self {
7573 self.inner.src_access_mask = src_access_mask;
7574 self
7575 }
7576 pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self {
7577 self.inner.dst_access_mask = dst_access_mask;
7578 self
7579 }
7580 pub fn dependency_flags(mut self, dependency_flags: DependencyFlags) -> Self {
7581 self.inner.dependency_flags = dependency_flags;
7582 self
7583 }
7584 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7585 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7586 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
7587 pub fn build(self) -> SubpassDependency {
7588 self.inner
7589 }
7590}
7591#[repr(C)]
7592#[cfg_attr(feature = "debug", derive(Debug))]
7593#[derive(Copy, Clone)]
7594#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassCreateInfo.html>"]
7595pub struct RenderPassCreateInfo {
7596 pub s_type: StructureType,
7597 pub p_next: *const c_void,
7598 pub flags: RenderPassCreateFlags,
7599 pub attachment_count: u32,
7600 pub p_attachments: *const AttachmentDescription,
7601 pub subpass_count: u32,
7602 pub p_subpasses: *const SubpassDescription,
7603 pub dependency_count: u32,
7604 pub p_dependencies: *const SubpassDependency,
7605}
7606impl ::std::default::Default for RenderPassCreateInfo {
7607 fn default() -> Self {
7608 Self {
7609 s_type: StructureType::RENDER_PASS_CREATE_INFO,
7610 p_next: ::std::ptr::null(),
7611 flags: RenderPassCreateFlags::default(),
7612 attachment_count: u32::default(),
7613 p_attachments: ::std::ptr::null(),
7614 subpass_count: u32::default(),
7615 p_subpasses: ::std::ptr::null(),
7616 dependency_count: u32::default(),
7617 p_dependencies: ::std::ptr::null(),
7618 }
7619 }
7620}
7621impl RenderPassCreateInfo {
7622 pub fn builder<'a>() -> RenderPassCreateInfoBuilder<'a> {
7623 RenderPassCreateInfoBuilder {
7624 inner: Self::default(),
7625 marker: ::std::marker::PhantomData,
7626 }
7627 }
7628}
7629#[repr(transparent)]
7630pub struct RenderPassCreateInfoBuilder<'a> {
7631 inner: RenderPassCreateInfo,
7632 marker: ::std::marker::PhantomData<&'a ()>,
7633}
7634pub unsafe trait ExtendsRenderPassCreateInfo {}
7635impl<'a> ::std::ops::Deref for RenderPassCreateInfoBuilder<'a> {
7636 type Target = RenderPassCreateInfo;
7637 fn deref(&self) -> &Self::Target {
7638 &self.inner
7639 }
7640}
7641impl<'a> ::std::ops::DerefMut for RenderPassCreateInfoBuilder<'a> {
7642 fn deref_mut(&mut self) -> &mut Self::Target {
7643 &mut self.inner
7644 }
7645}
7646impl<'a> RenderPassCreateInfoBuilder<'a> {
7647 pub fn flags(mut self, flags: RenderPassCreateFlags) -> Self {
7648 self.inner.flags = flags;
7649 self
7650 }
7651 pub fn attachments(mut self, attachments: &'a [AttachmentDescription]) -> Self {
7652 self.inner.attachment_count = attachments.len() as _;
7653 self.inner.p_attachments = attachments.as_ptr();
7654 self
7655 }
7656 pub fn subpasses(mut self, subpasses: &'a [SubpassDescription]) -> Self {
7657 self.inner.subpass_count = subpasses.len() as _;
7658 self.inner.p_subpasses = subpasses.as_ptr();
7659 self
7660 }
7661 pub fn dependencies(mut self, dependencies: &'a [SubpassDependency]) -> Self {
7662 self.inner.dependency_count = dependencies.len() as _;
7663 self.inner.p_dependencies = dependencies.as_ptr();
7664 self
7665 }
7666 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
7667 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
7668 #[doc = r" valid extension structs can be pushed into the chain."]
7669 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
7670 #[doc = r" chain will look like `A -> D -> B -> C`."]
7671 pub fn push_next<T: ExtendsRenderPassCreateInfo>(mut self, next: &'a mut T) -> Self {
7672 unsafe {
7673 let next_ptr = <*const T>::cast(next);
7674 let last_next = ptr_chain_iter(next).last().unwrap();
7675 (*last_next).p_next = self.inner.p_next as _;
7676 self.inner.p_next = next_ptr;
7677 }
7678 self
7679 }
7680 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7681 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7682 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
7683 pub fn build(self) -> RenderPassCreateInfo {
7684 self.inner
7685 }
7686}
7687#[repr(C)]
7688#[cfg_attr(feature = "debug", derive(Debug))]
7689#[derive(Copy, Clone)]
7690#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkEventCreateInfo.html>"]
7691pub struct EventCreateInfo {
7692 pub s_type: StructureType,
7693 pub p_next: *const c_void,
7694 pub flags: EventCreateFlags,
7695}
7696impl ::std::default::Default for EventCreateInfo {
7697 fn default() -> Self {
7698 Self {
7699 s_type: StructureType::EVENT_CREATE_INFO,
7700 p_next: ::std::ptr::null(),
7701 flags: EventCreateFlags::default(),
7702 }
7703 }
7704}
7705impl EventCreateInfo {
7706 pub fn builder<'a>() -> EventCreateInfoBuilder<'a> {
7707 EventCreateInfoBuilder {
7708 inner: Self::default(),
7709 marker: ::std::marker::PhantomData,
7710 }
7711 }
7712}
7713#[repr(transparent)]
7714pub struct EventCreateInfoBuilder<'a> {
7715 inner: EventCreateInfo,
7716 marker: ::std::marker::PhantomData<&'a ()>,
7717}
7718impl<'a> ::std::ops::Deref for EventCreateInfoBuilder<'a> {
7719 type Target = EventCreateInfo;
7720 fn deref(&self) -> &Self::Target {
7721 &self.inner
7722 }
7723}
7724impl<'a> ::std::ops::DerefMut for EventCreateInfoBuilder<'a> {
7725 fn deref_mut(&mut self) -> &mut Self::Target {
7726 &mut self.inner
7727 }
7728}
7729impl<'a> EventCreateInfoBuilder<'a> {
7730 pub fn flags(mut self, flags: EventCreateFlags) -> Self {
7731 self.inner.flags = flags;
7732 self
7733 }
7734 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7735 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7736 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
7737 pub fn build(self) -> EventCreateInfo {
7738 self.inner
7739 }
7740}
7741#[repr(C)]
7742#[cfg_attr(feature = "debug", derive(Debug))]
7743#[derive(Copy, Clone)]
7744#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFenceCreateInfo.html>"]
7745pub struct FenceCreateInfo {
7746 pub s_type: StructureType,
7747 pub p_next: *const c_void,
7748 pub flags: FenceCreateFlags,
7749}
7750impl ::std::default::Default for FenceCreateInfo {
7751 fn default() -> Self {
7752 Self {
7753 s_type: StructureType::FENCE_CREATE_INFO,
7754 p_next: ::std::ptr::null(),
7755 flags: FenceCreateFlags::default(),
7756 }
7757 }
7758}
7759impl FenceCreateInfo {
7760 pub fn builder<'a>() -> FenceCreateInfoBuilder<'a> {
7761 FenceCreateInfoBuilder {
7762 inner: Self::default(),
7763 marker: ::std::marker::PhantomData,
7764 }
7765 }
7766}
7767#[repr(transparent)]
7768pub struct FenceCreateInfoBuilder<'a> {
7769 inner: FenceCreateInfo,
7770 marker: ::std::marker::PhantomData<&'a ()>,
7771}
7772pub unsafe trait ExtendsFenceCreateInfo {}
7773impl<'a> ::std::ops::Deref for FenceCreateInfoBuilder<'a> {
7774 type Target = FenceCreateInfo;
7775 fn deref(&self) -> &Self::Target {
7776 &self.inner
7777 }
7778}
7779impl<'a> ::std::ops::DerefMut for FenceCreateInfoBuilder<'a> {
7780 fn deref_mut(&mut self) -> &mut Self::Target {
7781 &mut self.inner
7782 }
7783}
7784impl<'a> FenceCreateInfoBuilder<'a> {
7785 pub fn flags(mut self, flags: FenceCreateFlags) -> Self {
7786 self.inner.flags = flags;
7787 self
7788 }
7789 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
7790 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
7791 #[doc = r" valid extension structs can be pushed into the chain."]
7792 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
7793 #[doc = r" chain will look like `A -> D -> B -> C`."]
7794 pub fn push_next<T: ExtendsFenceCreateInfo>(mut self, next: &'a mut T) -> Self {
7795 unsafe {
7796 let next_ptr = <*const T>::cast(next);
7797 let last_next = ptr_chain_iter(next).last().unwrap();
7798 (*last_next).p_next = self.inner.p_next as _;
7799 self.inner.p_next = next_ptr;
7800 }
7801 self
7802 }
7803 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7804 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7805 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
7806 pub fn build(self) -> FenceCreateInfo {
7807 self.inner
7808 }
7809}
7810#[repr(C)]
7811#[cfg_attr(feature = "debug", derive(Debug))]
7812#[derive(Copy, Clone, Default)]
7813#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFeatures.html>"]
7814pub struct PhysicalDeviceFeatures {
7815 pub robust_buffer_access: Bool32,
7816 pub full_draw_index_uint32: Bool32,
7817 pub image_cube_array: Bool32,
7818 pub independent_blend: Bool32,
7819 pub geometry_shader: Bool32,
7820 pub tessellation_shader: Bool32,
7821 pub sample_rate_shading: Bool32,
7822 pub dual_src_blend: Bool32,
7823 pub logic_op: Bool32,
7824 pub multi_draw_indirect: Bool32,
7825 pub draw_indirect_first_instance: Bool32,
7826 pub depth_clamp: Bool32,
7827 pub depth_bias_clamp: Bool32,
7828 pub fill_mode_non_solid: Bool32,
7829 pub depth_bounds: Bool32,
7830 pub wide_lines: Bool32,
7831 pub large_points: Bool32,
7832 pub alpha_to_one: Bool32,
7833 pub multi_viewport: Bool32,
7834 pub sampler_anisotropy: Bool32,
7835 pub texture_compression_etc2: Bool32,
7836 pub texture_compression_astc_ldr: Bool32,
7837 pub texture_compression_bc: Bool32,
7838 pub occlusion_query_precise: Bool32,
7839 pub pipeline_statistics_query: Bool32,
7840 pub vertex_pipeline_stores_and_atomics: Bool32,
7841 pub fragment_stores_and_atomics: Bool32,
7842 pub shader_tessellation_and_geometry_point_size: Bool32,
7843 pub shader_image_gather_extended: Bool32,
7844 pub shader_storage_image_extended_formats: Bool32,
7845 pub shader_storage_image_multisample: Bool32,
7846 pub shader_storage_image_read_without_format: Bool32,
7847 pub shader_storage_image_write_without_format: Bool32,
7848 pub shader_uniform_buffer_array_dynamic_indexing: Bool32,
7849 pub shader_sampled_image_array_dynamic_indexing: Bool32,
7850 pub shader_storage_buffer_array_dynamic_indexing: Bool32,
7851 pub shader_storage_image_array_dynamic_indexing: Bool32,
7852 pub shader_clip_distance: Bool32,
7853 pub shader_cull_distance: Bool32,
7854 pub shader_float64: Bool32,
7855 pub shader_int64: Bool32,
7856 pub shader_int16: Bool32,
7857 pub shader_resource_residency: Bool32,
7858 pub shader_resource_min_lod: Bool32,
7859 pub sparse_binding: Bool32,
7860 pub sparse_residency_buffer: Bool32,
7861 pub sparse_residency_image2_d: Bool32,
7862 pub sparse_residency_image3_d: Bool32,
7863 pub sparse_residency2_samples: Bool32,
7864 pub sparse_residency4_samples: Bool32,
7865 pub sparse_residency8_samples: Bool32,
7866 pub sparse_residency16_samples: Bool32,
7867 pub sparse_residency_aliased: Bool32,
7868 pub variable_multisample_rate: Bool32,
7869 pub inherited_queries: Bool32,
7870}
7871impl PhysicalDeviceFeatures {
7872 pub fn builder<'a>() -> PhysicalDeviceFeaturesBuilder<'a> {
7873 PhysicalDeviceFeaturesBuilder {
7874 inner: Self::default(),
7875 marker: ::std::marker::PhantomData,
7876 }
7877 }
7878}
7879#[repr(transparent)]
7880pub struct PhysicalDeviceFeaturesBuilder<'a> {
7881 inner: PhysicalDeviceFeatures,
7882 marker: ::std::marker::PhantomData<&'a ()>,
7883}
7884impl<'a> ::std::ops::Deref for PhysicalDeviceFeaturesBuilder<'a> {
7885 type Target = PhysicalDeviceFeatures;
7886 fn deref(&self) -> &Self::Target {
7887 &self.inner
7888 }
7889}
7890impl<'a> ::std::ops::DerefMut for PhysicalDeviceFeaturesBuilder<'a> {
7891 fn deref_mut(&mut self) -> &mut Self::Target {
7892 &mut self.inner
7893 }
7894}
7895impl<'a> PhysicalDeviceFeaturesBuilder<'a> {
7896 pub fn robust_buffer_access(mut self, robust_buffer_access: bool) -> Self {
7897 self.inner.robust_buffer_access = robust_buffer_access.into();
7898 self
7899 }
7900 pub fn full_draw_index_uint32(mut self, full_draw_index_uint32: bool) -> Self {
7901 self.inner.full_draw_index_uint32 = full_draw_index_uint32.into();
7902 self
7903 }
7904 pub fn image_cube_array(mut self, image_cube_array: bool) -> Self {
7905 self.inner.image_cube_array = image_cube_array.into();
7906 self
7907 }
7908 pub fn independent_blend(mut self, independent_blend: bool) -> Self {
7909 self.inner.independent_blend = independent_blend.into();
7910 self
7911 }
7912 pub fn geometry_shader(mut self, geometry_shader: bool) -> Self {
7913 self.inner.geometry_shader = geometry_shader.into();
7914 self
7915 }
7916 pub fn tessellation_shader(mut self, tessellation_shader: bool) -> Self {
7917 self.inner.tessellation_shader = tessellation_shader.into();
7918 self
7919 }
7920 pub fn sample_rate_shading(mut self, sample_rate_shading: bool) -> Self {
7921 self.inner.sample_rate_shading = sample_rate_shading.into();
7922 self
7923 }
7924 pub fn dual_src_blend(mut self, dual_src_blend: bool) -> Self {
7925 self.inner.dual_src_blend = dual_src_blend.into();
7926 self
7927 }
7928 pub fn logic_op(mut self, logic_op: bool) -> Self {
7929 self.inner.logic_op = logic_op.into();
7930 self
7931 }
7932 pub fn multi_draw_indirect(mut self, multi_draw_indirect: bool) -> Self {
7933 self.inner.multi_draw_indirect = multi_draw_indirect.into();
7934 self
7935 }
7936 pub fn draw_indirect_first_instance(mut self, draw_indirect_first_instance: bool) -> Self {
7937 self.inner.draw_indirect_first_instance = draw_indirect_first_instance.into();
7938 self
7939 }
7940 pub fn depth_clamp(mut self, depth_clamp: bool) -> Self {
7941 self.inner.depth_clamp = depth_clamp.into();
7942 self
7943 }
7944 pub fn depth_bias_clamp(mut self, depth_bias_clamp: bool) -> Self {
7945 self.inner.depth_bias_clamp = depth_bias_clamp.into();
7946 self
7947 }
7948 pub fn fill_mode_non_solid(mut self, fill_mode_non_solid: bool) -> Self {
7949 self.inner.fill_mode_non_solid = fill_mode_non_solid.into();
7950 self
7951 }
7952 pub fn depth_bounds(mut self, depth_bounds: bool) -> Self {
7953 self.inner.depth_bounds = depth_bounds.into();
7954 self
7955 }
7956 pub fn wide_lines(mut self, wide_lines: bool) -> Self {
7957 self.inner.wide_lines = wide_lines.into();
7958 self
7959 }
7960 pub fn large_points(mut self, large_points: bool) -> Self {
7961 self.inner.large_points = large_points.into();
7962 self
7963 }
7964 pub fn alpha_to_one(mut self, alpha_to_one: bool) -> Self {
7965 self.inner.alpha_to_one = alpha_to_one.into();
7966 self
7967 }
7968 pub fn multi_viewport(mut self, multi_viewport: bool) -> Self {
7969 self.inner.multi_viewport = multi_viewport.into();
7970 self
7971 }
7972 pub fn sampler_anisotropy(mut self, sampler_anisotropy: bool) -> Self {
7973 self.inner.sampler_anisotropy = sampler_anisotropy.into();
7974 self
7975 }
7976 pub fn texture_compression_etc2(mut self, texture_compression_etc2: bool) -> Self {
7977 self.inner.texture_compression_etc2 = texture_compression_etc2.into();
7978 self
7979 }
7980 pub fn texture_compression_astc_ldr(mut self, texture_compression_astc_ldr: bool) -> Self {
7981 self.inner.texture_compression_astc_ldr = texture_compression_astc_ldr.into();
7982 self
7983 }
7984 pub fn texture_compression_bc(mut self, texture_compression_bc: bool) -> Self {
7985 self.inner.texture_compression_bc = texture_compression_bc.into();
7986 self
7987 }
7988 pub fn occlusion_query_precise(mut self, occlusion_query_precise: bool) -> Self {
7989 self.inner.occlusion_query_precise = occlusion_query_precise.into();
7990 self
7991 }
7992 pub fn pipeline_statistics_query(mut self, pipeline_statistics_query: bool) -> Self {
7993 self.inner.pipeline_statistics_query = pipeline_statistics_query.into();
7994 self
7995 }
7996 pub fn vertex_pipeline_stores_and_atomics(
7997 mut self,
7998 vertex_pipeline_stores_and_atomics: bool,
7999 ) -> Self {
8000 self.inner.vertex_pipeline_stores_and_atomics = vertex_pipeline_stores_and_atomics.into();
8001 self
8002 }
8003 pub fn fragment_stores_and_atomics(mut self, fragment_stores_and_atomics: bool) -> Self {
8004 self.inner.fragment_stores_and_atomics = fragment_stores_and_atomics.into();
8005 self
8006 }
8007 pub fn shader_tessellation_and_geometry_point_size(
8008 mut self,
8009 shader_tessellation_and_geometry_point_size: bool,
8010 ) -> Self {
8011 self.inner.shader_tessellation_and_geometry_point_size =
8012 shader_tessellation_and_geometry_point_size.into();
8013 self
8014 }
8015 pub fn shader_image_gather_extended(mut self, shader_image_gather_extended: bool) -> Self {
8016 self.inner.shader_image_gather_extended = shader_image_gather_extended.into();
8017 self
8018 }
8019 pub fn shader_storage_image_extended_formats(
8020 mut self,
8021 shader_storage_image_extended_formats: bool,
8022 ) -> Self {
8023 self.inner.shader_storage_image_extended_formats =
8024 shader_storage_image_extended_formats.into();
8025 self
8026 }
8027 pub fn shader_storage_image_multisample(
8028 mut self,
8029 shader_storage_image_multisample: bool,
8030 ) -> Self {
8031 self.inner.shader_storage_image_multisample = shader_storage_image_multisample.into();
8032 self
8033 }
8034 pub fn shader_storage_image_read_without_format(
8035 mut self,
8036 shader_storage_image_read_without_format: bool,
8037 ) -> Self {
8038 self.inner.shader_storage_image_read_without_format =
8039 shader_storage_image_read_without_format.into();
8040 self
8041 }
8042 pub fn shader_storage_image_write_without_format(
8043 mut self,
8044 shader_storage_image_write_without_format: bool,
8045 ) -> Self {
8046 self.inner.shader_storage_image_write_without_format =
8047 shader_storage_image_write_without_format.into();
8048 self
8049 }
8050 pub fn shader_uniform_buffer_array_dynamic_indexing(
8051 mut self,
8052 shader_uniform_buffer_array_dynamic_indexing: bool,
8053 ) -> Self {
8054 self.inner.shader_uniform_buffer_array_dynamic_indexing =
8055 shader_uniform_buffer_array_dynamic_indexing.into();
8056 self
8057 }
8058 pub fn shader_sampled_image_array_dynamic_indexing(
8059 mut self,
8060 shader_sampled_image_array_dynamic_indexing: bool,
8061 ) -> Self {
8062 self.inner.shader_sampled_image_array_dynamic_indexing =
8063 shader_sampled_image_array_dynamic_indexing.into();
8064 self
8065 }
8066 pub fn shader_storage_buffer_array_dynamic_indexing(
8067 mut self,
8068 shader_storage_buffer_array_dynamic_indexing: bool,
8069 ) -> Self {
8070 self.inner.shader_storage_buffer_array_dynamic_indexing =
8071 shader_storage_buffer_array_dynamic_indexing.into();
8072 self
8073 }
8074 pub fn shader_storage_image_array_dynamic_indexing(
8075 mut self,
8076 shader_storage_image_array_dynamic_indexing: bool,
8077 ) -> Self {
8078 self.inner.shader_storage_image_array_dynamic_indexing =
8079 shader_storage_image_array_dynamic_indexing.into();
8080 self
8081 }
8082 pub fn shader_clip_distance(mut self, shader_clip_distance: bool) -> Self {
8083 self.inner.shader_clip_distance = shader_clip_distance.into();
8084 self
8085 }
8086 pub fn shader_cull_distance(mut self, shader_cull_distance: bool) -> Self {
8087 self.inner.shader_cull_distance = shader_cull_distance.into();
8088 self
8089 }
8090 pub fn shader_float64(mut self, shader_float64: bool) -> Self {
8091 self.inner.shader_float64 = shader_float64.into();
8092 self
8093 }
8094 pub fn shader_int64(mut self, shader_int64: bool) -> Self {
8095 self.inner.shader_int64 = shader_int64.into();
8096 self
8097 }
8098 pub fn shader_int16(mut self, shader_int16: bool) -> Self {
8099 self.inner.shader_int16 = shader_int16.into();
8100 self
8101 }
8102 pub fn shader_resource_residency(mut self, shader_resource_residency: bool) -> Self {
8103 self.inner.shader_resource_residency = shader_resource_residency.into();
8104 self
8105 }
8106 pub fn shader_resource_min_lod(mut self, shader_resource_min_lod: bool) -> Self {
8107 self.inner.shader_resource_min_lod = shader_resource_min_lod.into();
8108 self
8109 }
8110 pub fn sparse_binding(mut self, sparse_binding: bool) -> Self {
8111 self.inner.sparse_binding = sparse_binding.into();
8112 self
8113 }
8114 pub fn sparse_residency_buffer(mut self, sparse_residency_buffer: bool) -> Self {
8115 self.inner.sparse_residency_buffer = sparse_residency_buffer.into();
8116 self
8117 }
8118 pub fn sparse_residency_image2_d(mut self, sparse_residency_image2_d: bool) -> Self {
8119 self.inner.sparse_residency_image2_d = sparse_residency_image2_d.into();
8120 self
8121 }
8122 pub fn sparse_residency_image3_d(mut self, sparse_residency_image3_d: bool) -> Self {
8123 self.inner.sparse_residency_image3_d = sparse_residency_image3_d.into();
8124 self
8125 }
8126 pub fn sparse_residency2_samples(mut self, sparse_residency2_samples: bool) -> Self {
8127 self.inner.sparse_residency2_samples = sparse_residency2_samples.into();
8128 self
8129 }
8130 pub fn sparse_residency4_samples(mut self, sparse_residency4_samples: bool) -> Self {
8131 self.inner.sparse_residency4_samples = sparse_residency4_samples.into();
8132 self
8133 }
8134 pub fn sparse_residency8_samples(mut self, sparse_residency8_samples: bool) -> Self {
8135 self.inner.sparse_residency8_samples = sparse_residency8_samples.into();
8136 self
8137 }
8138 pub fn sparse_residency16_samples(mut self, sparse_residency16_samples: bool) -> Self {
8139 self.inner.sparse_residency16_samples = sparse_residency16_samples.into();
8140 self
8141 }
8142 pub fn sparse_residency_aliased(mut self, sparse_residency_aliased: bool) -> Self {
8143 self.inner.sparse_residency_aliased = sparse_residency_aliased.into();
8144 self
8145 }
8146 pub fn variable_multisample_rate(mut self, variable_multisample_rate: bool) -> Self {
8147 self.inner.variable_multisample_rate = variable_multisample_rate.into();
8148 self
8149 }
8150 pub fn inherited_queries(mut self, inherited_queries: bool) -> Self {
8151 self.inner.inherited_queries = inherited_queries.into();
8152 self
8153 }
8154 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
8155 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
8156 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
8157 pub fn build(self) -> PhysicalDeviceFeatures {
8158 self.inner
8159 }
8160}
8161#[repr(C)]
8162#[cfg_attr(feature = "debug", derive(Debug))]
8163#[derive(Copy, Clone, Default)]
8164#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSparseProperties.html>"]
8165pub struct PhysicalDeviceSparseProperties {
8166 pub residency_standard2_d_block_shape: Bool32,
8167 pub residency_standard2_d_multisample_block_shape: Bool32,
8168 pub residency_standard3_d_block_shape: Bool32,
8169 pub residency_aligned_mip_size: Bool32,
8170 pub residency_non_resident_strict: Bool32,
8171}
8172impl PhysicalDeviceSparseProperties {
8173 pub fn builder<'a>() -> PhysicalDeviceSparsePropertiesBuilder<'a> {
8174 PhysicalDeviceSparsePropertiesBuilder {
8175 inner: Self::default(),
8176 marker: ::std::marker::PhantomData,
8177 }
8178 }
8179}
8180#[repr(transparent)]
8181pub struct PhysicalDeviceSparsePropertiesBuilder<'a> {
8182 inner: PhysicalDeviceSparseProperties,
8183 marker: ::std::marker::PhantomData<&'a ()>,
8184}
8185impl<'a> ::std::ops::Deref for PhysicalDeviceSparsePropertiesBuilder<'a> {
8186 type Target = PhysicalDeviceSparseProperties;
8187 fn deref(&self) -> &Self::Target {
8188 &self.inner
8189 }
8190}
8191impl<'a> ::std::ops::DerefMut for PhysicalDeviceSparsePropertiesBuilder<'a> {
8192 fn deref_mut(&mut self) -> &mut Self::Target {
8193 &mut self.inner
8194 }
8195}
8196impl<'a> PhysicalDeviceSparsePropertiesBuilder<'a> {
8197 pub fn residency_standard2_d_block_shape(
8198 mut self,
8199 residency_standard2_d_block_shape: bool,
8200 ) -> Self {
8201 self.inner.residency_standard2_d_block_shape = residency_standard2_d_block_shape.into();
8202 self
8203 }
8204 pub fn residency_standard2_d_multisample_block_shape(
8205 mut self,
8206 residency_standard2_d_multisample_block_shape: bool,
8207 ) -> Self {
8208 self.inner.residency_standard2_d_multisample_block_shape =
8209 residency_standard2_d_multisample_block_shape.into();
8210 self
8211 }
8212 pub fn residency_standard3_d_block_shape(
8213 mut self,
8214 residency_standard3_d_block_shape: bool,
8215 ) -> Self {
8216 self.inner.residency_standard3_d_block_shape = residency_standard3_d_block_shape.into();
8217 self
8218 }
8219 pub fn residency_aligned_mip_size(mut self, residency_aligned_mip_size: bool) -> Self {
8220 self.inner.residency_aligned_mip_size = residency_aligned_mip_size.into();
8221 self
8222 }
8223 pub fn residency_non_resident_strict(mut self, residency_non_resident_strict: bool) -> Self {
8224 self.inner.residency_non_resident_strict = residency_non_resident_strict.into();
8225 self
8226 }
8227 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
8228 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
8229 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
8230 pub fn build(self) -> PhysicalDeviceSparseProperties {
8231 self.inner
8232 }
8233}
8234#[repr(C)]
8235#[cfg_attr(feature = "debug", derive(Debug))]
8236#[derive(Copy, Clone)]
8237#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceLimits.html>"]
8238pub struct PhysicalDeviceLimits {
8239 pub max_image_dimension1_d: u32,
8240 pub max_image_dimension2_d: u32,
8241 pub max_image_dimension3_d: u32,
8242 pub max_image_dimension_cube: u32,
8243 pub max_image_array_layers: u32,
8244 pub max_texel_buffer_elements: u32,
8245 pub max_uniform_buffer_range: u32,
8246 pub max_storage_buffer_range: u32,
8247 pub max_push_constants_size: u32,
8248 pub max_memory_allocation_count: u32,
8249 pub max_sampler_allocation_count: u32,
8250 pub buffer_image_granularity: DeviceSize,
8251 pub sparse_address_space_size: DeviceSize,
8252 pub max_bound_descriptor_sets: u32,
8253 pub max_per_stage_descriptor_samplers: u32,
8254 pub max_per_stage_descriptor_uniform_buffers: u32,
8255 pub max_per_stage_descriptor_storage_buffers: u32,
8256 pub max_per_stage_descriptor_sampled_images: u32,
8257 pub max_per_stage_descriptor_storage_images: u32,
8258 pub max_per_stage_descriptor_input_attachments: u32,
8259 pub max_per_stage_resources: u32,
8260 pub max_descriptor_set_samplers: u32,
8261 pub max_descriptor_set_uniform_buffers: u32,
8262 pub max_descriptor_set_uniform_buffers_dynamic: u32,
8263 pub max_descriptor_set_storage_buffers: u32,
8264 pub max_descriptor_set_storage_buffers_dynamic: u32,
8265 pub max_descriptor_set_sampled_images: u32,
8266 pub max_descriptor_set_storage_images: u32,
8267 pub max_descriptor_set_input_attachments: u32,
8268 pub max_vertex_input_attributes: u32,
8269 pub max_vertex_input_bindings: u32,
8270 pub max_vertex_input_attribute_offset: u32,
8271 pub max_vertex_input_binding_stride: u32,
8272 pub max_vertex_output_components: u32,
8273 pub max_tessellation_generation_level: u32,
8274 pub max_tessellation_patch_size: u32,
8275 pub max_tessellation_control_per_vertex_input_components: u32,
8276 pub max_tessellation_control_per_vertex_output_components: u32,
8277 pub max_tessellation_control_per_patch_output_components: u32,
8278 pub max_tessellation_control_total_output_components: u32,
8279 pub max_tessellation_evaluation_input_components: u32,
8280 pub max_tessellation_evaluation_output_components: u32,
8281 pub max_geometry_shader_invocations: u32,
8282 pub max_geometry_input_components: u32,
8283 pub max_geometry_output_components: u32,
8284 pub max_geometry_output_vertices: u32,
8285 pub max_geometry_total_output_components: u32,
8286 pub max_fragment_input_components: u32,
8287 pub max_fragment_output_attachments: u32,
8288 pub max_fragment_dual_src_attachments: u32,
8289 pub max_fragment_combined_output_resources: u32,
8290 pub max_compute_shared_memory_size: u32,
8291 pub max_compute_work_group_count: [u32; 3],
8292 pub max_compute_work_group_invocations: u32,
8293 pub max_compute_work_group_size: [u32; 3],
8294 pub sub_pixel_precision_bits: u32,
8295 pub sub_texel_precision_bits: u32,
8296 pub mipmap_precision_bits: u32,
8297 pub max_draw_indexed_index_value: u32,
8298 pub max_draw_indirect_count: u32,
8299 pub max_sampler_lod_bias: f32,
8300 pub max_sampler_anisotropy: f32,
8301 pub max_viewports: u32,
8302 pub max_viewport_dimensions: [u32; 2],
8303 pub viewport_bounds_range: [f32; 2],
8304 pub viewport_sub_pixel_bits: u32,
8305 pub min_memory_map_alignment: usize,
8306 pub min_texel_buffer_offset_alignment: DeviceSize,
8307 pub min_uniform_buffer_offset_alignment: DeviceSize,
8308 pub min_storage_buffer_offset_alignment: DeviceSize,
8309 pub min_texel_offset: i32,
8310 pub max_texel_offset: u32,
8311 pub min_texel_gather_offset: i32,
8312 pub max_texel_gather_offset: u32,
8313 pub min_interpolation_offset: f32,
8314 pub max_interpolation_offset: f32,
8315 pub sub_pixel_interpolation_offset_bits: u32,
8316 pub max_framebuffer_width: u32,
8317 pub max_framebuffer_height: u32,
8318 pub max_framebuffer_layers: u32,
8319 pub framebuffer_color_sample_counts: SampleCountFlags,
8320 pub framebuffer_depth_sample_counts: SampleCountFlags,
8321 pub framebuffer_stencil_sample_counts: SampleCountFlags,
8322 pub framebuffer_no_attachments_sample_counts: SampleCountFlags,
8323 pub max_color_attachments: u32,
8324 pub sampled_image_color_sample_counts: SampleCountFlags,
8325 pub sampled_image_integer_sample_counts: SampleCountFlags,
8326 pub sampled_image_depth_sample_counts: SampleCountFlags,
8327 pub sampled_image_stencil_sample_counts: SampleCountFlags,
8328 pub storage_image_sample_counts: SampleCountFlags,
8329 pub max_sample_mask_words: u32,
8330 pub timestamp_compute_and_graphics: Bool32,
8331 pub timestamp_period: f32,
8332 pub max_clip_distances: u32,
8333 pub max_cull_distances: u32,
8334 pub max_combined_clip_and_cull_distances: u32,
8335 pub discrete_queue_priorities: u32,
8336 pub point_size_range: [f32; 2],
8337 pub line_width_range: [f32; 2],
8338 pub point_size_granularity: f32,
8339 pub line_width_granularity: f32,
8340 pub strict_lines: Bool32,
8341 pub standard_sample_locations: Bool32,
8342 pub optimal_buffer_copy_offset_alignment: DeviceSize,
8343 pub optimal_buffer_copy_row_pitch_alignment: DeviceSize,
8344 pub non_coherent_atom_size: DeviceSize,
8345}
8346impl ::std::default::Default for PhysicalDeviceLimits {
8347 fn default() -> Self {
8348 Self {
8349 max_image_dimension1_d: u32::default(),
8350 max_image_dimension2_d: u32::default(),
8351 max_image_dimension3_d: u32::default(),
8352 max_image_dimension_cube: u32::default(),
8353 max_image_array_layers: u32::default(),
8354 max_texel_buffer_elements: u32::default(),
8355 max_uniform_buffer_range: u32::default(),
8356 max_storage_buffer_range: u32::default(),
8357 max_push_constants_size: u32::default(),
8358 max_memory_allocation_count: u32::default(),
8359 max_sampler_allocation_count: u32::default(),
8360 buffer_image_granularity: DeviceSize::default(),
8361 sparse_address_space_size: DeviceSize::default(),
8362 max_bound_descriptor_sets: u32::default(),
8363 max_per_stage_descriptor_samplers: u32::default(),
8364 max_per_stage_descriptor_uniform_buffers: u32::default(),
8365 max_per_stage_descriptor_storage_buffers: u32::default(),
8366 max_per_stage_descriptor_sampled_images: u32::default(),
8367 max_per_stage_descriptor_storage_images: u32::default(),
8368 max_per_stage_descriptor_input_attachments: u32::default(),
8369 max_per_stage_resources: u32::default(),
8370 max_descriptor_set_samplers: u32::default(),
8371 max_descriptor_set_uniform_buffers: u32::default(),
8372 max_descriptor_set_uniform_buffers_dynamic: u32::default(),
8373 max_descriptor_set_storage_buffers: u32::default(),
8374 max_descriptor_set_storage_buffers_dynamic: u32::default(),
8375 max_descriptor_set_sampled_images: u32::default(),
8376 max_descriptor_set_storage_images: u32::default(),
8377 max_descriptor_set_input_attachments: u32::default(),
8378 max_vertex_input_attributes: u32::default(),
8379 max_vertex_input_bindings: u32::default(),
8380 max_vertex_input_attribute_offset: u32::default(),
8381 max_vertex_input_binding_stride: u32::default(),
8382 max_vertex_output_components: u32::default(),
8383 max_tessellation_generation_level: u32::default(),
8384 max_tessellation_patch_size: u32::default(),
8385 max_tessellation_control_per_vertex_input_components: u32::default(),
8386 max_tessellation_control_per_vertex_output_components: u32::default(),
8387 max_tessellation_control_per_patch_output_components: u32::default(),
8388 max_tessellation_control_total_output_components: u32::default(),
8389 max_tessellation_evaluation_input_components: u32::default(),
8390 max_tessellation_evaluation_output_components: u32::default(),
8391 max_geometry_shader_invocations: u32::default(),
8392 max_geometry_input_components: u32::default(),
8393 max_geometry_output_components: u32::default(),
8394 max_geometry_output_vertices: u32::default(),
8395 max_geometry_total_output_components: u32::default(),
8396 max_fragment_input_components: u32::default(),
8397 max_fragment_output_attachments: u32::default(),
8398 max_fragment_dual_src_attachments: u32::default(),
8399 max_fragment_combined_output_resources: u32::default(),
8400 max_compute_shared_memory_size: u32::default(),
8401 max_compute_work_group_count: unsafe { ::std::mem::zeroed() },
8402 max_compute_work_group_invocations: u32::default(),
8403 max_compute_work_group_size: unsafe { ::std::mem::zeroed() },
8404 sub_pixel_precision_bits: u32::default(),
8405 sub_texel_precision_bits: u32::default(),
8406 mipmap_precision_bits: u32::default(),
8407 max_draw_indexed_index_value: u32::default(),
8408 max_draw_indirect_count: u32::default(),
8409 max_sampler_lod_bias: f32::default(),
8410 max_sampler_anisotropy: f32::default(),
8411 max_viewports: u32::default(),
8412 max_viewport_dimensions: unsafe { ::std::mem::zeroed() },
8413 viewport_bounds_range: unsafe { ::std::mem::zeroed() },
8414 viewport_sub_pixel_bits: u32::default(),
8415 min_memory_map_alignment: usize::default(),
8416 min_texel_buffer_offset_alignment: DeviceSize::default(),
8417 min_uniform_buffer_offset_alignment: DeviceSize::default(),
8418 min_storage_buffer_offset_alignment: DeviceSize::default(),
8419 min_texel_offset: i32::default(),
8420 max_texel_offset: u32::default(),
8421 min_texel_gather_offset: i32::default(),
8422 max_texel_gather_offset: u32::default(),
8423 min_interpolation_offset: f32::default(),
8424 max_interpolation_offset: f32::default(),
8425 sub_pixel_interpolation_offset_bits: u32::default(),
8426 max_framebuffer_width: u32::default(),
8427 max_framebuffer_height: u32::default(),
8428 max_framebuffer_layers: u32::default(),
8429 framebuffer_color_sample_counts: SampleCountFlags::default(),
8430 framebuffer_depth_sample_counts: SampleCountFlags::default(),
8431 framebuffer_stencil_sample_counts: SampleCountFlags::default(),
8432 framebuffer_no_attachments_sample_counts: SampleCountFlags::default(),
8433 max_color_attachments: u32::default(),
8434 sampled_image_color_sample_counts: SampleCountFlags::default(),
8435 sampled_image_integer_sample_counts: SampleCountFlags::default(),
8436 sampled_image_depth_sample_counts: SampleCountFlags::default(),
8437 sampled_image_stencil_sample_counts: SampleCountFlags::default(),
8438 storage_image_sample_counts: SampleCountFlags::default(),
8439 max_sample_mask_words: u32::default(),
8440 timestamp_compute_and_graphics: Bool32::default(),
8441 timestamp_period: f32::default(),
8442 max_clip_distances: u32::default(),
8443 max_cull_distances: u32::default(),
8444 max_combined_clip_and_cull_distances: u32::default(),
8445 discrete_queue_priorities: u32::default(),
8446 point_size_range: unsafe { ::std::mem::zeroed() },
8447 line_width_range: unsafe { ::std::mem::zeroed() },
8448 point_size_granularity: f32::default(),
8449 line_width_granularity: f32::default(),
8450 strict_lines: Bool32::default(),
8451 standard_sample_locations: Bool32::default(),
8452 optimal_buffer_copy_offset_alignment: DeviceSize::default(),
8453 optimal_buffer_copy_row_pitch_alignment: DeviceSize::default(),
8454 non_coherent_atom_size: DeviceSize::default(),
8455 }
8456 }
8457}
8458impl PhysicalDeviceLimits {
8459 pub fn builder<'a>() -> PhysicalDeviceLimitsBuilder<'a> {
8460 PhysicalDeviceLimitsBuilder {
8461 inner: Self::default(),
8462 marker: ::std::marker::PhantomData,
8463 }
8464 }
8465}
8466#[repr(transparent)]
8467pub struct PhysicalDeviceLimitsBuilder<'a> {
8468 inner: PhysicalDeviceLimits,
8469 marker: ::std::marker::PhantomData<&'a ()>,
8470}
8471impl<'a> ::std::ops::Deref for PhysicalDeviceLimitsBuilder<'a> {
8472 type Target = PhysicalDeviceLimits;
8473 fn deref(&self) -> &Self::Target {
8474 &self.inner
8475 }
8476}
8477impl<'a> ::std::ops::DerefMut for PhysicalDeviceLimitsBuilder<'a> {
8478 fn deref_mut(&mut self) -> &mut Self::Target {
8479 &mut self.inner
8480 }
8481}
8482impl<'a> PhysicalDeviceLimitsBuilder<'a> {
8483 pub fn max_image_dimension1_d(mut self, max_image_dimension1_d: u32) -> Self {
8484 self.inner.max_image_dimension1_d = max_image_dimension1_d;
8485 self
8486 }
8487 pub fn max_image_dimension2_d(mut self, max_image_dimension2_d: u32) -> Self {
8488 self.inner.max_image_dimension2_d = max_image_dimension2_d;
8489 self
8490 }
8491 pub fn max_image_dimension3_d(mut self, max_image_dimension3_d: u32) -> Self {
8492 self.inner.max_image_dimension3_d = max_image_dimension3_d;
8493 self
8494 }
8495 pub fn max_image_dimension_cube(mut self, max_image_dimension_cube: u32) -> Self {
8496 self.inner.max_image_dimension_cube = max_image_dimension_cube;
8497 self
8498 }
8499 pub fn max_image_array_layers(mut self, max_image_array_layers: u32) -> Self {
8500 self.inner.max_image_array_layers = max_image_array_layers;
8501 self
8502 }
8503 pub fn max_texel_buffer_elements(mut self, max_texel_buffer_elements: u32) -> Self {
8504 self.inner.max_texel_buffer_elements = max_texel_buffer_elements;
8505 self
8506 }
8507 pub fn max_uniform_buffer_range(mut self, max_uniform_buffer_range: u32) -> Self {
8508 self.inner.max_uniform_buffer_range = max_uniform_buffer_range;
8509 self
8510 }
8511 pub fn max_storage_buffer_range(mut self, max_storage_buffer_range: u32) -> Self {
8512 self.inner.max_storage_buffer_range = max_storage_buffer_range;
8513 self
8514 }
8515 pub fn max_push_constants_size(mut self, max_push_constants_size: u32) -> Self {
8516 self.inner.max_push_constants_size = max_push_constants_size;
8517 self
8518 }
8519 pub fn max_memory_allocation_count(mut self, max_memory_allocation_count: u32) -> Self {
8520 self.inner.max_memory_allocation_count = max_memory_allocation_count;
8521 self
8522 }
8523 pub fn max_sampler_allocation_count(mut self, max_sampler_allocation_count: u32) -> Self {
8524 self.inner.max_sampler_allocation_count = max_sampler_allocation_count;
8525 self
8526 }
8527 pub fn buffer_image_granularity(mut self, buffer_image_granularity: DeviceSize) -> Self {
8528 self.inner.buffer_image_granularity = buffer_image_granularity;
8529 self
8530 }
8531 pub fn sparse_address_space_size(mut self, sparse_address_space_size: DeviceSize) -> Self {
8532 self.inner.sparse_address_space_size = sparse_address_space_size;
8533 self
8534 }
8535 pub fn max_bound_descriptor_sets(mut self, max_bound_descriptor_sets: u32) -> Self {
8536 self.inner.max_bound_descriptor_sets = max_bound_descriptor_sets;
8537 self
8538 }
8539 pub fn max_per_stage_descriptor_samplers(
8540 mut self,
8541 max_per_stage_descriptor_samplers: u32,
8542 ) -> Self {
8543 self.inner.max_per_stage_descriptor_samplers = max_per_stage_descriptor_samplers;
8544 self
8545 }
8546 pub fn max_per_stage_descriptor_uniform_buffers(
8547 mut self,
8548 max_per_stage_descriptor_uniform_buffers: u32,
8549 ) -> Self {
8550 self.inner.max_per_stage_descriptor_uniform_buffers =
8551 max_per_stage_descriptor_uniform_buffers;
8552 self
8553 }
8554 pub fn max_per_stage_descriptor_storage_buffers(
8555 mut self,
8556 max_per_stage_descriptor_storage_buffers: u32,
8557 ) -> Self {
8558 self.inner.max_per_stage_descriptor_storage_buffers =
8559 max_per_stage_descriptor_storage_buffers;
8560 self
8561 }
8562 pub fn max_per_stage_descriptor_sampled_images(
8563 mut self,
8564 max_per_stage_descriptor_sampled_images: u32,
8565 ) -> Self {
8566 self.inner.max_per_stage_descriptor_sampled_images =
8567 max_per_stage_descriptor_sampled_images;
8568 self
8569 }
8570 pub fn max_per_stage_descriptor_storage_images(
8571 mut self,
8572 max_per_stage_descriptor_storage_images: u32,
8573 ) -> Self {
8574 self.inner.max_per_stage_descriptor_storage_images =
8575 max_per_stage_descriptor_storage_images;
8576 self
8577 }
8578 pub fn max_per_stage_descriptor_input_attachments(
8579 mut self,
8580 max_per_stage_descriptor_input_attachments: u32,
8581 ) -> Self {
8582 self.inner.max_per_stage_descriptor_input_attachments =
8583 max_per_stage_descriptor_input_attachments;
8584 self
8585 }
8586 pub fn max_per_stage_resources(mut self, max_per_stage_resources: u32) -> Self {
8587 self.inner.max_per_stage_resources = max_per_stage_resources;
8588 self
8589 }
8590 pub fn max_descriptor_set_samplers(mut self, max_descriptor_set_samplers: u32) -> Self {
8591 self.inner.max_descriptor_set_samplers = max_descriptor_set_samplers;
8592 self
8593 }
8594 pub fn max_descriptor_set_uniform_buffers(
8595 mut self,
8596 max_descriptor_set_uniform_buffers: u32,
8597 ) -> Self {
8598 self.inner.max_descriptor_set_uniform_buffers = max_descriptor_set_uniform_buffers;
8599 self
8600 }
8601 pub fn max_descriptor_set_uniform_buffers_dynamic(
8602 mut self,
8603 max_descriptor_set_uniform_buffers_dynamic: u32,
8604 ) -> Self {
8605 self.inner.max_descriptor_set_uniform_buffers_dynamic =
8606 max_descriptor_set_uniform_buffers_dynamic;
8607 self
8608 }
8609 pub fn max_descriptor_set_storage_buffers(
8610 mut self,
8611 max_descriptor_set_storage_buffers: u32,
8612 ) -> Self {
8613 self.inner.max_descriptor_set_storage_buffers = max_descriptor_set_storage_buffers;
8614 self
8615 }
8616 pub fn max_descriptor_set_storage_buffers_dynamic(
8617 mut self,
8618 max_descriptor_set_storage_buffers_dynamic: u32,
8619 ) -> Self {
8620 self.inner.max_descriptor_set_storage_buffers_dynamic =
8621 max_descriptor_set_storage_buffers_dynamic;
8622 self
8623 }
8624 pub fn max_descriptor_set_sampled_images(
8625 mut self,
8626 max_descriptor_set_sampled_images: u32,
8627 ) -> Self {
8628 self.inner.max_descriptor_set_sampled_images = max_descriptor_set_sampled_images;
8629 self
8630 }
8631 pub fn max_descriptor_set_storage_images(
8632 mut self,
8633 max_descriptor_set_storage_images: u32,
8634 ) -> Self {
8635 self.inner.max_descriptor_set_storage_images = max_descriptor_set_storage_images;
8636 self
8637 }
8638 pub fn max_descriptor_set_input_attachments(
8639 mut self,
8640 max_descriptor_set_input_attachments: u32,
8641 ) -> Self {
8642 self.inner.max_descriptor_set_input_attachments = max_descriptor_set_input_attachments;
8643 self
8644 }
8645 pub fn max_vertex_input_attributes(mut self, max_vertex_input_attributes: u32) -> Self {
8646 self.inner.max_vertex_input_attributes = max_vertex_input_attributes;
8647 self
8648 }
8649 pub fn max_vertex_input_bindings(mut self, max_vertex_input_bindings: u32) -> Self {
8650 self.inner.max_vertex_input_bindings = max_vertex_input_bindings;
8651 self
8652 }
8653 pub fn max_vertex_input_attribute_offset(
8654 mut self,
8655 max_vertex_input_attribute_offset: u32,
8656 ) -> Self {
8657 self.inner.max_vertex_input_attribute_offset = max_vertex_input_attribute_offset;
8658 self
8659 }
8660 pub fn max_vertex_input_binding_stride(mut self, max_vertex_input_binding_stride: u32) -> Self {
8661 self.inner.max_vertex_input_binding_stride = max_vertex_input_binding_stride;
8662 self
8663 }
8664 pub fn max_vertex_output_components(mut self, max_vertex_output_components: u32) -> Self {
8665 self.inner.max_vertex_output_components = max_vertex_output_components;
8666 self
8667 }
8668 pub fn max_tessellation_generation_level(
8669 mut self,
8670 max_tessellation_generation_level: u32,
8671 ) -> Self {
8672 self.inner.max_tessellation_generation_level = max_tessellation_generation_level;
8673 self
8674 }
8675 pub fn max_tessellation_patch_size(mut self, max_tessellation_patch_size: u32) -> Self {
8676 self.inner.max_tessellation_patch_size = max_tessellation_patch_size;
8677 self
8678 }
8679 pub fn max_tessellation_control_per_vertex_input_components(
8680 mut self,
8681 max_tessellation_control_per_vertex_input_components: u32,
8682 ) -> Self {
8683 self.inner
8684 .max_tessellation_control_per_vertex_input_components =
8685 max_tessellation_control_per_vertex_input_components;
8686 self
8687 }
8688 pub fn max_tessellation_control_per_vertex_output_components(
8689 mut self,
8690 max_tessellation_control_per_vertex_output_components: u32,
8691 ) -> Self {
8692 self.inner
8693 .max_tessellation_control_per_vertex_output_components =
8694 max_tessellation_control_per_vertex_output_components;
8695 self
8696 }
8697 pub fn max_tessellation_control_per_patch_output_components(
8698 mut self,
8699 max_tessellation_control_per_patch_output_components: u32,
8700 ) -> Self {
8701 self.inner
8702 .max_tessellation_control_per_patch_output_components =
8703 max_tessellation_control_per_patch_output_components;
8704 self
8705 }
8706 pub fn max_tessellation_control_total_output_components(
8707 mut self,
8708 max_tessellation_control_total_output_components: u32,
8709 ) -> Self {
8710 self.inner.max_tessellation_control_total_output_components =
8711 max_tessellation_control_total_output_components;
8712 self
8713 }
8714 pub fn max_tessellation_evaluation_input_components(
8715 mut self,
8716 max_tessellation_evaluation_input_components: u32,
8717 ) -> Self {
8718 self.inner.max_tessellation_evaluation_input_components =
8719 max_tessellation_evaluation_input_components;
8720 self
8721 }
8722 pub fn max_tessellation_evaluation_output_components(
8723 mut self,
8724 max_tessellation_evaluation_output_components: u32,
8725 ) -> Self {
8726 self.inner.max_tessellation_evaluation_output_components =
8727 max_tessellation_evaluation_output_components;
8728 self
8729 }
8730 pub fn max_geometry_shader_invocations(mut self, max_geometry_shader_invocations: u32) -> Self {
8731 self.inner.max_geometry_shader_invocations = max_geometry_shader_invocations;
8732 self
8733 }
8734 pub fn max_geometry_input_components(mut self, max_geometry_input_components: u32) -> Self {
8735 self.inner.max_geometry_input_components = max_geometry_input_components;
8736 self
8737 }
8738 pub fn max_geometry_output_components(mut self, max_geometry_output_components: u32) -> Self {
8739 self.inner.max_geometry_output_components = max_geometry_output_components;
8740 self
8741 }
8742 pub fn max_geometry_output_vertices(mut self, max_geometry_output_vertices: u32) -> Self {
8743 self.inner.max_geometry_output_vertices = max_geometry_output_vertices;
8744 self
8745 }
8746 pub fn max_geometry_total_output_components(
8747 mut self,
8748 max_geometry_total_output_components: u32,
8749 ) -> Self {
8750 self.inner.max_geometry_total_output_components = max_geometry_total_output_components;
8751 self
8752 }
8753 pub fn max_fragment_input_components(mut self, max_fragment_input_components: u32) -> Self {
8754 self.inner.max_fragment_input_components = max_fragment_input_components;
8755 self
8756 }
8757 pub fn max_fragment_output_attachments(mut self, max_fragment_output_attachments: u32) -> Self {
8758 self.inner.max_fragment_output_attachments = max_fragment_output_attachments;
8759 self
8760 }
8761 pub fn max_fragment_dual_src_attachments(
8762 mut self,
8763 max_fragment_dual_src_attachments: u32,
8764 ) -> Self {
8765 self.inner.max_fragment_dual_src_attachments = max_fragment_dual_src_attachments;
8766 self
8767 }
8768 pub fn max_fragment_combined_output_resources(
8769 mut self,
8770 max_fragment_combined_output_resources: u32,
8771 ) -> Self {
8772 self.inner.max_fragment_combined_output_resources = max_fragment_combined_output_resources;
8773 self
8774 }
8775 pub fn max_compute_shared_memory_size(mut self, max_compute_shared_memory_size: u32) -> Self {
8776 self.inner.max_compute_shared_memory_size = max_compute_shared_memory_size;
8777 self
8778 }
8779 pub fn max_compute_work_group_count(mut self, max_compute_work_group_count: [u32; 3]) -> Self {
8780 self.inner.max_compute_work_group_count = max_compute_work_group_count;
8781 self
8782 }
8783 pub fn max_compute_work_group_invocations(
8784 mut self,
8785 max_compute_work_group_invocations: u32,
8786 ) -> Self {
8787 self.inner.max_compute_work_group_invocations = max_compute_work_group_invocations;
8788 self
8789 }
8790 pub fn max_compute_work_group_size(mut self, max_compute_work_group_size: [u32; 3]) -> Self {
8791 self.inner.max_compute_work_group_size = max_compute_work_group_size;
8792 self
8793 }
8794 pub fn sub_pixel_precision_bits(mut self, sub_pixel_precision_bits: u32) -> Self {
8795 self.inner.sub_pixel_precision_bits = sub_pixel_precision_bits;
8796 self
8797 }
8798 pub fn sub_texel_precision_bits(mut self, sub_texel_precision_bits: u32) -> Self {
8799 self.inner.sub_texel_precision_bits = sub_texel_precision_bits;
8800 self
8801 }
8802 pub fn mipmap_precision_bits(mut self, mipmap_precision_bits: u32) -> Self {
8803 self.inner.mipmap_precision_bits = mipmap_precision_bits;
8804 self
8805 }
8806 pub fn max_draw_indexed_index_value(mut self, max_draw_indexed_index_value: u32) -> Self {
8807 self.inner.max_draw_indexed_index_value = max_draw_indexed_index_value;
8808 self
8809 }
8810 pub fn max_draw_indirect_count(mut self, max_draw_indirect_count: u32) -> Self {
8811 self.inner.max_draw_indirect_count = max_draw_indirect_count;
8812 self
8813 }
8814 pub fn max_sampler_lod_bias(mut self, max_sampler_lod_bias: f32) -> Self {
8815 self.inner.max_sampler_lod_bias = max_sampler_lod_bias;
8816 self
8817 }
8818 pub fn max_sampler_anisotropy(mut self, max_sampler_anisotropy: f32) -> Self {
8819 self.inner.max_sampler_anisotropy = max_sampler_anisotropy;
8820 self
8821 }
8822 pub fn max_viewports(mut self, max_viewports: u32) -> Self {
8823 self.inner.max_viewports = max_viewports;
8824 self
8825 }
8826 pub fn max_viewport_dimensions(mut self, max_viewport_dimensions: [u32; 2]) -> Self {
8827 self.inner.max_viewport_dimensions = max_viewport_dimensions;
8828 self
8829 }
8830 pub fn viewport_bounds_range(mut self, viewport_bounds_range: [f32; 2]) -> Self {
8831 self.inner.viewport_bounds_range = viewport_bounds_range;
8832 self
8833 }
8834 pub fn viewport_sub_pixel_bits(mut self, viewport_sub_pixel_bits: u32) -> Self {
8835 self.inner.viewport_sub_pixel_bits = viewport_sub_pixel_bits;
8836 self
8837 }
8838 pub fn min_memory_map_alignment(mut self, min_memory_map_alignment: usize) -> Self {
8839 self.inner.min_memory_map_alignment = min_memory_map_alignment;
8840 self
8841 }
8842 pub fn min_texel_buffer_offset_alignment(
8843 mut self,
8844 min_texel_buffer_offset_alignment: DeviceSize,
8845 ) -> Self {
8846 self.inner.min_texel_buffer_offset_alignment = min_texel_buffer_offset_alignment;
8847 self
8848 }
8849 pub fn min_uniform_buffer_offset_alignment(
8850 mut self,
8851 min_uniform_buffer_offset_alignment: DeviceSize,
8852 ) -> Self {
8853 self.inner.min_uniform_buffer_offset_alignment = min_uniform_buffer_offset_alignment;
8854 self
8855 }
8856 pub fn min_storage_buffer_offset_alignment(
8857 mut self,
8858 min_storage_buffer_offset_alignment: DeviceSize,
8859 ) -> Self {
8860 self.inner.min_storage_buffer_offset_alignment = min_storage_buffer_offset_alignment;
8861 self
8862 }
8863 pub fn min_texel_offset(mut self, min_texel_offset: i32) -> Self {
8864 self.inner.min_texel_offset = min_texel_offset;
8865 self
8866 }
8867 pub fn max_texel_offset(mut self, max_texel_offset: u32) -> Self {
8868 self.inner.max_texel_offset = max_texel_offset;
8869 self
8870 }
8871 pub fn min_texel_gather_offset(mut self, min_texel_gather_offset: i32) -> Self {
8872 self.inner.min_texel_gather_offset = min_texel_gather_offset;
8873 self
8874 }
8875 pub fn max_texel_gather_offset(mut self, max_texel_gather_offset: u32) -> Self {
8876 self.inner.max_texel_gather_offset = max_texel_gather_offset;
8877 self
8878 }
8879 pub fn min_interpolation_offset(mut self, min_interpolation_offset: f32) -> Self {
8880 self.inner.min_interpolation_offset = min_interpolation_offset;
8881 self
8882 }
8883 pub fn max_interpolation_offset(mut self, max_interpolation_offset: f32) -> Self {
8884 self.inner.max_interpolation_offset = max_interpolation_offset;
8885 self
8886 }
8887 pub fn sub_pixel_interpolation_offset_bits(
8888 mut self,
8889 sub_pixel_interpolation_offset_bits: u32,
8890 ) -> Self {
8891 self.inner.sub_pixel_interpolation_offset_bits = sub_pixel_interpolation_offset_bits;
8892 self
8893 }
8894 pub fn max_framebuffer_width(mut self, max_framebuffer_width: u32) -> Self {
8895 self.inner.max_framebuffer_width = max_framebuffer_width;
8896 self
8897 }
8898 pub fn max_framebuffer_height(mut self, max_framebuffer_height: u32) -> Self {
8899 self.inner.max_framebuffer_height = max_framebuffer_height;
8900 self
8901 }
8902 pub fn max_framebuffer_layers(mut self, max_framebuffer_layers: u32) -> Self {
8903 self.inner.max_framebuffer_layers = max_framebuffer_layers;
8904 self
8905 }
8906 pub fn framebuffer_color_sample_counts(
8907 mut self,
8908 framebuffer_color_sample_counts: SampleCountFlags,
8909 ) -> Self {
8910 self.inner.framebuffer_color_sample_counts = framebuffer_color_sample_counts;
8911 self
8912 }
8913 pub fn framebuffer_depth_sample_counts(
8914 mut self,
8915 framebuffer_depth_sample_counts: SampleCountFlags,
8916 ) -> Self {
8917 self.inner.framebuffer_depth_sample_counts = framebuffer_depth_sample_counts;
8918 self
8919 }
8920 pub fn framebuffer_stencil_sample_counts(
8921 mut self,
8922 framebuffer_stencil_sample_counts: SampleCountFlags,
8923 ) -> Self {
8924 self.inner.framebuffer_stencil_sample_counts = framebuffer_stencil_sample_counts;
8925 self
8926 }
8927 pub fn framebuffer_no_attachments_sample_counts(
8928 mut self,
8929 framebuffer_no_attachments_sample_counts: SampleCountFlags,
8930 ) -> Self {
8931 self.inner.framebuffer_no_attachments_sample_counts =
8932 framebuffer_no_attachments_sample_counts;
8933 self
8934 }
8935 pub fn max_color_attachments(mut self, max_color_attachments: u32) -> Self {
8936 self.inner.max_color_attachments = max_color_attachments;
8937 self
8938 }
8939 pub fn sampled_image_color_sample_counts(
8940 mut self,
8941 sampled_image_color_sample_counts: SampleCountFlags,
8942 ) -> Self {
8943 self.inner.sampled_image_color_sample_counts = sampled_image_color_sample_counts;
8944 self
8945 }
8946 pub fn sampled_image_integer_sample_counts(
8947 mut self,
8948 sampled_image_integer_sample_counts: SampleCountFlags,
8949 ) -> Self {
8950 self.inner.sampled_image_integer_sample_counts = sampled_image_integer_sample_counts;
8951 self
8952 }
8953 pub fn sampled_image_depth_sample_counts(
8954 mut self,
8955 sampled_image_depth_sample_counts: SampleCountFlags,
8956 ) -> Self {
8957 self.inner.sampled_image_depth_sample_counts = sampled_image_depth_sample_counts;
8958 self
8959 }
8960 pub fn sampled_image_stencil_sample_counts(
8961 mut self,
8962 sampled_image_stencil_sample_counts: SampleCountFlags,
8963 ) -> Self {
8964 self.inner.sampled_image_stencil_sample_counts = sampled_image_stencil_sample_counts;
8965 self
8966 }
8967 pub fn storage_image_sample_counts(
8968 mut self,
8969 storage_image_sample_counts: SampleCountFlags,
8970 ) -> Self {
8971 self.inner.storage_image_sample_counts = storage_image_sample_counts;
8972 self
8973 }
8974 pub fn max_sample_mask_words(mut self, max_sample_mask_words: u32) -> Self {
8975 self.inner.max_sample_mask_words = max_sample_mask_words;
8976 self
8977 }
8978 pub fn timestamp_compute_and_graphics(mut self, timestamp_compute_and_graphics: bool) -> Self {
8979 self.inner.timestamp_compute_and_graphics = timestamp_compute_and_graphics.into();
8980 self
8981 }
8982 pub fn timestamp_period(mut self, timestamp_period: f32) -> Self {
8983 self.inner.timestamp_period = timestamp_period;
8984 self
8985 }
8986 pub fn max_clip_distances(mut self, max_clip_distances: u32) -> Self {
8987 self.inner.max_clip_distances = max_clip_distances;
8988 self
8989 }
8990 pub fn max_cull_distances(mut self, max_cull_distances: u32) -> Self {
8991 self.inner.max_cull_distances = max_cull_distances;
8992 self
8993 }
8994 pub fn max_combined_clip_and_cull_distances(
8995 mut self,
8996 max_combined_clip_and_cull_distances: u32,
8997 ) -> Self {
8998 self.inner.max_combined_clip_and_cull_distances = max_combined_clip_and_cull_distances;
8999 self
9000 }
9001 pub fn discrete_queue_priorities(mut self, discrete_queue_priorities: u32) -> Self {
9002 self.inner.discrete_queue_priorities = discrete_queue_priorities;
9003 self
9004 }
9005 pub fn point_size_range(mut self, point_size_range: [f32; 2]) -> Self {
9006 self.inner.point_size_range = point_size_range;
9007 self
9008 }
9009 pub fn line_width_range(mut self, line_width_range: [f32; 2]) -> Self {
9010 self.inner.line_width_range = line_width_range;
9011 self
9012 }
9013 pub fn point_size_granularity(mut self, point_size_granularity: f32) -> Self {
9014 self.inner.point_size_granularity = point_size_granularity;
9015 self
9016 }
9017 pub fn line_width_granularity(mut self, line_width_granularity: f32) -> Self {
9018 self.inner.line_width_granularity = line_width_granularity;
9019 self
9020 }
9021 pub fn strict_lines(mut self, strict_lines: bool) -> Self {
9022 self.inner.strict_lines = strict_lines.into();
9023 self
9024 }
9025 pub fn standard_sample_locations(mut self, standard_sample_locations: bool) -> Self {
9026 self.inner.standard_sample_locations = standard_sample_locations.into();
9027 self
9028 }
9029 pub fn optimal_buffer_copy_offset_alignment(
9030 mut self,
9031 optimal_buffer_copy_offset_alignment: DeviceSize,
9032 ) -> Self {
9033 self.inner.optimal_buffer_copy_offset_alignment = optimal_buffer_copy_offset_alignment;
9034 self
9035 }
9036 pub fn optimal_buffer_copy_row_pitch_alignment(
9037 mut self,
9038 optimal_buffer_copy_row_pitch_alignment: DeviceSize,
9039 ) -> Self {
9040 self.inner.optimal_buffer_copy_row_pitch_alignment =
9041 optimal_buffer_copy_row_pitch_alignment;
9042 self
9043 }
9044 pub fn non_coherent_atom_size(mut self, non_coherent_atom_size: DeviceSize) -> Self {
9045 self.inner.non_coherent_atom_size = non_coherent_atom_size;
9046 self
9047 }
9048 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9049 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9050 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9051 pub fn build(self) -> PhysicalDeviceLimits {
9052 self.inner
9053 }
9054}
9055#[repr(C)]
9056#[cfg_attr(feature = "debug", derive(Debug))]
9057#[derive(Copy, Clone)]
9058#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreCreateInfo.html>"]
9059pub struct SemaphoreCreateInfo {
9060 pub s_type: StructureType,
9061 pub p_next: *const c_void,
9062 pub flags: SemaphoreCreateFlags,
9063}
9064impl ::std::default::Default for SemaphoreCreateInfo {
9065 fn default() -> Self {
9066 Self {
9067 s_type: StructureType::SEMAPHORE_CREATE_INFO,
9068 p_next: ::std::ptr::null(),
9069 flags: SemaphoreCreateFlags::default(),
9070 }
9071 }
9072}
9073impl SemaphoreCreateInfo {
9074 pub fn builder<'a>() -> SemaphoreCreateInfoBuilder<'a> {
9075 SemaphoreCreateInfoBuilder {
9076 inner: Self::default(),
9077 marker: ::std::marker::PhantomData,
9078 }
9079 }
9080}
9081#[repr(transparent)]
9082pub struct SemaphoreCreateInfoBuilder<'a> {
9083 inner: SemaphoreCreateInfo,
9084 marker: ::std::marker::PhantomData<&'a ()>,
9085}
9086pub unsafe trait ExtendsSemaphoreCreateInfo {}
9087impl<'a> ::std::ops::Deref for SemaphoreCreateInfoBuilder<'a> {
9088 type Target = SemaphoreCreateInfo;
9089 fn deref(&self) -> &Self::Target {
9090 &self.inner
9091 }
9092}
9093impl<'a> ::std::ops::DerefMut for SemaphoreCreateInfoBuilder<'a> {
9094 fn deref_mut(&mut self) -> &mut Self::Target {
9095 &mut self.inner
9096 }
9097}
9098impl<'a> SemaphoreCreateInfoBuilder<'a> {
9099 pub fn flags(mut self, flags: SemaphoreCreateFlags) -> Self {
9100 self.inner.flags = flags;
9101 self
9102 }
9103 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
9104 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
9105 #[doc = r" valid extension structs can be pushed into the chain."]
9106 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
9107 #[doc = r" chain will look like `A -> D -> B -> C`."]
9108 pub fn push_next<T: ExtendsSemaphoreCreateInfo>(mut self, next: &'a mut T) -> Self {
9109 unsafe {
9110 let next_ptr = <*const T>::cast(next);
9111 let last_next = ptr_chain_iter(next).last().unwrap();
9112 (*last_next).p_next = self.inner.p_next as _;
9113 self.inner.p_next = next_ptr;
9114 }
9115 self
9116 }
9117 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9118 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9119 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9120 pub fn build(self) -> SemaphoreCreateInfo {
9121 self.inner
9122 }
9123}
9124#[repr(C)]
9125#[cfg_attr(feature = "debug", derive(Debug))]
9126#[derive(Copy, Clone)]
9127#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPoolCreateInfo.html>"]
9128pub struct QueryPoolCreateInfo {
9129 pub s_type: StructureType,
9130 pub p_next: *const c_void,
9131 pub flags: QueryPoolCreateFlags,
9132 pub query_type: QueryType,
9133 pub query_count: u32,
9134 pub pipeline_statistics: QueryPipelineStatisticFlags,
9135}
9136impl ::std::default::Default for QueryPoolCreateInfo {
9137 fn default() -> Self {
9138 Self {
9139 s_type: StructureType::QUERY_POOL_CREATE_INFO,
9140 p_next: ::std::ptr::null(),
9141 flags: QueryPoolCreateFlags::default(),
9142 query_type: QueryType::default(),
9143 query_count: u32::default(),
9144 pipeline_statistics: QueryPipelineStatisticFlags::default(),
9145 }
9146 }
9147}
9148impl QueryPoolCreateInfo {
9149 pub fn builder<'a>() -> QueryPoolCreateInfoBuilder<'a> {
9150 QueryPoolCreateInfoBuilder {
9151 inner: Self::default(),
9152 marker: ::std::marker::PhantomData,
9153 }
9154 }
9155}
9156#[repr(transparent)]
9157pub struct QueryPoolCreateInfoBuilder<'a> {
9158 inner: QueryPoolCreateInfo,
9159 marker: ::std::marker::PhantomData<&'a ()>,
9160}
9161pub unsafe trait ExtendsQueryPoolCreateInfo {}
9162impl<'a> ::std::ops::Deref for QueryPoolCreateInfoBuilder<'a> {
9163 type Target = QueryPoolCreateInfo;
9164 fn deref(&self) -> &Self::Target {
9165 &self.inner
9166 }
9167}
9168impl<'a> ::std::ops::DerefMut for QueryPoolCreateInfoBuilder<'a> {
9169 fn deref_mut(&mut self) -> &mut Self::Target {
9170 &mut self.inner
9171 }
9172}
9173impl<'a> QueryPoolCreateInfoBuilder<'a> {
9174 pub fn flags(mut self, flags: QueryPoolCreateFlags) -> Self {
9175 self.inner.flags = flags;
9176 self
9177 }
9178 pub fn query_type(mut self, query_type: QueryType) -> Self {
9179 self.inner.query_type = query_type;
9180 self
9181 }
9182 pub fn query_count(mut self, query_count: u32) -> Self {
9183 self.inner.query_count = query_count;
9184 self
9185 }
9186 pub fn pipeline_statistics(mut self, pipeline_statistics: QueryPipelineStatisticFlags) -> Self {
9187 self.inner.pipeline_statistics = pipeline_statistics;
9188 self
9189 }
9190 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
9191 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
9192 #[doc = r" valid extension structs can be pushed into the chain."]
9193 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
9194 #[doc = r" chain will look like `A -> D -> B -> C`."]
9195 pub fn push_next<T: ExtendsQueryPoolCreateInfo>(mut self, next: &'a mut T) -> Self {
9196 unsafe {
9197 let next_ptr = <*const T>::cast(next);
9198 let last_next = ptr_chain_iter(next).last().unwrap();
9199 (*last_next).p_next = self.inner.p_next as _;
9200 self.inner.p_next = next_ptr;
9201 }
9202 self
9203 }
9204 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9205 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9206 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9207 pub fn build(self) -> QueryPoolCreateInfo {
9208 self.inner
9209 }
9210}
9211#[repr(C)]
9212#[cfg_attr(feature = "debug", derive(Debug))]
9213#[derive(Copy, Clone)]
9214#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebufferCreateInfo.html>"]
9215pub struct FramebufferCreateInfo {
9216 pub s_type: StructureType,
9217 pub p_next: *const c_void,
9218 pub flags: FramebufferCreateFlags,
9219 pub render_pass: RenderPass,
9220 pub attachment_count: u32,
9221 pub p_attachments: *const ImageView,
9222 pub width: u32,
9223 pub height: u32,
9224 pub layers: u32,
9225}
9226impl ::std::default::Default for FramebufferCreateInfo {
9227 fn default() -> Self {
9228 Self {
9229 s_type: StructureType::FRAMEBUFFER_CREATE_INFO,
9230 p_next: ::std::ptr::null(),
9231 flags: FramebufferCreateFlags::default(),
9232 render_pass: RenderPass::default(),
9233 attachment_count: u32::default(),
9234 p_attachments: ::std::ptr::null(),
9235 width: u32::default(),
9236 height: u32::default(),
9237 layers: u32::default(),
9238 }
9239 }
9240}
9241impl FramebufferCreateInfo {
9242 pub fn builder<'a>() -> FramebufferCreateInfoBuilder<'a> {
9243 FramebufferCreateInfoBuilder {
9244 inner: Self::default(),
9245 marker: ::std::marker::PhantomData,
9246 }
9247 }
9248}
9249#[repr(transparent)]
9250pub struct FramebufferCreateInfoBuilder<'a> {
9251 inner: FramebufferCreateInfo,
9252 marker: ::std::marker::PhantomData<&'a ()>,
9253}
9254pub unsafe trait ExtendsFramebufferCreateInfo {}
9255impl<'a> ::std::ops::Deref for FramebufferCreateInfoBuilder<'a> {
9256 type Target = FramebufferCreateInfo;
9257 fn deref(&self) -> &Self::Target {
9258 &self.inner
9259 }
9260}
9261impl<'a> ::std::ops::DerefMut for FramebufferCreateInfoBuilder<'a> {
9262 fn deref_mut(&mut self) -> &mut Self::Target {
9263 &mut self.inner
9264 }
9265}
9266impl<'a> FramebufferCreateInfoBuilder<'a> {
9267 pub fn flags(mut self, flags: FramebufferCreateFlags) -> Self {
9268 self.inner.flags = flags;
9269 self
9270 }
9271 pub fn render_pass(mut self, render_pass: RenderPass) -> Self {
9272 self.inner.render_pass = render_pass;
9273 self
9274 }
9275 pub fn attachments(mut self, attachments: &'a [ImageView]) -> Self {
9276 self.inner.attachment_count = attachments.len() as _;
9277 self.inner.p_attachments = attachments.as_ptr();
9278 self
9279 }
9280 pub fn width(mut self, width: u32) -> Self {
9281 self.inner.width = width;
9282 self
9283 }
9284 pub fn height(mut self, height: u32) -> Self {
9285 self.inner.height = height;
9286 self
9287 }
9288 pub fn layers(mut self, layers: u32) -> Self {
9289 self.inner.layers = layers;
9290 self
9291 }
9292 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
9293 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
9294 #[doc = r" valid extension structs can be pushed into the chain."]
9295 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
9296 #[doc = r" chain will look like `A -> D -> B -> C`."]
9297 pub fn push_next<T: ExtendsFramebufferCreateInfo>(mut self, next: &'a mut T) -> Self {
9298 unsafe {
9299 let next_ptr = <*const T>::cast(next);
9300 let last_next = ptr_chain_iter(next).last().unwrap();
9301 (*last_next).p_next = self.inner.p_next as _;
9302 self.inner.p_next = next_ptr;
9303 }
9304 self
9305 }
9306 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9307 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9308 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9309 pub fn build(self) -> FramebufferCreateInfo {
9310 self.inner
9311 }
9312}
9313#[repr(C)]
9314#[cfg_attr(feature = "debug", derive(Debug))]
9315#[derive(Copy, Clone, Default)]
9316#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrawIndirectCommand.html>"]
9317pub struct DrawIndirectCommand {
9318 pub vertex_count: u32,
9319 pub instance_count: u32,
9320 pub first_vertex: u32,
9321 pub first_instance: u32,
9322}
9323impl DrawIndirectCommand {
9324 pub fn builder<'a>() -> DrawIndirectCommandBuilder<'a> {
9325 DrawIndirectCommandBuilder {
9326 inner: Self::default(),
9327 marker: ::std::marker::PhantomData,
9328 }
9329 }
9330}
9331#[repr(transparent)]
9332pub struct DrawIndirectCommandBuilder<'a> {
9333 inner: DrawIndirectCommand,
9334 marker: ::std::marker::PhantomData<&'a ()>,
9335}
9336impl<'a> ::std::ops::Deref for DrawIndirectCommandBuilder<'a> {
9337 type Target = DrawIndirectCommand;
9338 fn deref(&self) -> &Self::Target {
9339 &self.inner
9340 }
9341}
9342impl<'a> ::std::ops::DerefMut for DrawIndirectCommandBuilder<'a> {
9343 fn deref_mut(&mut self) -> &mut Self::Target {
9344 &mut self.inner
9345 }
9346}
9347impl<'a> DrawIndirectCommandBuilder<'a> {
9348 pub fn vertex_count(mut self, vertex_count: u32) -> Self {
9349 self.inner.vertex_count = vertex_count;
9350 self
9351 }
9352 pub fn instance_count(mut self, instance_count: u32) -> Self {
9353 self.inner.instance_count = instance_count;
9354 self
9355 }
9356 pub fn first_vertex(mut self, first_vertex: u32) -> Self {
9357 self.inner.first_vertex = first_vertex;
9358 self
9359 }
9360 pub fn first_instance(mut self, first_instance: u32) -> Self {
9361 self.inner.first_instance = first_instance;
9362 self
9363 }
9364 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9365 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9366 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9367 pub fn build(self) -> DrawIndirectCommand {
9368 self.inner
9369 }
9370}
9371#[repr(C)]
9372#[cfg_attr(feature = "debug", derive(Debug))]
9373#[derive(Copy, Clone, Default)]
9374#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrawIndexedIndirectCommand.html>"]
9375pub struct DrawIndexedIndirectCommand {
9376 pub index_count: u32,
9377 pub instance_count: u32,
9378 pub first_index: u32,
9379 pub vertex_offset: i32,
9380 pub first_instance: u32,
9381}
9382impl DrawIndexedIndirectCommand {
9383 pub fn builder<'a>() -> DrawIndexedIndirectCommandBuilder<'a> {
9384 DrawIndexedIndirectCommandBuilder {
9385 inner: Self::default(),
9386 marker: ::std::marker::PhantomData,
9387 }
9388 }
9389}
9390#[repr(transparent)]
9391pub struct DrawIndexedIndirectCommandBuilder<'a> {
9392 inner: DrawIndexedIndirectCommand,
9393 marker: ::std::marker::PhantomData<&'a ()>,
9394}
9395impl<'a> ::std::ops::Deref for DrawIndexedIndirectCommandBuilder<'a> {
9396 type Target = DrawIndexedIndirectCommand;
9397 fn deref(&self) -> &Self::Target {
9398 &self.inner
9399 }
9400}
9401impl<'a> ::std::ops::DerefMut for DrawIndexedIndirectCommandBuilder<'a> {
9402 fn deref_mut(&mut self) -> &mut Self::Target {
9403 &mut self.inner
9404 }
9405}
9406impl<'a> DrawIndexedIndirectCommandBuilder<'a> {
9407 pub fn index_count(mut self, index_count: u32) -> Self {
9408 self.inner.index_count = index_count;
9409 self
9410 }
9411 pub fn instance_count(mut self, instance_count: u32) -> Self {
9412 self.inner.instance_count = instance_count;
9413 self
9414 }
9415 pub fn first_index(mut self, first_index: u32) -> Self {
9416 self.inner.first_index = first_index;
9417 self
9418 }
9419 pub fn vertex_offset(mut self, vertex_offset: i32) -> Self {
9420 self.inner.vertex_offset = vertex_offset;
9421 self
9422 }
9423 pub fn first_instance(mut self, first_instance: u32) -> Self {
9424 self.inner.first_instance = first_instance;
9425 self
9426 }
9427 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9428 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9429 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9430 pub fn build(self) -> DrawIndexedIndirectCommand {
9431 self.inner
9432 }
9433}
9434#[repr(C)]
9435#[cfg_attr(feature = "debug", derive(Debug))]
9436#[derive(Copy, Clone, Default)]
9437#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDispatchIndirectCommand.html>"]
9438pub struct DispatchIndirectCommand {
9439 pub x: u32,
9440 pub y: u32,
9441 pub z: u32,
9442}
9443impl DispatchIndirectCommand {
9444 pub fn builder<'a>() -> DispatchIndirectCommandBuilder<'a> {
9445 DispatchIndirectCommandBuilder {
9446 inner: Self::default(),
9447 marker: ::std::marker::PhantomData,
9448 }
9449 }
9450}
9451#[repr(transparent)]
9452pub struct DispatchIndirectCommandBuilder<'a> {
9453 inner: DispatchIndirectCommand,
9454 marker: ::std::marker::PhantomData<&'a ()>,
9455}
9456impl<'a> ::std::ops::Deref for DispatchIndirectCommandBuilder<'a> {
9457 type Target = DispatchIndirectCommand;
9458 fn deref(&self) -> &Self::Target {
9459 &self.inner
9460 }
9461}
9462impl<'a> ::std::ops::DerefMut for DispatchIndirectCommandBuilder<'a> {
9463 fn deref_mut(&mut self) -> &mut Self::Target {
9464 &mut self.inner
9465 }
9466}
9467impl<'a> DispatchIndirectCommandBuilder<'a> {
9468 pub fn x(mut self, x: u32) -> Self {
9469 self.inner.x = x;
9470 self
9471 }
9472 pub fn y(mut self, y: u32) -> Self {
9473 self.inner.y = y;
9474 self
9475 }
9476 pub fn z(mut self, z: u32) -> Self {
9477 self.inner.z = z;
9478 self
9479 }
9480 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9481 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9482 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9483 pub fn build(self) -> DispatchIndirectCommand {
9484 self.inner
9485 }
9486}
9487#[repr(C)]
9488#[cfg_attr(feature = "debug", derive(Debug))]
9489#[derive(Copy, Clone, Default)]
9490#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMultiDrawInfoEXT.html>"]
9491pub struct MultiDrawInfoEXT {
9492 pub first_vertex: u32,
9493 pub vertex_count: u32,
9494}
9495impl MultiDrawInfoEXT {
9496 pub fn builder<'a>() -> MultiDrawInfoEXTBuilder<'a> {
9497 MultiDrawInfoEXTBuilder {
9498 inner: Self::default(),
9499 marker: ::std::marker::PhantomData,
9500 }
9501 }
9502}
9503#[repr(transparent)]
9504pub struct MultiDrawInfoEXTBuilder<'a> {
9505 inner: MultiDrawInfoEXT,
9506 marker: ::std::marker::PhantomData<&'a ()>,
9507}
9508impl<'a> ::std::ops::Deref for MultiDrawInfoEXTBuilder<'a> {
9509 type Target = MultiDrawInfoEXT;
9510 fn deref(&self) -> &Self::Target {
9511 &self.inner
9512 }
9513}
9514impl<'a> ::std::ops::DerefMut for MultiDrawInfoEXTBuilder<'a> {
9515 fn deref_mut(&mut self) -> &mut Self::Target {
9516 &mut self.inner
9517 }
9518}
9519impl<'a> MultiDrawInfoEXTBuilder<'a> {
9520 pub fn first_vertex(mut self, first_vertex: u32) -> Self {
9521 self.inner.first_vertex = first_vertex;
9522 self
9523 }
9524 pub fn vertex_count(mut self, vertex_count: u32) -> Self {
9525 self.inner.vertex_count = vertex_count;
9526 self
9527 }
9528 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9529 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9530 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9531 pub fn build(self) -> MultiDrawInfoEXT {
9532 self.inner
9533 }
9534}
9535#[repr(C)]
9536#[cfg_attr(feature = "debug", derive(Debug))]
9537#[derive(Copy, Clone, Default)]
9538#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMultiDrawIndexedInfoEXT.html>"]
9539pub struct MultiDrawIndexedInfoEXT {
9540 pub first_index: u32,
9541 pub index_count: u32,
9542 pub vertex_offset: i32,
9543}
9544impl MultiDrawIndexedInfoEXT {
9545 pub fn builder<'a>() -> MultiDrawIndexedInfoEXTBuilder<'a> {
9546 MultiDrawIndexedInfoEXTBuilder {
9547 inner: Self::default(),
9548 marker: ::std::marker::PhantomData,
9549 }
9550 }
9551}
9552#[repr(transparent)]
9553pub struct MultiDrawIndexedInfoEXTBuilder<'a> {
9554 inner: MultiDrawIndexedInfoEXT,
9555 marker: ::std::marker::PhantomData<&'a ()>,
9556}
9557impl<'a> ::std::ops::Deref for MultiDrawIndexedInfoEXTBuilder<'a> {
9558 type Target = MultiDrawIndexedInfoEXT;
9559 fn deref(&self) -> &Self::Target {
9560 &self.inner
9561 }
9562}
9563impl<'a> ::std::ops::DerefMut for MultiDrawIndexedInfoEXTBuilder<'a> {
9564 fn deref_mut(&mut self) -> &mut Self::Target {
9565 &mut self.inner
9566 }
9567}
9568impl<'a> MultiDrawIndexedInfoEXTBuilder<'a> {
9569 pub fn first_index(mut self, first_index: u32) -> Self {
9570 self.inner.first_index = first_index;
9571 self
9572 }
9573 pub fn index_count(mut self, index_count: u32) -> Self {
9574 self.inner.index_count = index_count;
9575 self
9576 }
9577 pub fn vertex_offset(mut self, vertex_offset: i32) -> Self {
9578 self.inner.vertex_offset = vertex_offset;
9579 self
9580 }
9581 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9582 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9583 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9584 pub fn build(self) -> MultiDrawIndexedInfoEXT {
9585 self.inner
9586 }
9587}
9588#[repr(C)]
9589#[cfg_attr(feature = "debug", derive(Debug))]
9590#[derive(Copy, Clone)]
9591#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubmitInfo.html>"]
9592pub struct SubmitInfo {
9593 pub s_type: StructureType,
9594 pub p_next: *const c_void,
9595 pub wait_semaphore_count: u32,
9596 pub p_wait_semaphores: *const Semaphore,
9597 pub p_wait_dst_stage_mask: *const PipelineStageFlags,
9598 pub command_buffer_count: u32,
9599 pub p_command_buffers: *const CommandBuffer,
9600 pub signal_semaphore_count: u32,
9601 pub p_signal_semaphores: *const Semaphore,
9602}
9603impl ::std::default::Default for SubmitInfo {
9604 fn default() -> Self {
9605 Self {
9606 s_type: StructureType::SUBMIT_INFO,
9607 p_next: ::std::ptr::null(),
9608 wait_semaphore_count: u32::default(),
9609 p_wait_semaphores: ::std::ptr::null(),
9610 p_wait_dst_stage_mask: ::std::ptr::null(),
9611 command_buffer_count: u32::default(),
9612 p_command_buffers: ::std::ptr::null(),
9613 signal_semaphore_count: u32::default(),
9614 p_signal_semaphores: ::std::ptr::null(),
9615 }
9616 }
9617}
9618impl SubmitInfo {
9619 pub fn builder<'a>() -> SubmitInfoBuilder<'a> {
9620 SubmitInfoBuilder {
9621 inner: Self::default(),
9622 marker: ::std::marker::PhantomData,
9623 }
9624 }
9625}
9626#[repr(transparent)]
9627pub struct SubmitInfoBuilder<'a> {
9628 inner: SubmitInfo,
9629 marker: ::std::marker::PhantomData<&'a ()>,
9630}
9631pub unsafe trait ExtendsSubmitInfo {}
9632impl<'a> ::std::ops::Deref for SubmitInfoBuilder<'a> {
9633 type Target = SubmitInfo;
9634 fn deref(&self) -> &Self::Target {
9635 &self.inner
9636 }
9637}
9638impl<'a> ::std::ops::DerefMut for SubmitInfoBuilder<'a> {
9639 fn deref_mut(&mut self) -> &mut Self::Target {
9640 &mut self.inner
9641 }
9642}
9643impl<'a> SubmitInfoBuilder<'a> {
9644 pub fn wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> Self {
9645 self.inner.wait_semaphore_count = wait_semaphores.len() as _;
9646 self.inner.p_wait_semaphores = wait_semaphores.as_ptr();
9647 self
9648 }
9649 pub fn wait_dst_stage_mask(mut self, wait_dst_stage_mask: &'a [PipelineStageFlags]) -> Self {
9650 self.inner.wait_semaphore_count = wait_dst_stage_mask.len() as _;
9651 self.inner.p_wait_dst_stage_mask = wait_dst_stage_mask.as_ptr();
9652 self
9653 }
9654 pub fn command_buffers(mut self, command_buffers: &'a [CommandBuffer]) -> Self {
9655 self.inner.command_buffer_count = command_buffers.len() as _;
9656 self.inner.p_command_buffers = command_buffers.as_ptr();
9657 self
9658 }
9659 pub fn signal_semaphores(mut self, signal_semaphores: &'a [Semaphore]) -> Self {
9660 self.inner.signal_semaphore_count = signal_semaphores.len() as _;
9661 self.inner.p_signal_semaphores = signal_semaphores.as_ptr();
9662 self
9663 }
9664 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
9665 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
9666 #[doc = r" valid extension structs can be pushed into the chain."]
9667 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
9668 #[doc = r" chain will look like `A -> D -> B -> C`."]
9669 pub fn push_next<T: ExtendsSubmitInfo>(mut self, next: &'a mut T) -> Self {
9670 unsafe {
9671 let next_ptr = <*const T>::cast(next);
9672 let last_next = ptr_chain_iter(next).last().unwrap();
9673 (*last_next).p_next = self.inner.p_next as _;
9674 self.inner.p_next = next_ptr;
9675 }
9676 self
9677 }
9678 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9679 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9680 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9681 pub fn build(self) -> SubmitInfo {
9682 self.inner
9683 }
9684}
9685#[repr(C)]
9686#[cfg_attr(feature = "debug", derive(Debug))]
9687#[derive(Copy, Clone)]
9688#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPropertiesKHR.html>"]
9689pub struct DisplayPropertiesKHR {
9690 pub display: DisplayKHR,
9691 pub display_name: *const c_char,
9692 pub physical_dimensions: Extent2D,
9693 pub physical_resolution: Extent2D,
9694 pub supported_transforms: SurfaceTransformFlagsKHR,
9695 pub plane_reorder_possible: Bool32,
9696 pub persistent_content: Bool32,
9697}
9698impl ::std::default::Default for DisplayPropertiesKHR {
9699 fn default() -> Self {
9700 Self {
9701 display: DisplayKHR::default(),
9702 display_name: ::std::ptr::null(),
9703 physical_dimensions: Extent2D::default(),
9704 physical_resolution: Extent2D::default(),
9705 supported_transforms: SurfaceTransformFlagsKHR::default(),
9706 plane_reorder_possible: Bool32::default(),
9707 persistent_content: Bool32::default(),
9708 }
9709 }
9710}
9711impl DisplayPropertiesKHR {
9712 pub fn builder<'a>() -> DisplayPropertiesKHRBuilder<'a> {
9713 DisplayPropertiesKHRBuilder {
9714 inner: Self::default(),
9715 marker: ::std::marker::PhantomData,
9716 }
9717 }
9718}
9719#[repr(transparent)]
9720pub struct DisplayPropertiesKHRBuilder<'a> {
9721 inner: DisplayPropertiesKHR,
9722 marker: ::std::marker::PhantomData<&'a ()>,
9723}
9724impl<'a> ::std::ops::Deref for DisplayPropertiesKHRBuilder<'a> {
9725 type Target = DisplayPropertiesKHR;
9726 fn deref(&self) -> &Self::Target {
9727 &self.inner
9728 }
9729}
9730impl<'a> ::std::ops::DerefMut for DisplayPropertiesKHRBuilder<'a> {
9731 fn deref_mut(&mut self) -> &mut Self::Target {
9732 &mut self.inner
9733 }
9734}
9735impl<'a> DisplayPropertiesKHRBuilder<'a> {
9736 pub fn display(mut self, display: DisplayKHR) -> Self {
9737 self.inner.display = display;
9738 self
9739 }
9740 pub fn display_name(mut self, display_name: &'a ::std::ffi::CStr) -> Self {
9741 self.inner.display_name = display_name.as_ptr();
9742 self
9743 }
9744 pub fn physical_dimensions(mut self, physical_dimensions: Extent2D) -> Self {
9745 self.inner.physical_dimensions = physical_dimensions;
9746 self
9747 }
9748 pub fn physical_resolution(mut self, physical_resolution: Extent2D) -> Self {
9749 self.inner.physical_resolution = physical_resolution;
9750 self
9751 }
9752 pub fn supported_transforms(mut self, supported_transforms: SurfaceTransformFlagsKHR) -> Self {
9753 self.inner.supported_transforms = supported_transforms;
9754 self
9755 }
9756 pub fn plane_reorder_possible(mut self, plane_reorder_possible: bool) -> Self {
9757 self.inner.plane_reorder_possible = plane_reorder_possible.into();
9758 self
9759 }
9760 pub fn persistent_content(mut self, persistent_content: bool) -> Self {
9761 self.inner.persistent_content = persistent_content.into();
9762 self
9763 }
9764 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9765 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9766 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9767 pub fn build(self) -> DisplayPropertiesKHR {
9768 self.inner
9769 }
9770}
9771#[repr(C)]
9772#[cfg_attr(feature = "debug", derive(Debug))]
9773#[derive(Copy, Clone, Default)]
9774#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPlanePropertiesKHR.html>"]
9775pub struct DisplayPlanePropertiesKHR {
9776 pub current_display: DisplayKHR,
9777 pub current_stack_index: u32,
9778}
9779impl DisplayPlanePropertiesKHR {
9780 pub fn builder<'a>() -> DisplayPlanePropertiesKHRBuilder<'a> {
9781 DisplayPlanePropertiesKHRBuilder {
9782 inner: Self::default(),
9783 marker: ::std::marker::PhantomData,
9784 }
9785 }
9786}
9787#[repr(transparent)]
9788pub struct DisplayPlanePropertiesKHRBuilder<'a> {
9789 inner: DisplayPlanePropertiesKHR,
9790 marker: ::std::marker::PhantomData<&'a ()>,
9791}
9792impl<'a> ::std::ops::Deref for DisplayPlanePropertiesKHRBuilder<'a> {
9793 type Target = DisplayPlanePropertiesKHR;
9794 fn deref(&self) -> &Self::Target {
9795 &self.inner
9796 }
9797}
9798impl<'a> ::std::ops::DerefMut for DisplayPlanePropertiesKHRBuilder<'a> {
9799 fn deref_mut(&mut self) -> &mut Self::Target {
9800 &mut self.inner
9801 }
9802}
9803impl<'a> DisplayPlanePropertiesKHRBuilder<'a> {
9804 pub fn current_display(mut self, current_display: DisplayKHR) -> Self {
9805 self.inner.current_display = current_display;
9806 self
9807 }
9808 pub fn current_stack_index(mut self, current_stack_index: u32) -> Self {
9809 self.inner.current_stack_index = current_stack_index;
9810 self
9811 }
9812 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9813 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9814 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9815 pub fn build(self) -> DisplayPlanePropertiesKHR {
9816 self.inner
9817 }
9818}
9819#[repr(C)]
9820#[cfg_attr(feature = "debug", derive(Debug))]
9821#[derive(Copy, Clone, Default)]
9822#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModeParametersKHR.html>"]
9823pub struct DisplayModeParametersKHR {
9824 pub visible_region: Extent2D,
9825 pub refresh_rate: u32,
9826}
9827impl DisplayModeParametersKHR {
9828 pub fn builder<'a>() -> DisplayModeParametersKHRBuilder<'a> {
9829 DisplayModeParametersKHRBuilder {
9830 inner: Self::default(),
9831 marker: ::std::marker::PhantomData,
9832 }
9833 }
9834}
9835#[repr(transparent)]
9836pub struct DisplayModeParametersKHRBuilder<'a> {
9837 inner: DisplayModeParametersKHR,
9838 marker: ::std::marker::PhantomData<&'a ()>,
9839}
9840impl<'a> ::std::ops::Deref for DisplayModeParametersKHRBuilder<'a> {
9841 type Target = DisplayModeParametersKHR;
9842 fn deref(&self) -> &Self::Target {
9843 &self.inner
9844 }
9845}
9846impl<'a> ::std::ops::DerefMut for DisplayModeParametersKHRBuilder<'a> {
9847 fn deref_mut(&mut self) -> &mut Self::Target {
9848 &mut self.inner
9849 }
9850}
9851impl<'a> DisplayModeParametersKHRBuilder<'a> {
9852 pub fn visible_region(mut self, visible_region: Extent2D) -> Self {
9853 self.inner.visible_region = visible_region;
9854 self
9855 }
9856 pub fn refresh_rate(mut self, refresh_rate: u32) -> Self {
9857 self.inner.refresh_rate = refresh_rate;
9858 self
9859 }
9860 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9861 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9862 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9863 pub fn build(self) -> DisplayModeParametersKHR {
9864 self.inner
9865 }
9866}
9867#[repr(C)]
9868#[cfg_attr(feature = "debug", derive(Debug))]
9869#[derive(Copy, Clone, Default)]
9870#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModePropertiesKHR.html>"]
9871pub struct DisplayModePropertiesKHR {
9872 pub display_mode: DisplayModeKHR,
9873 pub parameters: DisplayModeParametersKHR,
9874}
9875impl DisplayModePropertiesKHR {
9876 pub fn builder<'a>() -> DisplayModePropertiesKHRBuilder<'a> {
9877 DisplayModePropertiesKHRBuilder {
9878 inner: Self::default(),
9879 marker: ::std::marker::PhantomData,
9880 }
9881 }
9882}
9883#[repr(transparent)]
9884pub struct DisplayModePropertiesKHRBuilder<'a> {
9885 inner: DisplayModePropertiesKHR,
9886 marker: ::std::marker::PhantomData<&'a ()>,
9887}
9888impl<'a> ::std::ops::Deref for DisplayModePropertiesKHRBuilder<'a> {
9889 type Target = DisplayModePropertiesKHR;
9890 fn deref(&self) -> &Self::Target {
9891 &self.inner
9892 }
9893}
9894impl<'a> ::std::ops::DerefMut for DisplayModePropertiesKHRBuilder<'a> {
9895 fn deref_mut(&mut self) -> &mut Self::Target {
9896 &mut self.inner
9897 }
9898}
9899impl<'a> DisplayModePropertiesKHRBuilder<'a> {
9900 pub fn display_mode(mut self, display_mode: DisplayModeKHR) -> Self {
9901 self.inner.display_mode = display_mode;
9902 self
9903 }
9904 pub fn parameters(mut self, parameters: DisplayModeParametersKHR) -> Self {
9905 self.inner.parameters = parameters;
9906 self
9907 }
9908 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9909 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9910 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9911 pub fn build(self) -> DisplayModePropertiesKHR {
9912 self.inner
9913 }
9914}
9915#[repr(C)]
9916#[cfg_attr(feature = "debug", derive(Debug))]
9917#[derive(Copy, Clone)]
9918#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModeCreateInfoKHR.html>"]
9919pub struct DisplayModeCreateInfoKHR {
9920 pub s_type: StructureType,
9921 pub p_next: *const c_void,
9922 pub flags: DisplayModeCreateFlagsKHR,
9923 pub parameters: DisplayModeParametersKHR,
9924}
9925impl ::std::default::Default for DisplayModeCreateInfoKHR {
9926 fn default() -> Self {
9927 Self {
9928 s_type: StructureType::DISPLAY_MODE_CREATE_INFO_KHR,
9929 p_next: ::std::ptr::null(),
9930 flags: DisplayModeCreateFlagsKHR::default(),
9931 parameters: DisplayModeParametersKHR::default(),
9932 }
9933 }
9934}
9935impl DisplayModeCreateInfoKHR {
9936 pub fn builder<'a>() -> DisplayModeCreateInfoKHRBuilder<'a> {
9937 DisplayModeCreateInfoKHRBuilder {
9938 inner: Self::default(),
9939 marker: ::std::marker::PhantomData,
9940 }
9941 }
9942}
9943#[repr(transparent)]
9944pub struct DisplayModeCreateInfoKHRBuilder<'a> {
9945 inner: DisplayModeCreateInfoKHR,
9946 marker: ::std::marker::PhantomData<&'a ()>,
9947}
9948impl<'a> ::std::ops::Deref for DisplayModeCreateInfoKHRBuilder<'a> {
9949 type Target = DisplayModeCreateInfoKHR;
9950 fn deref(&self) -> &Self::Target {
9951 &self.inner
9952 }
9953}
9954impl<'a> ::std::ops::DerefMut for DisplayModeCreateInfoKHRBuilder<'a> {
9955 fn deref_mut(&mut self) -> &mut Self::Target {
9956 &mut self.inner
9957 }
9958}
9959impl<'a> DisplayModeCreateInfoKHRBuilder<'a> {
9960 pub fn flags(mut self, flags: DisplayModeCreateFlagsKHR) -> Self {
9961 self.inner.flags = flags;
9962 self
9963 }
9964 pub fn parameters(mut self, parameters: DisplayModeParametersKHR) -> Self {
9965 self.inner.parameters = parameters;
9966 self
9967 }
9968 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9969 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9970 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9971 pub fn build(self) -> DisplayModeCreateInfoKHR {
9972 self.inner
9973 }
9974}
9975#[repr(C)]
9976#[cfg_attr(feature = "debug", derive(Debug))]
9977#[derive(Copy, Clone, Default)]
9978#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPlaneCapabilitiesKHR.html>"]
9979pub struct DisplayPlaneCapabilitiesKHR {
9980 pub supported_alpha: DisplayPlaneAlphaFlagsKHR,
9981 pub min_src_position: Offset2D,
9982 pub max_src_position: Offset2D,
9983 pub min_src_extent: Extent2D,
9984 pub max_src_extent: Extent2D,
9985 pub min_dst_position: Offset2D,
9986 pub max_dst_position: Offset2D,
9987 pub min_dst_extent: Extent2D,
9988 pub max_dst_extent: Extent2D,
9989}
9990impl DisplayPlaneCapabilitiesKHR {
9991 pub fn builder<'a>() -> DisplayPlaneCapabilitiesKHRBuilder<'a> {
9992 DisplayPlaneCapabilitiesKHRBuilder {
9993 inner: Self::default(),
9994 marker: ::std::marker::PhantomData,
9995 }
9996 }
9997}
9998#[repr(transparent)]
9999pub struct DisplayPlaneCapabilitiesKHRBuilder<'a> {
10000 inner: DisplayPlaneCapabilitiesKHR,
10001 marker: ::std::marker::PhantomData<&'a ()>,
10002}
10003impl<'a> ::std::ops::Deref for DisplayPlaneCapabilitiesKHRBuilder<'a> {
10004 type Target = DisplayPlaneCapabilitiesKHR;
10005 fn deref(&self) -> &Self::Target {
10006 &self.inner
10007 }
10008}
10009impl<'a> ::std::ops::DerefMut for DisplayPlaneCapabilitiesKHRBuilder<'a> {
10010 fn deref_mut(&mut self) -> &mut Self::Target {
10011 &mut self.inner
10012 }
10013}
10014impl<'a> DisplayPlaneCapabilitiesKHRBuilder<'a> {
10015 pub fn supported_alpha(mut self, supported_alpha: DisplayPlaneAlphaFlagsKHR) -> Self {
10016 self.inner.supported_alpha = supported_alpha;
10017 self
10018 }
10019 pub fn min_src_position(mut self, min_src_position: Offset2D) -> Self {
10020 self.inner.min_src_position = min_src_position;
10021 self
10022 }
10023 pub fn max_src_position(mut self, max_src_position: Offset2D) -> Self {
10024 self.inner.max_src_position = max_src_position;
10025 self
10026 }
10027 pub fn min_src_extent(mut self, min_src_extent: Extent2D) -> Self {
10028 self.inner.min_src_extent = min_src_extent;
10029 self
10030 }
10031 pub fn max_src_extent(mut self, max_src_extent: Extent2D) -> Self {
10032 self.inner.max_src_extent = max_src_extent;
10033 self
10034 }
10035 pub fn min_dst_position(mut self, min_dst_position: Offset2D) -> Self {
10036 self.inner.min_dst_position = min_dst_position;
10037 self
10038 }
10039 pub fn max_dst_position(mut self, max_dst_position: Offset2D) -> Self {
10040 self.inner.max_dst_position = max_dst_position;
10041 self
10042 }
10043 pub fn min_dst_extent(mut self, min_dst_extent: Extent2D) -> Self {
10044 self.inner.min_dst_extent = min_dst_extent;
10045 self
10046 }
10047 pub fn max_dst_extent(mut self, max_dst_extent: Extent2D) -> Self {
10048 self.inner.max_dst_extent = max_dst_extent;
10049 self
10050 }
10051 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10052 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10053 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10054 pub fn build(self) -> DisplayPlaneCapabilitiesKHR {
10055 self.inner
10056 }
10057}
10058#[repr(C)]
10059#[cfg_attr(feature = "debug", derive(Debug))]
10060#[derive(Copy, Clone)]
10061#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplaySurfaceCreateInfoKHR.html>"]
10062pub struct DisplaySurfaceCreateInfoKHR {
10063 pub s_type: StructureType,
10064 pub p_next: *const c_void,
10065 pub flags: DisplaySurfaceCreateFlagsKHR,
10066 pub display_mode: DisplayModeKHR,
10067 pub plane_index: u32,
10068 pub plane_stack_index: u32,
10069 pub transform: SurfaceTransformFlagsKHR,
10070 pub global_alpha: f32,
10071 pub alpha_mode: DisplayPlaneAlphaFlagsKHR,
10072 pub image_extent: Extent2D,
10073}
10074impl ::std::default::Default for DisplaySurfaceCreateInfoKHR {
10075 fn default() -> Self {
10076 Self {
10077 s_type: StructureType::DISPLAY_SURFACE_CREATE_INFO_KHR,
10078 p_next: ::std::ptr::null(),
10079 flags: DisplaySurfaceCreateFlagsKHR::default(),
10080 display_mode: DisplayModeKHR::default(),
10081 plane_index: u32::default(),
10082 plane_stack_index: u32::default(),
10083 transform: SurfaceTransformFlagsKHR::default(),
10084 global_alpha: f32::default(),
10085 alpha_mode: DisplayPlaneAlphaFlagsKHR::default(),
10086 image_extent: Extent2D::default(),
10087 }
10088 }
10089}
10090impl DisplaySurfaceCreateInfoKHR {
10091 pub fn builder<'a>() -> DisplaySurfaceCreateInfoKHRBuilder<'a> {
10092 DisplaySurfaceCreateInfoKHRBuilder {
10093 inner: Self::default(),
10094 marker: ::std::marker::PhantomData,
10095 }
10096 }
10097}
10098#[repr(transparent)]
10099pub struct DisplaySurfaceCreateInfoKHRBuilder<'a> {
10100 inner: DisplaySurfaceCreateInfoKHR,
10101 marker: ::std::marker::PhantomData<&'a ()>,
10102}
10103impl<'a> ::std::ops::Deref for DisplaySurfaceCreateInfoKHRBuilder<'a> {
10104 type Target = DisplaySurfaceCreateInfoKHR;
10105 fn deref(&self) -> &Self::Target {
10106 &self.inner
10107 }
10108}
10109impl<'a> ::std::ops::DerefMut for DisplaySurfaceCreateInfoKHRBuilder<'a> {
10110 fn deref_mut(&mut self) -> &mut Self::Target {
10111 &mut self.inner
10112 }
10113}
10114impl<'a> DisplaySurfaceCreateInfoKHRBuilder<'a> {
10115 pub fn flags(mut self, flags: DisplaySurfaceCreateFlagsKHR) -> Self {
10116 self.inner.flags = flags;
10117 self
10118 }
10119 pub fn display_mode(mut self, display_mode: DisplayModeKHR) -> Self {
10120 self.inner.display_mode = display_mode;
10121 self
10122 }
10123 pub fn plane_index(mut self, plane_index: u32) -> Self {
10124 self.inner.plane_index = plane_index;
10125 self
10126 }
10127 pub fn plane_stack_index(mut self, plane_stack_index: u32) -> Self {
10128 self.inner.plane_stack_index = plane_stack_index;
10129 self
10130 }
10131 pub fn transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self {
10132 self.inner.transform = transform;
10133 self
10134 }
10135 pub fn global_alpha(mut self, global_alpha: f32) -> Self {
10136 self.inner.global_alpha = global_alpha;
10137 self
10138 }
10139 pub fn alpha_mode(mut self, alpha_mode: DisplayPlaneAlphaFlagsKHR) -> Self {
10140 self.inner.alpha_mode = alpha_mode;
10141 self
10142 }
10143 pub fn image_extent(mut self, image_extent: Extent2D) -> Self {
10144 self.inner.image_extent = image_extent;
10145 self
10146 }
10147 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10148 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10149 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10150 pub fn build(self) -> DisplaySurfaceCreateInfoKHR {
10151 self.inner
10152 }
10153}
10154#[repr(C)]
10155#[cfg_attr(feature = "debug", derive(Debug))]
10156#[derive(Copy, Clone)]
10157#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPresentInfoKHR.html>"]
10158pub struct DisplayPresentInfoKHR {
10159 pub s_type: StructureType,
10160 pub p_next: *const c_void,
10161 pub src_rect: Rect2D,
10162 pub dst_rect: Rect2D,
10163 pub persistent: Bool32,
10164}
10165impl ::std::default::Default for DisplayPresentInfoKHR {
10166 fn default() -> Self {
10167 Self {
10168 s_type: StructureType::DISPLAY_PRESENT_INFO_KHR,
10169 p_next: ::std::ptr::null(),
10170 src_rect: Rect2D::default(),
10171 dst_rect: Rect2D::default(),
10172 persistent: Bool32::default(),
10173 }
10174 }
10175}
10176impl DisplayPresentInfoKHR {
10177 pub fn builder<'a>() -> DisplayPresentInfoKHRBuilder<'a> {
10178 DisplayPresentInfoKHRBuilder {
10179 inner: Self::default(),
10180 marker: ::std::marker::PhantomData,
10181 }
10182 }
10183}
10184#[repr(transparent)]
10185pub struct DisplayPresentInfoKHRBuilder<'a> {
10186 inner: DisplayPresentInfoKHR,
10187 marker: ::std::marker::PhantomData<&'a ()>,
10188}
10189unsafe impl ExtendsPresentInfoKHR for DisplayPresentInfoKHRBuilder<'_> {}
10190unsafe impl ExtendsPresentInfoKHR for DisplayPresentInfoKHR {}
10191impl<'a> ::std::ops::Deref for DisplayPresentInfoKHRBuilder<'a> {
10192 type Target = DisplayPresentInfoKHR;
10193 fn deref(&self) -> &Self::Target {
10194 &self.inner
10195 }
10196}
10197impl<'a> ::std::ops::DerefMut for DisplayPresentInfoKHRBuilder<'a> {
10198 fn deref_mut(&mut self) -> &mut Self::Target {
10199 &mut self.inner
10200 }
10201}
10202impl<'a> DisplayPresentInfoKHRBuilder<'a> {
10203 pub fn src_rect(mut self, src_rect: Rect2D) -> Self {
10204 self.inner.src_rect = src_rect;
10205 self
10206 }
10207 pub fn dst_rect(mut self, dst_rect: Rect2D) -> Self {
10208 self.inner.dst_rect = dst_rect;
10209 self
10210 }
10211 pub fn persistent(mut self, persistent: bool) -> Self {
10212 self.inner.persistent = persistent.into();
10213 self
10214 }
10215 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10216 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10217 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10218 pub fn build(self) -> DisplayPresentInfoKHR {
10219 self.inner
10220 }
10221}
10222#[repr(C)]
10223#[cfg_attr(feature = "debug", derive(Debug))]
10224#[derive(Copy, Clone, Default)]
10225#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceCapabilitiesKHR.html>"]
10226pub struct SurfaceCapabilitiesKHR {
10227 pub min_image_count: u32,
10228 pub max_image_count: u32,
10229 pub current_extent: Extent2D,
10230 pub min_image_extent: Extent2D,
10231 pub max_image_extent: Extent2D,
10232 pub max_image_array_layers: u32,
10233 pub supported_transforms: SurfaceTransformFlagsKHR,
10234 pub current_transform: SurfaceTransformFlagsKHR,
10235 pub supported_composite_alpha: CompositeAlphaFlagsKHR,
10236 pub supported_usage_flags: ImageUsageFlags,
10237}
10238impl SurfaceCapabilitiesKHR {
10239 pub fn builder<'a>() -> SurfaceCapabilitiesKHRBuilder<'a> {
10240 SurfaceCapabilitiesKHRBuilder {
10241 inner: Self::default(),
10242 marker: ::std::marker::PhantomData,
10243 }
10244 }
10245}
10246#[repr(transparent)]
10247pub struct SurfaceCapabilitiesKHRBuilder<'a> {
10248 inner: SurfaceCapabilitiesKHR,
10249 marker: ::std::marker::PhantomData<&'a ()>,
10250}
10251impl<'a> ::std::ops::Deref for SurfaceCapabilitiesKHRBuilder<'a> {
10252 type Target = SurfaceCapabilitiesKHR;
10253 fn deref(&self) -> &Self::Target {
10254 &self.inner
10255 }
10256}
10257impl<'a> ::std::ops::DerefMut for SurfaceCapabilitiesKHRBuilder<'a> {
10258 fn deref_mut(&mut self) -> &mut Self::Target {
10259 &mut self.inner
10260 }
10261}
10262impl<'a> SurfaceCapabilitiesKHRBuilder<'a> {
10263 pub fn min_image_count(mut self, min_image_count: u32) -> Self {
10264 self.inner.min_image_count = min_image_count;
10265 self
10266 }
10267 pub fn max_image_count(mut self, max_image_count: u32) -> Self {
10268 self.inner.max_image_count = max_image_count;
10269 self
10270 }
10271 pub fn current_extent(mut self, current_extent: Extent2D) -> Self {
10272 self.inner.current_extent = current_extent;
10273 self
10274 }
10275 pub fn min_image_extent(mut self, min_image_extent: Extent2D) -> Self {
10276 self.inner.min_image_extent = min_image_extent;
10277 self
10278 }
10279 pub fn max_image_extent(mut self, max_image_extent: Extent2D) -> Self {
10280 self.inner.max_image_extent = max_image_extent;
10281 self
10282 }
10283 pub fn max_image_array_layers(mut self, max_image_array_layers: u32) -> Self {
10284 self.inner.max_image_array_layers = max_image_array_layers;
10285 self
10286 }
10287 pub fn supported_transforms(mut self, supported_transforms: SurfaceTransformFlagsKHR) -> Self {
10288 self.inner.supported_transforms = supported_transforms;
10289 self
10290 }
10291 pub fn current_transform(mut self, current_transform: SurfaceTransformFlagsKHR) -> Self {
10292 self.inner.current_transform = current_transform;
10293 self
10294 }
10295 pub fn supported_composite_alpha(
10296 mut self,
10297 supported_composite_alpha: CompositeAlphaFlagsKHR,
10298 ) -> Self {
10299 self.inner.supported_composite_alpha = supported_composite_alpha;
10300 self
10301 }
10302 pub fn supported_usage_flags(mut self, supported_usage_flags: ImageUsageFlags) -> Self {
10303 self.inner.supported_usage_flags = supported_usage_flags;
10304 self
10305 }
10306 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10307 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10308 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10309 pub fn build(self) -> SurfaceCapabilitiesKHR {
10310 self.inner
10311 }
10312}
10313#[repr(C)]
10314#[cfg_attr(feature = "debug", derive(Debug))]
10315#[derive(Copy, Clone)]
10316#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAndroidSurfaceCreateInfoKHR.html>"]
10317pub struct AndroidSurfaceCreateInfoKHR {
10318 pub s_type: StructureType,
10319 pub p_next: *const c_void,
10320 pub flags: AndroidSurfaceCreateFlagsKHR,
10321 pub window: *mut ANativeWindow,
10322}
10323impl ::std::default::Default for AndroidSurfaceCreateInfoKHR {
10324 fn default() -> Self {
10325 Self {
10326 s_type: StructureType::ANDROID_SURFACE_CREATE_INFO_KHR,
10327 p_next: ::std::ptr::null(),
10328 flags: AndroidSurfaceCreateFlagsKHR::default(),
10329 window: ::std::ptr::null_mut(),
10330 }
10331 }
10332}
10333impl AndroidSurfaceCreateInfoKHR {
10334 pub fn builder<'a>() -> AndroidSurfaceCreateInfoKHRBuilder<'a> {
10335 AndroidSurfaceCreateInfoKHRBuilder {
10336 inner: Self::default(),
10337 marker: ::std::marker::PhantomData,
10338 }
10339 }
10340}
10341#[repr(transparent)]
10342pub struct AndroidSurfaceCreateInfoKHRBuilder<'a> {
10343 inner: AndroidSurfaceCreateInfoKHR,
10344 marker: ::std::marker::PhantomData<&'a ()>,
10345}
10346impl<'a> ::std::ops::Deref for AndroidSurfaceCreateInfoKHRBuilder<'a> {
10347 type Target = AndroidSurfaceCreateInfoKHR;
10348 fn deref(&self) -> &Self::Target {
10349 &self.inner
10350 }
10351}
10352impl<'a> ::std::ops::DerefMut for AndroidSurfaceCreateInfoKHRBuilder<'a> {
10353 fn deref_mut(&mut self) -> &mut Self::Target {
10354 &mut self.inner
10355 }
10356}
10357impl<'a> AndroidSurfaceCreateInfoKHRBuilder<'a> {
10358 pub fn flags(mut self, flags: AndroidSurfaceCreateFlagsKHR) -> Self {
10359 self.inner.flags = flags;
10360 self
10361 }
10362 pub fn window(mut self, window: *mut ANativeWindow) -> Self {
10363 self.inner.window = window;
10364 self
10365 }
10366 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10367 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10368 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10369 pub fn build(self) -> AndroidSurfaceCreateInfoKHR {
10370 self.inner
10371 }
10372}
10373#[repr(C)]
10374#[cfg_attr(feature = "debug", derive(Debug))]
10375#[derive(Copy, Clone)]
10376#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkViSurfaceCreateInfoNN.html>"]
10377pub struct ViSurfaceCreateInfoNN {
10378 pub s_type: StructureType,
10379 pub p_next: *const c_void,
10380 pub flags: ViSurfaceCreateFlagsNN,
10381 pub window: *mut c_void,
10382}
10383impl ::std::default::Default for ViSurfaceCreateInfoNN {
10384 fn default() -> Self {
10385 Self {
10386 s_type: StructureType::VI_SURFACE_CREATE_INFO_NN,
10387 p_next: ::std::ptr::null(),
10388 flags: ViSurfaceCreateFlagsNN::default(),
10389 window: ::std::ptr::null_mut(),
10390 }
10391 }
10392}
10393impl ViSurfaceCreateInfoNN {
10394 pub fn builder<'a>() -> ViSurfaceCreateInfoNNBuilder<'a> {
10395 ViSurfaceCreateInfoNNBuilder {
10396 inner: Self::default(),
10397 marker: ::std::marker::PhantomData,
10398 }
10399 }
10400}
10401#[repr(transparent)]
10402pub struct ViSurfaceCreateInfoNNBuilder<'a> {
10403 inner: ViSurfaceCreateInfoNN,
10404 marker: ::std::marker::PhantomData<&'a ()>,
10405}
10406impl<'a> ::std::ops::Deref for ViSurfaceCreateInfoNNBuilder<'a> {
10407 type Target = ViSurfaceCreateInfoNN;
10408 fn deref(&self) -> &Self::Target {
10409 &self.inner
10410 }
10411}
10412impl<'a> ::std::ops::DerefMut for ViSurfaceCreateInfoNNBuilder<'a> {
10413 fn deref_mut(&mut self) -> &mut Self::Target {
10414 &mut self.inner
10415 }
10416}
10417impl<'a> ViSurfaceCreateInfoNNBuilder<'a> {
10418 pub fn flags(mut self, flags: ViSurfaceCreateFlagsNN) -> Self {
10419 self.inner.flags = flags;
10420 self
10421 }
10422 pub fn window(mut self, window: *mut c_void) -> Self {
10423 self.inner.window = window;
10424 self
10425 }
10426 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10427 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10428 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10429 pub fn build(self) -> ViSurfaceCreateInfoNN {
10430 self.inner
10431 }
10432}
10433#[repr(C)]
10434#[cfg_attr(feature = "debug", derive(Debug))]
10435#[derive(Copy, Clone)]
10436#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWaylandSurfaceCreateInfoKHR.html>"]
10437pub struct WaylandSurfaceCreateInfoKHR {
10438 pub s_type: StructureType,
10439 pub p_next: *const c_void,
10440 pub flags: WaylandSurfaceCreateFlagsKHR,
10441 pub display: *mut wl_display,
10442 pub surface: *mut wl_surface,
10443}
10444impl ::std::default::Default for WaylandSurfaceCreateInfoKHR {
10445 fn default() -> Self {
10446 Self {
10447 s_type: StructureType::WAYLAND_SURFACE_CREATE_INFO_KHR,
10448 p_next: ::std::ptr::null(),
10449 flags: WaylandSurfaceCreateFlagsKHR::default(),
10450 display: ::std::ptr::null_mut(),
10451 surface: ::std::ptr::null_mut(),
10452 }
10453 }
10454}
10455impl WaylandSurfaceCreateInfoKHR {
10456 pub fn builder<'a>() -> WaylandSurfaceCreateInfoKHRBuilder<'a> {
10457 WaylandSurfaceCreateInfoKHRBuilder {
10458 inner: Self::default(),
10459 marker: ::std::marker::PhantomData,
10460 }
10461 }
10462}
10463#[repr(transparent)]
10464pub struct WaylandSurfaceCreateInfoKHRBuilder<'a> {
10465 inner: WaylandSurfaceCreateInfoKHR,
10466 marker: ::std::marker::PhantomData<&'a ()>,
10467}
10468impl<'a> ::std::ops::Deref for WaylandSurfaceCreateInfoKHRBuilder<'a> {
10469 type Target = WaylandSurfaceCreateInfoKHR;
10470 fn deref(&self) -> &Self::Target {
10471 &self.inner
10472 }
10473}
10474impl<'a> ::std::ops::DerefMut for WaylandSurfaceCreateInfoKHRBuilder<'a> {
10475 fn deref_mut(&mut self) -> &mut Self::Target {
10476 &mut self.inner
10477 }
10478}
10479impl<'a> WaylandSurfaceCreateInfoKHRBuilder<'a> {
10480 pub fn flags(mut self, flags: WaylandSurfaceCreateFlagsKHR) -> Self {
10481 self.inner.flags = flags;
10482 self
10483 }
10484 pub fn display(mut self, display: *mut wl_display) -> Self {
10485 self.inner.display = display;
10486 self
10487 }
10488 pub fn surface(mut self, surface: *mut wl_surface) -> Self {
10489 self.inner.surface = surface;
10490 self
10491 }
10492 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10493 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10494 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10495 pub fn build(self) -> WaylandSurfaceCreateInfoKHR {
10496 self.inner
10497 }
10498}
10499#[repr(C)]
10500#[cfg_attr(feature = "debug", derive(Debug))]
10501#[derive(Copy, Clone)]
10502#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWin32SurfaceCreateInfoKHR.html>"]
10503pub struct Win32SurfaceCreateInfoKHR {
10504 pub s_type: StructureType,
10505 pub p_next: *const c_void,
10506 pub flags: Win32SurfaceCreateFlagsKHR,
10507 pub hinstance: HINSTANCE,
10508 pub hwnd: HWND,
10509}
10510impl ::std::default::Default for Win32SurfaceCreateInfoKHR {
10511 fn default() -> Self {
10512 Self {
10513 s_type: StructureType::WIN32_SURFACE_CREATE_INFO_KHR,
10514 p_next: ::std::ptr::null(),
10515 flags: Win32SurfaceCreateFlagsKHR::default(),
10516 hinstance: unsafe { ::std::mem::zeroed() },
10517 hwnd: unsafe { ::std::mem::zeroed() },
10518 }
10519 }
10520}
10521impl Win32SurfaceCreateInfoKHR {
10522 pub fn builder<'a>() -> Win32SurfaceCreateInfoKHRBuilder<'a> {
10523 Win32SurfaceCreateInfoKHRBuilder {
10524 inner: Self::default(),
10525 marker: ::std::marker::PhantomData,
10526 }
10527 }
10528}
10529#[repr(transparent)]
10530pub struct Win32SurfaceCreateInfoKHRBuilder<'a> {
10531 inner: Win32SurfaceCreateInfoKHR,
10532 marker: ::std::marker::PhantomData<&'a ()>,
10533}
10534impl<'a> ::std::ops::Deref for Win32SurfaceCreateInfoKHRBuilder<'a> {
10535 type Target = Win32SurfaceCreateInfoKHR;
10536 fn deref(&self) -> &Self::Target {
10537 &self.inner
10538 }
10539}
10540impl<'a> ::std::ops::DerefMut for Win32SurfaceCreateInfoKHRBuilder<'a> {
10541 fn deref_mut(&mut self) -> &mut Self::Target {
10542 &mut self.inner
10543 }
10544}
10545impl<'a> Win32SurfaceCreateInfoKHRBuilder<'a> {
10546 pub fn flags(mut self, flags: Win32SurfaceCreateFlagsKHR) -> Self {
10547 self.inner.flags = flags;
10548 self
10549 }
10550 pub fn hinstance(mut self, hinstance: HINSTANCE) -> Self {
10551 self.inner.hinstance = hinstance;
10552 self
10553 }
10554 pub fn hwnd(mut self, hwnd: HWND) -> Self {
10555 self.inner.hwnd = hwnd;
10556 self
10557 }
10558 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10559 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10560 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10561 pub fn build(self) -> Win32SurfaceCreateInfoKHR {
10562 self.inner
10563 }
10564}
10565#[repr(C)]
10566#[cfg_attr(feature = "debug", derive(Debug))]
10567#[derive(Copy, Clone)]
10568#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkXlibSurfaceCreateInfoKHR.html>"]
10569pub struct XlibSurfaceCreateInfoKHR {
10570 pub s_type: StructureType,
10571 pub p_next: *const c_void,
10572 pub flags: XlibSurfaceCreateFlagsKHR,
10573 pub dpy: *mut Display,
10574 pub window: Window,
10575}
10576impl ::std::default::Default for XlibSurfaceCreateInfoKHR {
10577 fn default() -> Self {
10578 Self {
10579 s_type: StructureType::XLIB_SURFACE_CREATE_INFO_KHR,
10580 p_next: ::std::ptr::null(),
10581 flags: XlibSurfaceCreateFlagsKHR::default(),
10582 dpy: ::std::ptr::null_mut(),
10583 window: Window::default(),
10584 }
10585 }
10586}
10587impl XlibSurfaceCreateInfoKHR {
10588 pub fn builder<'a>() -> XlibSurfaceCreateInfoKHRBuilder<'a> {
10589 XlibSurfaceCreateInfoKHRBuilder {
10590 inner: Self::default(),
10591 marker: ::std::marker::PhantomData,
10592 }
10593 }
10594}
10595#[repr(transparent)]
10596pub struct XlibSurfaceCreateInfoKHRBuilder<'a> {
10597 inner: XlibSurfaceCreateInfoKHR,
10598 marker: ::std::marker::PhantomData<&'a ()>,
10599}
10600impl<'a> ::std::ops::Deref for XlibSurfaceCreateInfoKHRBuilder<'a> {
10601 type Target = XlibSurfaceCreateInfoKHR;
10602 fn deref(&self) -> &Self::Target {
10603 &self.inner
10604 }
10605}
10606impl<'a> ::std::ops::DerefMut for XlibSurfaceCreateInfoKHRBuilder<'a> {
10607 fn deref_mut(&mut self) -> &mut Self::Target {
10608 &mut self.inner
10609 }
10610}
10611impl<'a> XlibSurfaceCreateInfoKHRBuilder<'a> {
10612 pub fn flags(mut self, flags: XlibSurfaceCreateFlagsKHR) -> Self {
10613 self.inner.flags = flags;
10614 self
10615 }
10616 pub fn dpy(mut self, dpy: *mut Display) -> Self {
10617 self.inner.dpy = dpy;
10618 self
10619 }
10620 pub fn window(mut self, window: Window) -> Self {
10621 self.inner.window = window;
10622 self
10623 }
10624 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10625 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10626 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10627 pub fn build(self) -> XlibSurfaceCreateInfoKHR {
10628 self.inner
10629 }
10630}
10631#[repr(C)]
10632#[cfg_attr(feature = "debug", derive(Debug))]
10633#[derive(Copy, Clone)]
10634#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkXcbSurfaceCreateInfoKHR.html>"]
10635pub struct XcbSurfaceCreateInfoKHR {
10636 pub s_type: StructureType,
10637 pub p_next: *const c_void,
10638 pub flags: XcbSurfaceCreateFlagsKHR,
10639 pub connection: *mut xcb_connection_t,
10640 pub window: xcb_window_t,
10641}
10642impl ::std::default::Default for XcbSurfaceCreateInfoKHR {
10643 fn default() -> Self {
10644 Self {
10645 s_type: StructureType::XCB_SURFACE_CREATE_INFO_KHR,
10646 p_next: ::std::ptr::null(),
10647 flags: XcbSurfaceCreateFlagsKHR::default(),
10648 connection: ::std::ptr::null_mut(),
10649 window: xcb_window_t::default(),
10650 }
10651 }
10652}
10653impl XcbSurfaceCreateInfoKHR {
10654 pub fn builder<'a>() -> XcbSurfaceCreateInfoKHRBuilder<'a> {
10655 XcbSurfaceCreateInfoKHRBuilder {
10656 inner: Self::default(),
10657 marker: ::std::marker::PhantomData,
10658 }
10659 }
10660}
10661#[repr(transparent)]
10662pub struct XcbSurfaceCreateInfoKHRBuilder<'a> {
10663 inner: XcbSurfaceCreateInfoKHR,
10664 marker: ::std::marker::PhantomData<&'a ()>,
10665}
10666impl<'a> ::std::ops::Deref for XcbSurfaceCreateInfoKHRBuilder<'a> {
10667 type Target = XcbSurfaceCreateInfoKHR;
10668 fn deref(&self) -> &Self::Target {
10669 &self.inner
10670 }
10671}
10672impl<'a> ::std::ops::DerefMut for XcbSurfaceCreateInfoKHRBuilder<'a> {
10673 fn deref_mut(&mut self) -> &mut Self::Target {
10674 &mut self.inner
10675 }
10676}
10677impl<'a> XcbSurfaceCreateInfoKHRBuilder<'a> {
10678 pub fn flags(mut self, flags: XcbSurfaceCreateFlagsKHR) -> Self {
10679 self.inner.flags = flags;
10680 self
10681 }
10682 pub fn connection(mut self, connection: *mut xcb_connection_t) -> Self {
10683 self.inner.connection = connection;
10684 self
10685 }
10686 pub fn window(mut self, window: xcb_window_t) -> Self {
10687 self.inner.window = window;
10688 self
10689 }
10690 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10691 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10692 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10693 pub fn build(self) -> XcbSurfaceCreateInfoKHR {
10694 self.inner
10695 }
10696}
10697#[repr(C)]
10698#[cfg_attr(feature = "debug", derive(Debug))]
10699#[derive(Copy, Clone)]
10700#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDirectFBSurfaceCreateInfoEXT.html>"]
10701pub struct DirectFBSurfaceCreateInfoEXT {
10702 pub s_type: StructureType,
10703 pub p_next: *const c_void,
10704 pub flags: DirectFBSurfaceCreateFlagsEXT,
10705 pub dfb: *mut IDirectFB,
10706 pub surface: *mut IDirectFBSurface,
10707}
10708impl ::std::default::Default for DirectFBSurfaceCreateInfoEXT {
10709 fn default() -> Self {
10710 Self {
10711 s_type: StructureType::DIRECTFB_SURFACE_CREATE_INFO_EXT,
10712 p_next: ::std::ptr::null(),
10713 flags: DirectFBSurfaceCreateFlagsEXT::default(),
10714 dfb: ::std::ptr::null_mut(),
10715 surface: ::std::ptr::null_mut(),
10716 }
10717 }
10718}
10719impl DirectFBSurfaceCreateInfoEXT {
10720 pub fn builder<'a>() -> DirectFBSurfaceCreateInfoEXTBuilder<'a> {
10721 DirectFBSurfaceCreateInfoEXTBuilder {
10722 inner: Self::default(),
10723 marker: ::std::marker::PhantomData,
10724 }
10725 }
10726}
10727#[repr(transparent)]
10728pub struct DirectFBSurfaceCreateInfoEXTBuilder<'a> {
10729 inner: DirectFBSurfaceCreateInfoEXT,
10730 marker: ::std::marker::PhantomData<&'a ()>,
10731}
10732impl<'a> ::std::ops::Deref for DirectFBSurfaceCreateInfoEXTBuilder<'a> {
10733 type Target = DirectFBSurfaceCreateInfoEXT;
10734 fn deref(&self) -> &Self::Target {
10735 &self.inner
10736 }
10737}
10738impl<'a> ::std::ops::DerefMut for DirectFBSurfaceCreateInfoEXTBuilder<'a> {
10739 fn deref_mut(&mut self) -> &mut Self::Target {
10740 &mut self.inner
10741 }
10742}
10743impl<'a> DirectFBSurfaceCreateInfoEXTBuilder<'a> {
10744 pub fn flags(mut self, flags: DirectFBSurfaceCreateFlagsEXT) -> Self {
10745 self.inner.flags = flags;
10746 self
10747 }
10748 pub fn dfb(mut self, dfb: *mut IDirectFB) -> Self {
10749 self.inner.dfb = dfb;
10750 self
10751 }
10752 pub fn surface(mut self, surface: *mut IDirectFBSurface) -> Self {
10753 self.inner.surface = surface;
10754 self
10755 }
10756 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10757 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10758 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10759 pub fn build(self) -> DirectFBSurfaceCreateInfoEXT {
10760 self.inner
10761 }
10762}
10763#[repr(C)]
10764#[cfg_attr(feature = "debug", derive(Debug))]
10765#[derive(Copy, Clone)]
10766#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImagePipeSurfaceCreateInfoFUCHSIA.html>"]
10767pub struct ImagePipeSurfaceCreateInfoFUCHSIA {
10768 pub s_type: StructureType,
10769 pub p_next: *const c_void,
10770 pub flags: ImagePipeSurfaceCreateFlagsFUCHSIA,
10771 pub image_pipe_handle: zx_handle_t,
10772}
10773impl ::std::default::Default for ImagePipeSurfaceCreateInfoFUCHSIA {
10774 fn default() -> Self {
10775 Self {
10776 s_type: StructureType::IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA,
10777 p_next: ::std::ptr::null(),
10778 flags: ImagePipeSurfaceCreateFlagsFUCHSIA::default(),
10779 image_pipe_handle: zx_handle_t::default(),
10780 }
10781 }
10782}
10783impl ImagePipeSurfaceCreateInfoFUCHSIA {
10784 pub fn builder<'a>() -> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
10785 ImagePipeSurfaceCreateInfoFUCHSIABuilder {
10786 inner: Self::default(),
10787 marker: ::std::marker::PhantomData,
10788 }
10789 }
10790}
10791#[repr(transparent)]
10792pub struct ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
10793 inner: ImagePipeSurfaceCreateInfoFUCHSIA,
10794 marker: ::std::marker::PhantomData<&'a ()>,
10795}
10796impl<'a> ::std::ops::Deref for ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
10797 type Target = ImagePipeSurfaceCreateInfoFUCHSIA;
10798 fn deref(&self) -> &Self::Target {
10799 &self.inner
10800 }
10801}
10802impl<'a> ::std::ops::DerefMut for ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
10803 fn deref_mut(&mut self) -> &mut Self::Target {
10804 &mut self.inner
10805 }
10806}
10807impl<'a> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
10808 pub fn flags(mut self, flags: ImagePipeSurfaceCreateFlagsFUCHSIA) -> Self {
10809 self.inner.flags = flags;
10810 self
10811 }
10812 pub fn image_pipe_handle(mut self, image_pipe_handle: zx_handle_t) -> Self {
10813 self.inner.image_pipe_handle = image_pipe_handle;
10814 self
10815 }
10816 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10817 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10818 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10819 pub fn build(self) -> ImagePipeSurfaceCreateInfoFUCHSIA {
10820 self.inner
10821 }
10822}
10823#[repr(C)]
10824#[cfg_attr(feature = "debug", derive(Debug))]
10825#[derive(Copy, Clone)]
10826#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkStreamDescriptorSurfaceCreateInfoGGP.html>"]
10827pub struct StreamDescriptorSurfaceCreateInfoGGP {
10828 pub s_type: StructureType,
10829 pub p_next: *const c_void,
10830 pub flags: StreamDescriptorSurfaceCreateFlagsGGP,
10831 pub stream_descriptor: GgpStreamDescriptor,
10832}
10833impl ::std::default::Default for StreamDescriptorSurfaceCreateInfoGGP {
10834 fn default() -> Self {
10835 Self {
10836 s_type: StructureType::STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP,
10837 p_next: ::std::ptr::null(),
10838 flags: StreamDescriptorSurfaceCreateFlagsGGP::default(),
10839 stream_descriptor: GgpStreamDescriptor::default(),
10840 }
10841 }
10842}
10843impl StreamDescriptorSurfaceCreateInfoGGP {
10844 pub fn builder<'a>() -> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
10845 StreamDescriptorSurfaceCreateInfoGGPBuilder {
10846 inner: Self::default(),
10847 marker: ::std::marker::PhantomData,
10848 }
10849 }
10850}
10851#[repr(transparent)]
10852pub struct StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
10853 inner: StreamDescriptorSurfaceCreateInfoGGP,
10854 marker: ::std::marker::PhantomData<&'a ()>,
10855}
10856impl<'a> ::std::ops::Deref for StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
10857 type Target = StreamDescriptorSurfaceCreateInfoGGP;
10858 fn deref(&self) -> &Self::Target {
10859 &self.inner
10860 }
10861}
10862impl<'a> ::std::ops::DerefMut for StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
10863 fn deref_mut(&mut self) -> &mut Self::Target {
10864 &mut self.inner
10865 }
10866}
10867impl<'a> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
10868 pub fn flags(mut self, flags: StreamDescriptorSurfaceCreateFlagsGGP) -> Self {
10869 self.inner.flags = flags;
10870 self
10871 }
10872 pub fn stream_descriptor(mut self, stream_descriptor: GgpStreamDescriptor) -> Self {
10873 self.inner.stream_descriptor = stream_descriptor;
10874 self
10875 }
10876 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10877 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10878 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10879 pub fn build(self) -> StreamDescriptorSurfaceCreateInfoGGP {
10880 self.inner
10881 }
10882}
10883#[repr(C)]
10884#[cfg_attr(feature = "debug", derive(Debug))]
10885#[derive(Copy, Clone)]
10886#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkScreenSurfaceCreateInfoQNX.html>"]
10887pub struct ScreenSurfaceCreateInfoQNX {
10888 pub s_type: StructureType,
10889 pub p_next: *const c_void,
10890 pub flags: ScreenSurfaceCreateFlagsQNX,
10891 pub context: *mut _screen_context,
10892 pub window: *mut _screen_window,
10893}
10894impl ::std::default::Default for ScreenSurfaceCreateInfoQNX {
10895 fn default() -> Self {
10896 Self {
10897 s_type: StructureType::SCREEN_SURFACE_CREATE_INFO_QNX,
10898 p_next: ::std::ptr::null(),
10899 flags: ScreenSurfaceCreateFlagsQNX::default(),
10900 context: ::std::ptr::null_mut(),
10901 window: ::std::ptr::null_mut(),
10902 }
10903 }
10904}
10905impl ScreenSurfaceCreateInfoQNX {
10906 pub fn builder<'a>() -> ScreenSurfaceCreateInfoQNXBuilder<'a> {
10907 ScreenSurfaceCreateInfoQNXBuilder {
10908 inner: Self::default(),
10909 marker: ::std::marker::PhantomData,
10910 }
10911 }
10912}
10913#[repr(transparent)]
10914pub struct ScreenSurfaceCreateInfoQNXBuilder<'a> {
10915 inner: ScreenSurfaceCreateInfoQNX,
10916 marker: ::std::marker::PhantomData<&'a ()>,
10917}
10918impl<'a> ::std::ops::Deref for ScreenSurfaceCreateInfoQNXBuilder<'a> {
10919 type Target = ScreenSurfaceCreateInfoQNX;
10920 fn deref(&self) -> &Self::Target {
10921 &self.inner
10922 }
10923}
10924impl<'a> ::std::ops::DerefMut for ScreenSurfaceCreateInfoQNXBuilder<'a> {
10925 fn deref_mut(&mut self) -> &mut Self::Target {
10926 &mut self.inner
10927 }
10928}
10929impl<'a> ScreenSurfaceCreateInfoQNXBuilder<'a> {
10930 pub fn flags(mut self, flags: ScreenSurfaceCreateFlagsQNX) -> Self {
10931 self.inner.flags = flags;
10932 self
10933 }
10934 pub fn context(mut self, context: &'a mut _screen_context) -> Self {
10935 self.inner.context = context;
10936 self
10937 }
10938 pub fn window(mut self, window: &'a mut _screen_window) -> Self {
10939 self.inner.window = window;
10940 self
10941 }
10942 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10943 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10944 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10945 pub fn build(self) -> ScreenSurfaceCreateInfoQNX {
10946 self.inner
10947 }
10948}
10949#[repr(C)]
10950#[cfg_attr(feature = "debug", derive(Debug))]
10951#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
10952#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceFormatKHR.html>"]
10953pub struct SurfaceFormatKHR {
10954 pub format: Format,
10955 pub color_space: ColorSpaceKHR,
10956}
10957impl SurfaceFormatKHR {
10958 pub fn builder<'a>() -> SurfaceFormatKHRBuilder<'a> {
10959 SurfaceFormatKHRBuilder {
10960 inner: Self::default(),
10961 marker: ::std::marker::PhantomData,
10962 }
10963 }
10964}
10965#[repr(transparent)]
10966pub struct SurfaceFormatKHRBuilder<'a> {
10967 inner: SurfaceFormatKHR,
10968 marker: ::std::marker::PhantomData<&'a ()>,
10969}
10970impl<'a> ::std::ops::Deref for SurfaceFormatKHRBuilder<'a> {
10971 type Target = SurfaceFormatKHR;
10972 fn deref(&self) -> &Self::Target {
10973 &self.inner
10974 }
10975}
10976impl<'a> ::std::ops::DerefMut for SurfaceFormatKHRBuilder<'a> {
10977 fn deref_mut(&mut self) -> &mut Self::Target {
10978 &mut self.inner
10979 }
10980}
10981impl<'a> SurfaceFormatKHRBuilder<'a> {
10982 pub fn format(mut self, format: Format) -> Self {
10983 self.inner.format = format;
10984 self
10985 }
10986 pub fn color_space(mut self, color_space: ColorSpaceKHR) -> Self {
10987 self.inner.color_space = color_space;
10988 self
10989 }
10990 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10991 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10992 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10993 pub fn build(self) -> SurfaceFormatKHR {
10994 self.inner
10995 }
10996}
10997#[repr(C)]
10998#[cfg_attr(feature = "debug", derive(Debug))]
10999#[derive(Copy, Clone)]
11000#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainCreateInfoKHR.html>"]
11001pub struct SwapchainCreateInfoKHR {
11002 pub s_type: StructureType,
11003 pub p_next: *const c_void,
11004 pub flags: SwapchainCreateFlagsKHR,
11005 pub surface: SurfaceKHR,
11006 pub min_image_count: u32,
11007 pub image_format: Format,
11008 pub image_color_space: ColorSpaceKHR,
11009 pub image_extent: Extent2D,
11010 pub image_array_layers: u32,
11011 pub image_usage: ImageUsageFlags,
11012 pub image_sharing_mode: SharingMode,
11013 pub queue_family_index_count: u32,
11014 pub p_queue_family_indices: *const u32,
11015 pub pre_transform: SurfaceTransformFlagsKHR,
11016 pub composite_alpha: CompositeAlphaFlagsKHR,
11017 pub present_mode: PresentModeKHR,
11018 pub clipped: Bool32,
11019 pub old_swapchain: SwapchainKHR,
11020}
11021impl ::std::default::Default for SwapchainCreateInfoKHR {
11022 fn default() -> Self {
11023 Self {
11024 s_type: StructureType::SWAPCHAIN_CREATE_INFO_KHR,
11025 p_next: ::std::ptr::null(),
11026 flags: SwapchainCreateFlagsKHR::default(),
11027 surface: SurfaceKHR::default(),
11028 min_image_count: u32::default(),
11029 image_format: Format::default(),
11030 image_color_space: ColorSpaceKHR::default(),
11031 image_extent: Extent2D::default(),
11032 image_array_layers: u32::default(),
11033 image_usage: ImageUsageFlags::default(),
11034 image_sharing_mode: SharingMode::default(),
11035 queue_family_index_count: u32::default(),
11036 p_queue_family_indices: ::std::ptr::null(),
11037 pre_transform: SurfaceTransformFlagsKHR::default(),
11038 composite_alpha: CompositeAlphaFlagsKHR::default(),
11039 present_mode: PresentModeKHR::default(),
11040 clipped: Bool32::default(),
11041 old_swapchain: SwapchainKHR::default(),
11042 }
11043 }
11044}
11045impl SwapchainCreateInfoKHR {
11046 pub fn builder<'a>() -> SwapchainCreateInfoKHRBuilder<'a> {
11047 SwapchainCreateInfoKHRBuilder {
11048 inner: Self::default(),
11049 marker: ::std::marker::PhantomData,
11050 }
11051 }
11052}
11053#[repr(transparent)]
11054pub struct SwapchainCreateInfoKHRBuilder<'a> {
11055 inner: SwapchainCreateInfoKHR,
11056 marker: ::std::marker::PhantomData<&'a ()>,
11057}
11058pub unsafe trait ExtendsSwapchainCreateInfoKHR {}
11059impl<'a> ::std::ops::Deref for SwapchainCreateInfoKHRBuilder<'a> {
11060 type Target = SwapchainCreateInfoKHR;
11061 fn deref(&self) -> &Self::Target {
11062 &self.inner
11063 }
11064}
11065impl<'a> ::std::ops::DerefMut for SwapchainCreateInfoKHRBuilder<'a> {
11066 fn deref_mut(&mut self) -> &mut Self::Target {
11067 &mut self.inner
11068 }
11069}
11070impl<'a> SwapchainCreateInfoKHRBuilder<'a> {
11071 pub fn flags(mut self, flags: SwapchainCreateFlagsKHR) -> Self {
11072 self.inner.flags = flags;
11073 self
11074 }
11075 pub fn surface(mut self, surface: SurfaceKHR) -> Self {
11076 self.inner.surface = surface;
11077 self
11078 }
11079 pub fn min_image_count(mut self, min_image_count: u32) -> Self {
11080 self.inner.min_image_count = min_image_count;
11081 self
11082 }
11083 pub fn image_format(mut self, image_format: Format) -> Self {
11084 self.inner.image_format = image_format;
11085 self
11086 }
11087 pub fn image_color_space(mut self, image_color_space: ColorSpaceKHR) -> Self {
11088 self.inner.image_color_space = image_color_space;
11089 self
11090 }
11091 pub fn image_extent(mut self, image_extent: Extent2D) -> Self {
11092 self.inner.image_extent = image_extent;
11093 self
11094 }
11095 pub fn image_array_layers(mut self, image_array_layers: u32) -> Self {
11096 self.inner.image_array_layers = image_array_layers;
11097 self
11098 }
11099 pub fn image_usage(mut self, image_usage: ImageUsageFlags) -> Self {
11100 self.inner.image_usage = image_usage;
11101 self
11102 }
11103 pub fn image_sharing_mode(mut self, image_sharing_mode: SharingMode) -> Self {
11104 self.inner.image_sharing_mode = image_sharing_mode;
11105 self
11106 }
11107 pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self {
11108 self.inner.queue_family_index_count = queue_family_indices.len() as _;
11109 self.inner.p_queue_family_indices = queue_family_indices.as_ptr();
11110 self
11111 }
11112 pub fn pre_transform(mut self, pre_transform: SurfaceTransformFlagsKHR) -> Self {
11113 self.inner.pre_transform = pre_transform;
11114 self
11115 }
11116 pub fn composite_alpha(mut self, composite_alpha: CompositeAlphaFlagsKHR) -> Self {
11117 self.inner.composite_alpha = composite_alpha;
11118 self
11119 }
11120 pub fn present_mode(mut self, present_mode: PresentModeKHR) -> Self {
11121 self.inner.present_mode = present_mode;
11122 self
11123 }
11124 pub fn clipped(mut self, clipped: bool) -> Self {
11125 self.inner.clipped = clipped.into();
11126 self
11127 }
11128 pub fn old_swapchain(mut self, old_swapchain: SwapchainKHR) -> Self {
11129 self.inner.old_swapchain = old_swapchain;
11130 self
11131 }
11132 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
11133 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
11134 #[doc = r" valid extension structs can be pushed into the chain."]
11135 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
11136 #[doc = r" chain will look like `A -> D -> B -> C`."]
11137 pub fn push_next<T: ExtendsSwapchainCreateInfoKHR>(mut self, next: &'a mut T) -> Self {
11138 unsafe {
11139 let next_ptr = <*const T>::cast(next);
11140 let last_next = ptr_chain_iter(next).last().unwrap();
11141 (*last_next).p_next = self.inner.p_next as _;
11142 self.inner.p_next = next_ptr;
11143 }
11144 self
11145 }
11146 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11147 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11148 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
11149 pub fn build(self) -> SwapchainCreateInfoKHR {
11150 self.inner
11151 }
11152}
11153#[repr(C)]
11154#[cfg_attr(feature = "debug", derive(Debug))]
11155#[derive(Copy, Clone)]
11156#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentInfoKHR.html>"]
11157pub struct PresentInfoKHR {
11158 pub s_type: StructureType,
11159 pub p_next: *const c_void,
11160 pub wait_semaphore_count: u32,
11161 pub p_wait_semaphores: *const Semaphore,
11162 pub swapchain_count: u32,
11163 pub p_swapchains: *const SwapchainKHR,
11164 pub p_image_indices: *const u32,
11165 pub p_results: *mut Result,
11166}
11167impl ::std::default::Default for PresentInfoKHR {
11168 fn default() -> Self {
11169 Self {
11170 s_type: StructureType::PRESENT_INFO_KHR,
11171 p_next: ::std::ptr::null(),
11172 wait_semaphore_count: u32::default(),
11173 p_wait_semaphores: ::std::ptr::null(),
11174 swapchain_count: u32::default(),
11175 p_swapchains: ::std::ptr::null(),
11176 p_image_indices: ::std::ptr::null(),
11177 p_results: ::std::ptr::null_mut(),
11178 }
11179 }
11180}
11181impl PresentInfoKHR {
11182 pub fn builder<'a>() -> PresentInfoKHRBuilder<'a> {
11183 PresentInfoKHRBuilder {
11184 inner: Self::default(),
11185 marker: ::std::marker::PhantomData,
11186 }
11187 }
11188}
11189#[repr(transparent)]
11190pub struct PresentInfoKHRBuilder<'a> {
11191 inner: PresentInfoKHR,
11192 marker: ::std::marker::PhantomData<&'a ()>,
11193}
11194pub unsafe trait ExtendsPresentInfoKHR {}
11195impl<'a> ::std::ops::Deref for PresentInfoKHRBuilder<'a> {
11196 type Target = PresentInfoKHR;
11197 fn deref(&self) -> &Self::Target {
11198 &self.inner
11199 }
11200}
11201impl<'a> ::std::ops::DerefMut for PresentInfoKHRBuilder<'a> {
11202 fn deref_mut(&mut self) -> &mut Self::Target {
11203 &mut self.inner
11204 }
11205}
11206impl<'a> PresentInfoKHRBuilder<'a> {
11207 pub fn wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> Self {
11208 self.inner.wait_semaphore_count = wait_semaphores.len() as _;
11209 self.inner.p_wait_semaphores = wait_semaphores.as_ptr();
11210 self
11211 }
11212 pub fn swapchains(mut self, swapchains: &'a [SwapchainKHR]) -> Self {
11213 self.inner.swapchain_count = swapchains.len() as _;
11214 self.inner.p_swapchains = swapchains.as_ptr();
11215 self
11216 }
11217 pub fn image_indices(mut self, image_indices: &'a [u32]) -> Self {
11218 self.inner.swapchain_count = image_indices.len() as _;
11219 self.inner.p_image_indices = image_indices.as_ptr();
11220 self
11221 }
11222 pub fn results(mut self, results: &'a mut [Result]) -> Self {
11223 self.inner.swapchain_count = results.len() as _;
11224 self.inner.p_results = results.as_mut_ptr();
11225 self
11226 }
11227 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
11228 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
11229 #[doc = r" valid extension structs can be pushed into the chain."]
11230 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
11231 #[doc = r" chain will look like `A -> D -> B -> C`."]
11232 pub fn push_next<T: ExtendsPresentInfoKHR>(mut self, next: &'a mut T) -> Self {
11233 unsafe {
11234 let next_ptr = <*const T>::cast(next);
11235 let last_next = ptr_chain_iter(next).last().unwrap();
11236 (*last_next).p_next = self.inner.p_next as _;
11237 self.inner.p_next = next_ptr;
11238 }
11239 self
11240 }
11241 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11242 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11243 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
11244 pub fn build(self) -> PresentInfoKHR {
11245 self.inner
11246 }
11247}
11248#[repr(C)]
11249#[derive(Copy, Clone)]
11250#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugReportCallbackCreateInfoEXT.html>"]
11251pub struct DebugReportCallbackCreateInfoEXT {
11252 pub s_type: StructureType,
11253 pub p_next: *const c_void,
11254 pub flags: DebugReportFlagsEXT,
11255 pub pfn_callback: PFN_vkDebugReportCallbackEXT,
11256 pub p_user_data: *mut c_void,
11257}
11258#[cfg(feature = "debug")]
11259impl fmt::Debug for DebugReportCallbackCreateInfoEXT {
11260 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
11261 fmt.debug_struct("DebugReportCallbackCreateInfoEXT")
11262 .field("s_type", &self.s_type)
11263 .field("p_next", &self.p_next)
11264 .field("flags", &self.flags)
11265 .field("pfn_callback", &(self.pfn_callback.map(|x| x as *const ())))
11266 .field("p_user_data", &self.p_user_data)
11267 .finish()
11268 }
11269}
11270impl ::std::default::Default for DebugReportCallbackCreateInfoEXT {
11271 fn default() -> Self {
11272 Self {
11273 s_type: StructureType::DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
11274 p_next: ::std::ptr::null(),
11275 flags: DebugReportFlagsEXT::default(),
11276 pfn_callback: PFN_vkDebugReportCallbackEXT::default(),
11277 p_user_data: ::std::ptr::null_mut(),
11278 }
11279 }
11280}
11281impl DebugReportCallbackCreateInfoEXT {
11282 pub fn builder<'a>() -> DebugReportCallbackCreateInfoEXTBuilder<'a> {
11283 DebugReportCallbackCreateInfoEXTBuilder {
11284 inner: Self::default(),
11285 marker: ::std::marker::PhantomData,
11286 }
11287 }
11288}
11289#[repr(transparent)]
11290pub struct DebugReportCallbackCreateInfoEXTBuilder<'a> {
11291 inner: DebugReportCallbackCreateInfoEXT,
11292 marker: ::std::marker::PhantomData<&'a ()>,
11293}
11294unsafe impl ExtendsInstanceCreateInfo for DebugReportCallbackCreateInfoEXTBuilder<'_> {}
11295unsafe impl ExtendsInstanceCreateInfo for DebugReportCallbackCreateInfoEXT {}
11296impl<'a> ::std::ops::Deref for DebugReportCallbackCreateInfoEXTBuilder<'a> {
11297 type Target = DebugReportCallbackCreateInfoEXT;
11298 fn deref(&self) -> &Self::Target {
11299 &self.inner
11300 }
11301}
11302impl<'a> ::std::ops::DerefMut for DebugReportCallbackCreateInfoEXTBuilder<'a> {
11303 fn deref_mut(&mut self) -> &mut Self::Target {
11304 &mut self.inner
11305 }
11306}
11307impl<'a> DebugReportCallbackCreateInfoEXTBuilder<'a> {
11308 pub fn flags(mut self, flags: DebugReportFlagsEXT) -> Self {
11309 self.inner.flags = flags;
11310 self
11311 }
11312 pub fn pfn_callback(mut self, pfn_callback: PFN_vkDebugReportCallbackEXT) -> Self {
11313 self.inner.pfn_callback = pfn_callback;
11314 self
11315 }
11316 pub fn user_data(mut self, user_data: *mut c_void) -> Self {
11317 self.inner.p_user_data = user_data;
11318 self
11319 }
11320 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11321 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11322 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
11323 pub fn build(self) -> DebugReportCallbackCreateInfoEXT {
11324 self.inner
11325 }
11326}
11327#[repr(C)]
11328#[cfg_attr(feature = "debug", derive(Debug))]
11329#[derive(Copy, Clone)]
11330#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationFlagsEXT.html>"]
11331pub struct ValidationFlagsEXT {
11332 pub s_type: StructureType,
11333 pub p_next: *const c_void,
11334 pub disabled_validation_check_count: u32,
11335 pub p_disabled_validation_checks: *const ValidationCheckEXT,
11336}
11337impl ::std::default::Default for ValidationFlagsEXT {
11338 fn default() -> Self {
11339 Self {
11340 s_type: StructureType::VALIDATION_FLAGS_EXT,
11341 p_next: ::std::ptr::null(),
11342 disabled_validation_check_count: u32::default(),
11343 p_disabled_validation_checks: ::std::ptr::null(),
11344 }
11345 }
11346}
11347impl ValidationFlagsEXT {
11348 pub fn builder<'a>() -> ValidationFlagsEXTBuilder<'a> {
11349 ValidationFlagsEXTBuilder {
11350 inner: Self::default(),
11351 marker: ::std::marker::PhantomData,
11352 }
11353 }
11354}
11355#[repr(transparent)]
11356pub struct ValidationFlagsEXTBuilder<'a> {
11357 inner: ValidationFlagsEXT,
11358 marker: ::std::marker::PhantomData<&'a ()>,
11359}
11360unsafe impl ExtendsInstanceCreateInfo for ValidationFlagsEXTBuilder<'_> {}
11361unsafe impl ExtendsInstanceCreateInfo for ValidationFlagsEXT {}
11362impl<'a> ::std::ops::Deref for ValidationFlagsEXTBuilder<'a> {
11363 type Target = ValidationFlagsEXT;
11364 fn deref(&self) -> &Self::Target {
11365 &self.inner
11366 }
11367}
11368impl<'a> ::std::ops::DerefMut for ValidationFlagsEXTBuilder<'a> {
11369 fn deref_mut(&mut self) -> &mut Self::Target {
11370 &mut self.inner
11371 }
11372}
11373impl<'a> ValidationFlagsEXTBuilder<'a> {
11374 pub fn disabled_validation_checks(
11375 mut self,
11376 disabled_validation_checks: &'a [ValidationCheckEXT],
11377 ) -> Self {
11378 self.inner.disabled_validation_check_count = disabled_validation_checks.len() as _;
11379 self.inner.p_disabled_validation_checks = disabled_validation_checks.as_ptr();
11380 self
11381 }
11382 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11383 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11384 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
11385 pub fn build(self) -> ValidationFlagsEXT {
11386 self.inner
11387 }
11388}
11389#[repr(C)]
11390#[cfg_attr(feature = "debug", derive(Debug))]
11391#[derive(Copy, Clone)]
11392#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationFeaturesEXT.html>"]
11393pub struct ValidationFeaturesEXT {
11394 pub s_type: StructureType,
11395 pub p_next: *const c_void,
11396 pub enabled_validation_feature_count: u32,
11397 pub p_enabled_validation_features: *const ValidationFeatureEnableEXT,
11398 pub disabled_validation_feature_count: u32,
11399 pub p_disabled_validation_features: *const ValidationFeatureDisableEXT,
11400}
11401impl ::std::default::Default for ValidationFeaturesEXT {
11402 fn default() -> Self {
11403 Self {
11404 s_type: StructureType::VALIDATION_FEATURES_EXT,
11405 p_next: ::std::ptr::null(),
11406 enabled_validation_feature_count: u32::default(),
11407 p_enabled_validation_features: ::std::ptr::null(),
11408 disabled_validation_feature_count: u32::default(),
11409 p_disabled_validation_features: ::std::ptr::null(),
11410 }
11411 }
11412}
11413impl ValidationFeaturesEXT {
11414 pub fn builder<'a>() -> ValidationFeaturesEXTBuilder<'a> {
11415 ValidationFeaturesEXTBuilder {
11416 inner: Self::default(),
11417 marker: ::std::marker::PhantomData,
11418 }
11419 }
11420}
11421#[repr(transparent)]
11422pub struct ValidationFeaturesEXTBuilder<'a> {
11423 inner: ValidationFeaturesEXT,
11424 marker: ::std::marker::PhantomData<&'a ()>,
11425}
11426unsafe impl ExtendsInstanceCreateInfo for ValidationFeaturesEXTBuilder<'_> {}
11427unsafe impl ExtendsInstanceCreateInfo for ValidationFeaturesEXT {}
11428impl<'a> ::std::ops::Deref for ValidationFeaturesEXTBuilder<'a> {
11429 type Target = ValidationFeaturesEXT;
11430 fn deref(&self) -> &Self::Target {
11431 &self.inner
11432 }
11433}
11434impl<'a> ::std::ops::DerefMut for ValidationFeaturesEXTBuilder<'a> {
11435 fn deref_mut(&mut self) -> &mut Self::Target {
11436 &mut self.inner
11437 }
11438}
11439impl<'a> ValidationFeaturesEXTBuilder<'a> {
11440 pub fn enabled_validation_features(
11441 mut self,
11442 enabled_validation_features: &'a [ValidationFeatureEnableEXT],
11443 ) -> Self {
11444 self.inner.enabled_validation_feature_count = enabled_validation_features.len() as _;
11445 self.inner.p_enabled_validation_features = enabled_validation_features.as_ptr();
11446 self
11447 }
11448 pub fn disabled_validation_features(
11449 mut self,
11450 disabled_validation_features: &'a [ValidationFeatureDisableEXT],
11451 ) -> Self {
11452 self.inner.disabled_validation_feature_count = disabled_validation_features.len() as _;
11453 self.inner.p_disabled_validation_features = disabled_validation_features.as_ptr();
11454 self
11455 }
11456 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11457 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11458 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
11459 pub fn build(self) -> ValidationFeaturesEXT {
11460 self.inner
11461 }
11462}
11463#[repr(C)]
11464#[cfg_attr(feature = "debug", derive(Debug))]
11465#[derive(Copy, Clone)]
11466#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationStateRasterizationOrderAMD.html>"]
11467pub struct PipelineRasterizationStateRasterizationOrderAMD {
11468 pub s_type: StructureType,
11469 pub p_next: *const c_void,
11470 pub rasterization_order: RasterizationOrderAMD,
11471}
11472impl ::std::default::Default for PipelineRasterizationStateRasterizationOrderAMD {
11473 fn default() -> Self {
11474 Self {
11475 s_type: StructureType::PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD,
11476 p_next: ::std::ptr::null(),
11477 rasterization_order: RasterizationOrderAMD::default(),
11478 }
11479 }
11480}
11481impl PipelineRasterizationStateRasterizationOrderAMD {
11482 pub fn builder<'a>() -> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
11483 PipelineRasterizationStateRasterizationOrderAMDBuilder {
11484 inner: Self::default(),
11485 marker: ::std::marker::PhantomData,
11486 }
11487 }
11488}
11489#[repr(transparent)]
11490pub struct PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
11491 inner: PipelineRasterizationStateRasterizationOrderAMD,
11492 marker: ::std::marker::PhantomData<&'a ()>,
11493}
11494unsafe impl ExtendsPipelineRasterizationStateCreateInfo
11495 for PipelineRasterizationStateRasterizationOrderAMDBuilder<'_>
11496{
11497}
11498unsafe impl ExtendsPipelineRasterizationStateCreateInfo
11499 for PipelineRasterizationStateRasterizationOrderAMD
11500{
11501}
11502impl<'a> ::std::ops::Deref for PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
11503 type Target = PipelineRasterizationStateRasterizationOrderAMD;
11504 fn deref(&self) -> &Self::Target {
11505 &self.inner
11506 }
11507}
11508impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
11509 fn deref_mut(&mut self) -> &mut Self::Target {
11510 &mut self.inner
11511 }
11512}
11513impl<'a> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
11514 pub fn rasterization_order(mut self, rasterization_order: RasterizationOrderAMD) -> Self {
11515 self.inner.rasterization_order = rasterization_order;
11516 self
11517 }
11518 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11519 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11520 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
11521 pub fn build(self) -> PipelineRasterizationStateRasterizationOrderAMD {
11522 self.inner
11523 }
11524}
11525#[repr(C)]
11526#[cfg_attr(feature = "debug", derive(Debug))]
11527#[derive(Copy, Clone)]
11528#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugMarkerObjectNameInfoEXT.html>"]
11529pub struct DebugMarkerObjectNameInfoEXT {
11530 pub s_type: StructureType,
11531 pub p_next: *const c_void,
11532 pub object_type: DebugReportObjectTypeEXT,
11533 pub object: u64,
11534 pub p_object_name: *const c_char,
11535}
11536impl ::std::default::Default for DebugMarkerObjectNameInfoEXT {
11537 fn default() -> Self {
11538 Self {
11539 s_type: StructureType::DEBUG_MARKER_OBJECT_NAME_INFO_EXT,
11540 p_next: ::std::ptr::null(),
11541 object_type: DebugReportObjectTypeEXT::default(),
11542 object: u64::default(),
11543 p_object_name: ::std::ptr::null(),
11544 }
11545 }
11546}
11547impl DebugMarkerObjectNameInfoEXT {
11548 pub fn builder<'a>() -> DebugMarkerObjectNameInfoEXTBuilder<'a> {
11549 DebugMarkerObjectNameInfoEXTBuilder {
11550 inner: Self::default(),
11551 marker: ::std::marker::PhantomData,
11552 }
11553 }
11554}
11555#[repr(transparent)]
11556pub struct DebugMarkerObjectNameInfoEXTBuilder<'a> {
11557 inner: DebugMarkerObjectNameInfoEXT,
11558 marker: ::std::marker::PhantomData<&'a ()>,
11559}
11560impl<'a> ::std::ops::Deref for DebugMarkerObjectNameInfoEXTBuilder<'a> {
11561 type Target = DebugMarkerObjectNameInfoEXT;
11562 fn deref(&self) -> &Self::Target {
11563 &self.inner
11564 }
11565}
11566impl<'a> ::std::ops::DerefMut for DebugMarkerObjectNameInfoEXTBuilder<'a> {
11567 fn deref_mut(&mut self) -> &mut Self::Target {
11568 &mut self.inner
11569 }
11570}
11571impl<'a> DebugMarkerObjectNameInfoEXTBuilder<'a> {
11572 pub fn object_type(mut self, object_type: DebugReportObjectTypeEXT) -> Self {
11573 self.inner.object_type = object_type;
11574 self
11575 }
11576 pub fn object(mut self, object: u64) -> Self {
11577 self.inner.object = object;
11578 self
11579 }
11580 pub fn object_name(mut self, object_name: &'a ::std::ffi::CStr) -> Self {
11581 self.inner.p_object_name = object_name.as_ptr();
11582 self
11583 }
11584 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11585 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11586 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
11587 pub fn build(self) -> DebugMarkerObjectNameInfoEXT {
11588 self.inner
11589 }
11590}
11591#[repr(C)]
11592#[cfg_attr(feature = "debug", derive(Debug))]
11593#[derive(Copy, Clone)]
11594#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugMarkerObjectTagInfoEXT.html>"]
11595pub struct DebugMarkerObjectTagInfoEXT {
11596 pub s_type: StructureType,
11597 pub p_next: *const c_void,
11598 pub object_type: DebugReportObjectTypeEXT,
11599 pub object: u64,
11600 pub tag_name: u64,
11601 pub tag_size: usize,
11602 pub p_tag: *const c_void,
11603}
11604impl ::std::default::Default for DebugMarkerObjectTagInfoEXT {
11605 fn default() -> Self {
11606 Self {
11607 s_type: StructureType::DEBUG_MARKER_OBJECT_TAG_INFO_EXT,
11608 p_next: ::std::ptr::null(),
11609 object_type: DebugReportObjectTypeEXT::default(),
11610 object: u64::default(),
11611 tag_name: u64::default(),
11612 tag_size: usize::default(),
11613 p_tag: ::std::ptr::null(),
11614 }
11615 }
11616}
11617impl DebugMarkerObjectTagInfoEXT {
11618 pub fn builder<'a>() -> DebugMarkerObjectTagInfoEXTBuilder<'a> {
11619 DebugMarkerObjectTagInfoEXTBuilder {
11620 inner: Self::default(),
11621 marker: ::std::marker::PhantomData,
11622 }
11623 }
11624}
11625#[repr(transparent)]
11626pub struct DebugMarkerObjectTagInfoEXTBuilder<'a> {
11627 inner: DebugMarkerObjectTagInfoEXT,
11628 marker: ::std::marker::PhantomData<&'a ()>,
11629}
11630impl<'a> ::std::ops::Deref for DebugMarkerObjectTagInfoEXTBuilder<'a> {
11631 type Target = DebugMarkerObjectTagInfoEXT;
11632 fn deref(&self) -> &Self::Target {
11633 &self.inner
11634 }
11635}
11636impl<'a> ::std::ops::DerefMut for DebugMarkerObjectTagInfoEXTBuilder<'a> {
11637 fn deref_mut(&mut self) -> &mut Self::Target {
11638 &mut self.inner
11639 }
11640}
11641impl<'a> DebugMarkerObjectTagInfoEXTBuilder<'a> {
11642 pub fn object_type(mut self, object_type: DebugReportObjectTypeEXT) -> Self {
11643 self.inner.object_type = object_type;
11644 self
11645 }
11646 pub fn object(mut self, object: u64) -> Self {
11647 self.inner.object = object;
11648 self
11649 }
11650 pub fn tag_name(mut self, tag_name: u64) -> Self {
11651 self.inner.tag_name = tag_name;
11652 self
11653 }
11654 pub fn tag(mut self, tag: &'a [u8]) -> Self {
11655 self.inner.tag_size = tag.len();
11656 self.inner.p_tag = tag.as_ptr() as *const c_void;
11657 self
11658 }
11659 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11660 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11661 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
11662 pub fn build(self) -> DebugMarkerObjectTagInfoEXT {
11663 self.inner
11664 }
11665}
11666#[repr(C)]
11667#[cfg_attr(feature = "debug", derive(Debug))]
11668#[derive(Copy, Clone)]
11669#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugMarkerMarkerInfoEXT.html>"]
11670pub struct DebugMarkerMarkerInfoEXT {
11671 pub s_type: StructureType,
11672 pub p_next: *const c_void,
11673 pub p_marker_name: *const c_char,
11674 pub color: [f32; 4],
11675}
11676impl ::std::default::Default for DebugMarkerMarkerInfoEXT {
11677 fn default() -> Self {
11678 Self {
11679 s_type: StructureType::DEBUG_MARKER_MARKER_INFO_EXT,
11680 p_next: ::std::ptr::null(),
11681 p_marker_name: ::std::ptr::null(),
11682 color: unsafe { ::std::mem::zeroed() },
11683 }
11684 }
11685}
11686impl DebugMarkerMarkerInfoEXT {
11687 pub fn builder<'a>() -> DebugMarkerMarkerInfoEXTBuilder<'a> {
11688 DebugMarkerMarkerInfoEXTBuilder {
11689 inner: Self::default(),
11690 marker: ::std::marker::PhantomData,
11691 }
11692 }
11693}
11694#[repr(transparent)]
11695pub struct DebugMarkerMarkerInfoEXTBuilder<'a> {
11696 inner: DebugMarkerMarkerInfoEXT,
11697 marker: ::std::marker::PhantomData<&'a ()>,
11698}
11699impl<'a> ::std::ops::Deref for DebugMarkerMarkerInfoEXTBuilder<'a> {
11700 type Target = DebugMarkerMarkerInfoEXT;
11701 fn deref(&self) -> &Self::Target {
11702 &self.inner
11703 }
11704}
11705impl<'a> ::std::ops::DerefMut for DebugMarkerMarkerInfoEXTBuilder<'a> {
11706 fn deref_mut(&mut self) -> &mut Self::Target {
11707 &mut self.inner
11708 }
11709}
11710impl<'a> DebugMarkerMarkerInfoEXTBuilder<'a> {
11711 pub fn marker_name(mut self, marker_name: &'a ::std::ffi::CStr) -> Self {
11712 self.inner.p_marker_name = marker_name.as_ptr();
11713 self
11714 }
11715 pub fn color(mut self, color: [f32; 4]) -> Self {
11716 self.inner.color = color;
11717 self
11718 }
11719 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11720 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11721 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
11722 pub fn build(self) -> DebugMarkerMarkerInfoEXT {
11723 self.inner
11724 }
11725}
11726#[repr(C)]
11727#[cfg_attr(feature = "debug", derive(Debug))]
11728#[derive(Copy, Clone)]
11729#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDedicatedAllocationImageCreateInfoNV.html>"]
11730pub struct DedicatedAllocationImageCreateInfoNV {
11731 pub s_type: StructureType,
11732 pub p_next: *const c_void,
11733 pub dedicated_allocation: Bool32,
11734}
11735impl ::std::default::Default for DedicatedAllocationImageCreateInfoNV {
11736 fn default() -> Self {
11737 Self {
11738 s_type: StructureType::DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV,
11739 p_next: ::std::ptr::null(),
11740 dedicated_allocation: Bool32::default(),
11741 }
11742 }
11743}
11744impl DedicatedAllocationImageCreateInfoNV {
11745 pub fn builder<'a>() -> DedicatedAllocationImageCreateInfoNVBuilder<'a> {
11746 DedicatedAllocationImageCreateInfoNVBuilder {
11747 inner: Self::default(),
11748 marker: ::std::marker::PhantomData,
11749 }
11750 }
11751}
11752#[repr(transparent)]
11753pub struct DedicatedAllocationImageCreateInfoNVBuilder<'a> {
11754 inner: DedicatedAllocationImageCreateInfoNV,
11755 marker: ::std::marker::PhantomData<&'a ()>,
11756}
11757unsafe impl ExtendsImageCreateInfo for DedicatedAllocationImageCreateInfoNVBuilder<'_> {}
11758unsafe impl ExtendsImageCreateInfo for DedicatedAllocationImageCreateInfoNV {}
11759impl<'a> ::std::ops::Deref for DedicatedAllocationImageCreateInfoNVBuilder<'a> {
11760 type Target = DedicatedAllocationImageCreateInfoNV;
11761 fn deref(&self) -> &Self::Target {
11762 &self.inner
11763 }
11764}
11765impl<'a> ::std::ops::DerefMut for DedicatedAllocationImageCreateInfoNVBuilder<'a> {
11766 fn deref_mut(&mut self) -> &mut Self::Target {
11767 &mut self.inner
11768 }
11769}
11770impl<'a> DedicatedAllocationImageCreateInfoNVBuilder<'a> {
11771 pub fn dedicated_allocation(mut self, dedicated_allocation: bool) -> Self {
11772 self.inner.dedicated_allocation = dedicated_allocation.into();
11773 self
11774 }
11775 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11776 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11777 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
11778 pub fn build(self) -> DedicatedAllocationImageCreateInfoNV {
11779 self.inner
11780 }
11781}
11782#[repr(C)]
11783#[cfg_attr(feature = "debug", derive(Debug))]
11784#[derive(Copy, Clone)]
11785#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDedicatedAllocationBufferCreateInfoNV.html>"]
11786pub struct DedicatedAllocationBufferCreateInfoNV {
11787 pub s_type: StructureType,
11788 pub p_next: *const c_void,
11789 pub dedicated_allocation: Bool32,
11790}
11791impl ::std::default::Default for DedicatedAllocationBufferCreateInfoNV {
11792 fn default() -> Self {
11793 Self {
11794 s_type: StructureType::DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV,
11795 p_next: ::std::ptr::null(),
11796 dedicated_allocation: Bool32::default(),
11797 }
11798 }
11799}
11800impl DedicatedAllocationBufferCreateInfoNV {
11801 pub fn builder<'a>() -> DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
11802 DedicatedAllocationBufferCreateInfoNVBuilder {
11803 inner: Self::default(),
11804 marker: ::std::marker::PhantomData,
11805 }
11806 }
11807}
11808#[repr(transparent)]
11809pub struct DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
11810 inner: DedicatedAllocationBufferCreateInfoNV,
11811 marker: ::std::marker::PhantomData<&'a ()>,
11812}
11813unsafe impl ExtendsBufferCreateInfo for DedicatedAllocationBufferCreateInfoNVBuilder<'_> {}
11814unsafe impl ExtendsBufferCreateInfo for DedicatedAllocationBufferCreateInfoNV {}
11815impl<'a> ::std::ops::Deref for DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
11816 type Target = DedicatedAllocationBufferCreateInfoNV;
11817 fn deref(&self) -> &Self::Target {
11818 &self.inner
11819 }
11820}
11821impl<'a> ::std::ops::DerefMut for DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
11822 fn deref_mut(&mut self) -> &mut Self::Target {
11823 &mut self.inner
11824 }
11825}
11826impl<'a> DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
11827 pub fn dedicated_allocation(mut self, dedicated_allocation: bool) -> Self {
11828 self.inner.dedicated_allocation = dedicated_allocation.into();
11829 self
11830 }
11831 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11832 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11833 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
11834 pub fn build(self) -> DedicatedAllocationBufferCreateInfoNV {
11835 self.inner
11836 }
11837}
11838#[repr(C)]
11839#[cfg_attr(feature = "debug", derive(Debug))]
11840#[derive(Copy, Clone)]
11841#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDedicatedAllocationMemoryAllocateInfoNV.html>"]
11842pub struct DedicatedAllocationMemoryAllocateInfoNV {
11843 pub s_type: StructureType,
11844 pub p_next: *const c_void,
11845 pub image: Image,
11846 pub buffer: Buffer,
11847}
11848impl ::std::default::Default for DedicatedAllocationMemoryAllocateInfoNV {
11849 fn default() -> Self {
11850 Self {
11851 s_type: StructureType::DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV,
11852 p_next: ::std::ptr::null(),
11853 image: Image::default(),
11854 buffer: Buffer::default(),
11855 }
11856 }
11857}
11858impl DedicatedAllocationMemoryAllocateInfoNV {
11859 pub fn builder<'a>() -> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
11860 DedicatedAllocationMemoryAllocateInfoNVBuilder {
11861 inner: Self::default(),
11862 marker: ::std::marker::PhantomData,
11863 }
11864 }
11865}
11866#[repr(transparent)]
11867pub struct DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
11868 inner: DedicatedAllocationMemoryAllocateInfoNV,
11869 marker: ::std::marker::PhantomData<&'a ()>,
11870}
11871unsafe impl ExtendsMemoryAllocateInfo for DedicatedAllocationMemoryAllocateInfoNVBuilder<'_> {}
11872unsafe impl ExtendsMemoryAllocateInfo for DedicatedAllocationMemoryAllocateInfoNV {}
11873impl<'a> ::std::ops::Deref for DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
11874 type Target = DedicatedAllocationMemoryAllocateInfoNV;
11875 fn deref(&self) -> &Self::Target {
11876 &self.inner
11877 }
11878}
11879impl<'a> ::std::ops::DerefMut for DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
11880 fn deref_mut(&mut self) -> &mut Self::Target {
11881 &mut self.inner
11882 }
11883}
11884impl<'a> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
11885 pub fn image(mut self, image: Image) -> Self {
11886 self.inner.image = image;
11887 self
11888 }
11889 pub fn buffer(mut self, buffer: Buffer) -> Self {
11890 self.inner.buffer = buffer;
11891 self
11892 }
11893 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11894 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11895 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
11896 pub fn build(self) -> DedicatedAllocationMemoryAllocateInfoNV {
11897 self.inner
11898 }
11899}
11900#[repr(C)]
11901#[cfg_attr(feature = "debug", derive(Debug))]
11902#[derive(Copy, Clone, Default)]
11903#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalImageFormatPropertiesNV.html>"]
11904pub struct ExternalImageFormatPropertiesNV {
11905 pub image_format_properties: ImageFormatProperties,
11906 pub external_memory_features: ExternalMemoryFeatureFlagsNV,
11907 pub export_from_imported_handle_types: ExternalMemoryHandleTypeFlagsNV,
11908 pub compatible_handle_types: ExternalMemoryHandleTypeFlagsNV,
11909}
11910impl ExternalImageFormatPropertiesNV {
11911 pub fn builder<'a>() -> ExternalImageFormatPropertiesNVBuilder<'a> {
11912 ExternalImageFormatPropertiesNVBuilder {
11913 inner: Self::default(),
11914 marker: ::std::marker::PhantomData,
11915 }
11916 }
11917}
11918#[repr(transparent)]
11919pub struct ExternalImageFormatPropertiesNVBuilder<'a> {
11920 inner: ExternalImageFormatPropertiesNV,
11921 marker: ::std::marker::PhantomData<&'a ()>,
11922}
11923impl<'a> ::std::ops::Deref for ExternalImageFormatPropertiesNVBuilder<'a> {
11924 type Target = ExternalImageFormatPropertiesNV;
11925 fn deref(&self) -> &Self::Target {
11926 &self.inner
11927 }
11928}
11929impl<'a> ::std::ops::DerefMut for ExternalImageFormatPropertiesNVBuilder<'a> {
11930 fn deref_mut(&mut self) -> &mut Self::Target {
11931 &mut self.inner
11932 }
11933}
11934impl<'a> ExternalImageFormatPropertiesNVBuilder<'a> {
11935 pub fn image_format_properties(
11936 mut self,
11937 image_format_properties: ImageFormatProperties,
11938 ) -> Self {
11939 self.inner.image_format_properties = image_format_properties;
11940 self
11941 }
11942 pub fn external_memory_features(
11943 mut self,
11944 external_memory_features: ExternalMemoryFeatureFlagsNV,
11945 ) -> Self {
11946 self.inner.external_memory_features = external_memory_features;
11947 self
11948 }
11949 pub fn export_from_imported_handle_types(
11950 mut self,
11951 export_from_imported_handle_types: ExternalMemoryHandleTypeFlagsNV,
11952 ) -> Self {
11953 self.inner.export_from_imported_handle_types = export_from_imported_handle_types;
11954 self
11955 }
11956 pub fn compatible_handle_types(
11957 mut self,
11958 compatible_handle_types: ExternalMemoryHandleTypeFlagsNV,
11959 ) -> Self {
11960 self.inner.compatible_handle_types = compatible_handle_types;
11961 self
11962 }
11963 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11964 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11965 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
11966 pub fn build(self) -> ExternalImageFormatPropertiesNV {
11967 self.inner
11968 }
11969}
11970#[repr(C)]
11971#[cfg_attr(feature = "debug", derive(Debug))]
11972#[derive(Copy, Clone)]
11973#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryImageCreateInfoNV.html>"]
11974pub struct ExternalMemoryImageCreateInfoNV {
11975 pub s_type: StructureType,
11976 pub p_next: *const c_void,
11977 pub handle_types: ExternalMemoryHandleTypeFlagsNV,
11978}
11979impl ::std::default::Default for ExternalMemoryImageCreateInfoNV {
11980 fn default() -> Self {
11981 Self {
11982 s_type: StructureType::EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV,
11983 p_next: ::std::ptr::null(),
11984 handle_types: ExternalMemoryHandleTypeFlagsNV::default(),
11985 }
11986 }
11987}
11988impl ExternalMemoryImageCreateInfoNV {
11989 pub fn builder<'a>() -> ExternalMemoryImageCreateInfoNVBuilder<'a> {
11990 ExternalMemoryImageCreateInfoNVBuilder {
11991 inner: Self::default(),
11992 marker: ::std::marker::PhantomData,
11993 }
11994 }
11995}
11996#[repr(transparent)]
11997pub struct ExternalMemoryImageCreateInfoNVBuilder<'a> {
11998 inner: ExternalMemoryImageCreateInfoNV,
11999 marker: ::std::marker::PhantomData<&'a ()>,
12000}
12001unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoNVBuilder<'_> {}
12002unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoNV {}
12003impl<'a> ::std::ops::Deref for ExternalMemoryImageCreateInfoNVBuilder<'a> {
12004 type Target = ExternalMemoryImageCreateInfoNV;
12005 fn deref(&self) -> &Self::Target {
12006 &self.inner
12007 }
12008}
12009impl<'a> ::std::ops::DerefMut for ExternalMemoryImageCreateInfoNVBuilder<'a> {
12010 fn deref_mut(&mut self) -> &mut Self::Target {
12011 &mut self.inner
12012 }
12013}
12014impl<'a> ExternalMemoryImageCreateInfoNVBuilder<'a> {
12015 pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlagsNV) -> Self {
12016 self.inner.handle_types = handle_types;
12017 self
12018 }
12019 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12020 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12021 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12022 pub fn build(self) -> ExternalMemoryImageCreateInfoNV {
12023 self.inner
12024 }
12025}
12026#[repr(C)]
12027#[cfg_attr(feature = "debug", derive(Debug))]
12028#[derive(Copy, Clone)]
12029#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMemoryAllocateInfoNV.html>"]
12030pub struct ExportMemoryAllocateInfoNV {
12031 pub s_type: StructureType,
12032 pub p_next: *const c_void,
12033 pub handle_types: ExternalMemoryHandleTypeFlagsNV,
12034}
12035impl ::std::default::Default for ExportMemoryAllocateInfoNV {
12036 fn default() -> Self {
12037 Self {
12038 s_type: StructureType::EXPORT_MEMORY_ALLOCATE_INFO_NV,
12039 p_next: ::std::ptr::null(),
12040 handle_types: ExternalMemoryHandleTypeFlagsNV::default(),
12041 }
12042 }
12043}
12044impl ExportMemoryAllocateInfoNV {
12045 pub fn builder<'a>() -> ExportMemoryAllocateInfoNVBuilder<'a> {
12046 ExportMemoryAllocateInfoNVBuilder {
12047 inner: Self::default(),
12048 marker: ::std::marker::PhantomData,
12049 }
12050 }
12051}
12052#[repr(transparent)]
12053pub struct ExportMemoryAllocateInfoNVBuilder<'a> {
12054 inner: ExportMemoryAllocateInfoNV,
12055 marker: ::std::marker::PhantomData<&'a ()>,
12056}
12057unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoNVBuilder<'_> {}
12058unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoNV {}
12059impl<'a> ::std::ops::Deref for ExportMemoryAllocateInfoNVBuilder<'a> {
12060 type Target = ExportMemoryAllocateInfoNV;
12061 fn deref(&self) -> &Self::Target {
12062 &self.inner
12063 }
12064}
12065impl<'a> ::std::ops::DerefMut for ExportMemoryAllocateInfoNVBuilder<'a> {
12066 fn deref_mut(&mut self) -> &mut Self::Target {
12067 &mut self.inner
12068 }
12069}
12070impl<'a> ExportMemoryAllocateInfoNVBuilder<'a> {
12071 pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlagsNV) -> Self {
12072 self.inner.handle_types = handle_types;
12073 self
12074 }
12075 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12076 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12077 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12078 pub fn build(self) -> ExportMemoryAllocateInfoNV {
12079 self.inner
12080 }
12081}
12082#[repr(C)]
12083#[cfg_attr(feature = "debug", derive(Debug))]
12084#[derive(Copy, Clone)]
12085#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMemoryWin32HandleInfoNV.html>"]
12086pub struct ImportMemoryWin32HandleInfoNV {
12087 pub s_type: StructureType,
12088 pub p_next: *const c_void,
12089 pub handle_type: ExternalMemoryHandleTypeFlagsNV,
12090 pub handle: HANDLE,
12091}
12092impl ::std::default::Default for ImportMemoryWin32HandleInfoNV {
12093 fn default() -> Self {
12094 Self {
12095 s_type: StructureType::IMPORT_MEMORY_WIN32_HANDLE_INFO_NV,
12096 p_next: ::std::ptr::null(),
12097 handle_type: ExternalMemoryHandleTypeFlagsNV::default(),
12098 handle: unsafe { ::std::mem::zeroed() },
12099 }
12100 }
12101}
12102impl ImportMemoryWin32HandleInfoNV {
12103 pub fn builder<'a>() -> ImportMemoryWin32HandleInfoNVBuilder<'a> {
12104 ImportMemoryWin32HandleInfoNVBuilder {
12105 inner: Self::default(),
12106 marker: ::std::marker::PhantomData,
12107 }
12108 }
12109}
12110#[repr(transparent)]
12111pub struct ImportMemoryWin32HandleInfoNVBuilder<'a> {
12112 inner: ImportMemoryWin32HandleInfoNV,
12113 marker: ::std::marker::PhantomData<&'a ()>,
12114}
12115unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoNVBuilder<'_> {}
12116unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoNV {}
12117impl<'a> ::std::ops::Deref for ImportMemoryWin32HandleInfoNVBuilder<'a> {
12118 type Target = ImportMemoryWin32HandleInfoNV;
12119 fn deref(&self) -> &Self::Target {
12120 &self.inner
12121 }
12122}
12123impl<'a> ::std::ops::DerefMut for ImportMemoryWin32HandleInfoNVBuilder<'a> {
12124 fn deref_mut(&mut self) -> &mut Self::Target {
12125 &mut self.inner
12126 }
12127}
12128impl<'a> ImportMemoryWin32HandleInfoNVBuilder<'a> {
12129 pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlagsNV) -> Self {
12130 self.inner.handle_type = handle_type;
12131 self
12132 }
12133 pub fn handle(mut self, handle: HANDLE) -> Self {
12134 self.inner.handle = handle;
12135 self
12136 }
12137 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12138 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12139 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12140 pub fn build(self) -> ImportMemoryWin32HandleInfoNV {
12141 self.inner
12142 }
12143}
12144#[repr(C)]
12145#[cfg_attr(feature = "debug", derive(Debug))]
12146#[derive(Copy, Clone)]
12147#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMemoryWin32HandleInfoNV.html>"]
12148pub struct ExportMemoryWin32HandleInfoNV {
12149 pub s_type: StructureType,
12150 pub p_next: *const c_void,
12151 pub p_attributes: *const SECURITY_ATTRIBUTES,
12152 pub dw_access: DWORD,
12153}
12154impl ::std::default::Default for ExportMemoryWin32HandleInfoNV {
12155 fn default() -> Self {
12156 Self {
12157 s_type: StructureType::EXPORT_MEMORY_WIN32_HANDLE_INFO_NV,
12158 p_next: ::std::ptr::null(),
12159 p_attributes: ::std::ptr::null(),
12160 dw_access: DWORD::default(),
12161 }
12162 }
12163}
12164impl ExportMemoryWin32HandleInfoNV {
12165 pub fn builder<'a>() -> ExportMemoryWin32HandleInfoNVBuilder<'a> {
12166 ExportMemoryWin32HandleInfoNVBuilder {
12167 inner: Self::default(),
12168 marker: ::std::marker::PhantomData,
12169 }
12170 }
12171}
12172#[repr(transparent)]
12173pub struct ExportMemoryWin32HandleInfoNVBuilder<'a> {
12174 inner: ExportMemoryWin32HandleInfoNV,
12175 marker: ::std::marker::PhantomData<&'a ()>,
12176}
12177unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoNVBuilder<'_> {}
12178unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoNV {}
12179impl<'a> ::std::ops::Deref for ExportMemoryWin32HandleInfoNVBuilder<'a> {
12180 type Target = ExportMemoryWin32HandleInfoNV;
12181 fn deref(&self) -> &Self::Target {
12182 &self.inner
12183 }
12184}
12185impl<'a> ::std::ops::DerefMut for ExportMemoryWin32HandleInfoNVBuilder<'a> {
12186 fn deref_mut(&mut self) -> &mut Self::Target {
12187 &mut self.inner
12188 }
12189}
12190impl<'a> ExportMemoryWin32HandleInfoNVBuilder<'a> {
12191 pub fn attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self {
12192 self.inner.p_attributes = attributes;
12193 self
12194 }
12195 pub fn dw_access(mut self, dw_access: DWORD) -> Self {
12196 self.inner.dw_access = dw_access;
12197 self
12198 }
12199 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12200 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12201 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12202 pub fn build(self) -> ExportMemoryWin32HandleInfoNV {
12203 self.inner
12204 }
12205}
12206#[repr(C)]
12207#[cfg_attr(feature = "debug", derive(Debug))]
12208#[derive(Copy, Clone)]
12209#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWin32KeyedMutexAcquireReleaseInfoNV.html>"]
12210pub struct Win32KeyedMutexAcquireReleaseInfoNV {
12211 pub s_type: StructureType,
12212 pub p_next: *const c_void,
12213 pub acquire_count: u32,
12214 pub p_acquire_syncs: *const DeviceMemory,
12215 pub p_acquire_keys: *const u64,
12216 pub p_acquire_timeout_milliseconds: *const u32,
12217 pub release_count: u32,
12218 pub p_release_syncs: *const DeviceMemory,
12219 pub p_release_keys: *const u64,
12220}
12221impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoNV {
12222 fn default() -> Self {
12223 Self {
12224 s_type: StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV,
12225 p_next: ::std::ptr::null(),
12226 acquire_count: u32::default(),
12227 p_acquire_syncs: ::std::ptr::null(),
12228 p_acquire_keys: ::std::ptr::null(),
12229 p_acquire_timeout_milliseconds: ::std::ptr::null(),
12230 release_count: u32::default(),
12231 p_release_syncs: ::std::ptr::null(),
12232 p_release_keys: ::std::ptr::null(),
12233 }
12234 }
12235}
12236impl Win32KeyedMutexAcquireReleaseInfoNV {
12237 pub fn builder<'a>() -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
12238 Win32KeyedMutexAcquireReleaseInfoNVBuilder {
12239 inner: Self::default(),
12240 marker: ::std::marker::PhantomData,
12241 }
12242 }
12243}
12244#[repr(transparent)]
12245pub struct Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
12246 inner: Win32KeyedMutexAcquireReleaseInfoNV,
12247 marker: ::std::marker::PhantomData<&'a ()>,
12248}
12249unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'_> {}
12250unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoNV {}
12251unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'_> {}
12252unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoNV {}
12253impl<'a> ::std::ops::Deref for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
12254 type Target = Win32KeyedMutexAcquireReleaseInfoNV;
12255 fn deref(&self) -> &Self::Target {
12256 &self.inner
12257 }
12258}
12259impl<'a> ::std::ops::DerefMut for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
12260 fn deref_mut(&mut self) -> &mut Self::Target {
12261 &mut self.inner
12262 }
12263}
12264impl<'a> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
12265 pub fn acquire_syncs(mut self, acquire_syncs: &'a [DeviceMemory]) -> Self {
12266 self.inner.acquire_count = acquire_syncs.len() as _;
12267 self.inner.p_acquire_syncs = acquire_syncs.as_ptr();
12268 self
12269 }
12270 pub fn acquire_keys(mut self, acquire_keys: &'a [u64]) -> Self {
12271 self.inner.acquire_count = acquire_keys.len() as _;
12272 self.inner.p_acquire_keys = acquire_keys.as_ptr();
12273 self
12274 }
12275 pub fn acquire_timeout_milliseconds(mut self, acquire_timeout_milliseconds: &'a [u32]) -> Self {
12276 self.inner.acquire_count = acquire_timeout_milliseconds.len() as _;
12277 self.inner.p_acquire_timeout_milliseconds = acquire_timeout_milliseconds.as_ptr();
12278 self
12279 }
12280 pub fn release_syncs(mut self, release_syncs: &'a [DeviceMemory]) -> Self {
12281 self.inner.release_count = release_syncs.len() as _;
12282 self.inner.p_release_syncs = release_syncs.as_ptr();
12283 self
12284 }
12285 pub fn release_keys(mut self, release_keys: &'a [u64]) -> Self {
12286 self.inner.release_count = release_keys.len() as _;
12287 self.inner.p_release_keys = release_keys.as_ptr();
12288 self
12289 }
12290 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12291 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12292 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12293 pub fn build(self) -> Win32KeyedMutexAcquireReleaseInfoNV {
12294 self.inner
12295 }
12296}
12297#[repr(C)]
12298#[cfg_attr(feature = "debug", derive(Debug))]
12299#[derive(Copy, Clone)]
12300#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV.html>"]
12301pub struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
12302 pub s_type: StructureType,
12303 pub p_next: *mut c_void,
12304 pub device_generated_commands: Bool32,
12305}
12306impl ::std::default::Default for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
12307 fn default() -> Self {
12308 Self {
12309 s_type: StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV,
12310 p_next: ::std::ptr::null_mut(),
12311 device_generated_commands: Bool32::default(),
12312 }
12313 }
12314}
12315impl PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
12316 pub fn builder<'a>() -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
12317 PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder {
12318 inner: Self::default(),
12319 marker: ::std::marker::PhantomData,
12320 }
12321 }
12322}
12323#[repr(transparent)]
12324pub struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
12325 inner: PhysicalDeviceDeviceGeneratedCommandsFeaturesNV,
12326 marker: ::std::marker::PhantomData<&'a ()>,
12327}
12328unsafe impl ExtendsPhysicalDeviceFeatures2
12329 for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'_>
12330{
12331}
12332unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {}
12333unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'_> {}
12334unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {}
12335impl<'a> ::std::ops::Deref for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
12336 type Target = PhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
12337 fn deref(&self) -> &Self::Target {
12338 &self.inner
12339 }
12340}
12341impl<'a> ::std::ops::DerefMut for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
12342 fn deref_mut(&mut self) -> &mut Self::Target {
12343 &mut self.inner
12344 }
12345}
12346impl<'a> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
12347 pub fn device_generated_commands(mut self, device_generated_commands: bool) -> Self {
12348 self.inner.device_generated_commands = device_generated_commands.into();
12349 self
12350 }
12351 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12352 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12353 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12354 pub fn build(self) -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
12355 self.inner
12356 }
12357}
12358#[repr(C)]
12359#[cfg_attr(feature = "debug", derive(Debug))]
12360#[derive(Copy, Clone)]
12361#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDevicePrivateDataCreateInfo.html>"]
12362pub struct DevicePrivateDataCreateInfo {
12363 pub s_type: StructureType,
12364 pub p_next: *const c_void,
12365 pub private_data_slot_request_count: u32,
12366}
12367impl ::std::default::Default for DevicePrivateDataCreateInfo {
12368 fn default() -> Self {
12369 Self {
12370 s_type: StructureType::DEVICE_PRIVATE_DATA_CREATE_INFO,
12371 p_next: ::std::ptr::null(),
12372 private_data_slot_request_count: u32::default(),
12373 }
12374 }
12375}
12376impl DevicePrivateDataCreateInfo {
12377 pub fn builder<'a>() -> DevicePrivateDataCreateInfoBuilder<'a> {
12378 DevicePrivateDataCreateInfoBuilder {
12379 inner: Self::default(),
12380 marker: ::std::marker::PhantomData,
12381 }
12382 }
12383}
12384#[repr(transparent)]
12385pub struct DevicePrivateDataCreateInfoBuilder<'a> {
12386 inner: DevicePrivateDataCreateInfo,
12387 marker: ::std::marker::PhantomData<&'a ()>,
12388}
12389unsafe impl ExtendsDeviceCreateInfo for DevicePrivateDataCreateInfoBuilder<'_> {}
12390unsafe impl ExtendsDeviceCreateInfo for DevicePrivateDataCreateInfo {}
12391impl<'a> ::std::ops::Deref for DevicePrivateDataCreateInfoBuilder<'a> {
12392 type Target = DevicePrivateDataCreateInfo;
12393 fn deref(&self) -> &Self::Target {
12394 &self.inner
12395 }
12396}
12397impl<'a> ::std::ops::DerefMut for DevicePrivateDataCreateInfoBuilder<'a> {
12398 fn deref_mut(&mut self) -> &mut Self::Target {
12399 &mut self.inner
12400 }
12401}
12402impl<'a> DevicePrivateDataCreateInfoBuilder<'a> {
12403 pub fn private_data_slot_request_count(mut self, private_data_slot_request_count: u32) -> Self {
12404 self.inner.private_data_slot_request_count = private_data_slot_request_count;
12405 self
12406 }
12407 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12408 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12409 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12410 pub fn build(self) -> DevicePrivateDataCreateInfo {
12411 self.inner
12412 }
12413}
12414#[repr(C)]
12415#[cfg_attr(feature = "debug", derive(Debug))]
12416#[derive(Copy, Clone)]
12417#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPrivateDataSlotCreateInfo.html>"]
12418pub struct PrivateDataSlotCreateInfo {
12419 pub s_type: StructureType,
12420 pub p_next: *const c_void,
12421 pub flags: PrivateDataSlotCreateFlags,
12422}
12423impl ::std::default::Default for PrivateDataSlotCreateInfo {
12424 fn default() -> Self {
12425 Self {
12426 s_type: StructureType::PRIVATE_DATA_SLOT_CREATE_INFO,
12427 p_next: ::std::ptr::null(),
12428 flags: PrivateDataSlotCreateFlags::default(),
12429 }
12430 }
12431}
12432impl PrivateDataSlotCreateInfo {
12433 pub fn builder<'a>() -> PrivateDataSlotCreateInfoBuilder<'a> {
12434 PrivateDataSlotCreateInfoBuilder {
12435 inner: Self::default(),
12436 marker: ::std::marker::PhantomData,
12437 }
12438 }
12439}
12440#[repr(transparent)]
12441pub struct PrivateDataSlotCreateInfoBuilder<'a> {
12442 inner: PrivateDataSlotCreateInfo,
12443 marker: ::std::marker::PhantomData<&'a ()>,
12444}
12445impl<'a> ::std::ops::Deref for PrivateDataSlotCreateInfoBuilder<'a> {
12446 type Target = PrivateDataSlotCreateInfo;
12447 fn deref(&self) -> &Self::Target {
12448 &self.inner
12449 }
12450}
12451impl<'a> ::std::ops::DerefMut for PrivateDataSlotCreateInfoBuilder<'a> {
12452 fn deref_mut(&mut self) -> &mut Self::Target {
12453 &mut self.inner
12454 }
12455}
12456impl<'a> PrivateDataSlotCreateInfoBuilder<'a> {
12457 pub fn flags(mut self, flags: PrivateDataSlotCreateFlags) -> Self {
12458 self.inner.flags = flags;
12459 self
12460 }
12461 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12462 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12463 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12464 pub fn build(self) -> PrivateDataSlotCreateInfo {
12465 self.inner
12466 }
12467}
12468#[repr(C)]
12469#[cfg_attr(feature = "debug", derive(Debug))]
12470#[derive(Copy, Clone)]
12471#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePrivateDataFeatures.html>"]
12472pub struct PhysicalDevicePrivateDataFeatures {
12473 pub s_type: StructureType,
12474 pub p_next: *mut c_void,
12475 pub private_data: Bool32,
12476}
12477impl ::std::default::Default for PhysicalDevicePrivateDataFeatures {
12478 fn default() -> Self {
12479 Self {
12480 s_type: StructureType::PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES,
12481 p_next: ::std::ptr::null_mut(),
12482 private_data: Bool32::default(),
12483 }
12484 }
12485}
12486impl PhysicalDevicePrivateDataFeatures {
12487 pub fn builder<'a>() -> PhysicalDevicePrivateDataFeaturesBuilder<'a> {
12488 PhysicalDevicePrivateDataFeaturesBuilder {
12489 inner: Self::default(),
12490 marker: ::std::marker::PhantomData,
12491 }
12492 }
12493}
12494#[repr(transparent)]
12495pub struct PhysicalDevicePrivateDataFeaturesBuilder<'a> {
12496 inner: PhysicalDevicePrivateDataFeatures,
12497 marker: ::std::marker::PhantomData<&'a ()>,
12498}
12499unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePrivateDataFeaturesBuilder<'_> {}
12500unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePrivateDataFeatures {}
12501unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrivateDataFeaturesBuilder<'_> {}
12502unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrivateDataFeatures {}
12503impl<'a> ::std::ops::Deref for PhysicalDevicePrivateDataFeaturesBuilder<'a> {
12504 type Target = PhysicalDevicePrivateDataFeatures;
12505 fn deref(&self) -> &Self::Target {
12506 &self.inner
12507 }
12508}
12509impl<'a> ::std::ops::DerefMut for PhysicalDevicePrivateDataFeaturesBuilder<'a> {
12510 fn deref_mut(&mut self) -> &mut Self::Target {
12511 &mut self.inner
12512 }
12513}
12514impl<'a> PhysicalDevicePrivateDataFeaturesBuilder<'a> {
12515 pub fn private_data(mut self, private_data: bool) -> Self {
12516 self.inner.private_data = private_data.into();
12517 self
12518 }
12519 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12520 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12521 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12522 pub fn build(self) -> PhysicalDevicePrivateDataFeatures {
12523 self.inner
12524 }
12525}
12526#[repr(C)]
12527#[cfg_attr(feature = "debug", derive(Debug))]
12528#[derive(Copy, Clone)]
12529#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV.html>"]
12530pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
12531 pub s_type: StructureType,
12532 pub p_next: *mut c_void,
12533 pub max_graphics_shader_group_count: u32,
12534 pub max_indirect_sequence_count: u32,
12535 pub max_indirect_commands_token_count: u32,
12536 pub max_indirect_commands_stream_count: u32,
12537 pub max_indirect_commands_token_offset: u32,
12538 pub max_indirect_commands_stream_stride: u32,
12539 pub min_sequences_count_buffer_offset_alignment: u32,
12540 pub min_sequences_index_buffer_offset_alignment: u32,
12541 pub min_indirect_commands_buffer_offset_alignment: u32,
12542}
12543impl ::std::default::Default for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
12544 fn default() -> Self {
12545 Self {
12546 s_type: StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV,
12547 p_next: ::std::ptr::null_mut(),
12548 max_graphics_shader_group_count: u32::default(),
12549 max_indirect_sequence_count: u32::default(),
12550 max_indirect_commands_token_count: u32::default(),
12551 max_indirect_commands_stream_count: u32::default(),
12552 max_indirect_commands_token_offset: u32::default(),
12553 max_indirect_commands_stream_stride: u32::default(),
12554 min_sequences_count_buffer_offset_alignment: u32::default(),
12555 min_sequences_index_buffer_offset_alignment: u32::default(),
12556 min_indirect_commands_buffer_offset_alignment: u32::default(),
12557 }
12558 }
12559}
12560impl PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
12561 pub fn builder<'a>() -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
12562 PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder {
12563 inner: Self::default(),
12564 marker: ::std::marker::PhantomData,
12565 }
12566 }
12567}
12568#[repr(transparent)]
12569pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
12570 inner: PhysicalDeviceDeviceGeneratedCommandsPropertiesNV,
12571 marker: ::std::marker::PhantomData<&'a ()>,
12572}
12573unsafe impl ExtendsPhysicalDeviceProperties2
12574 for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'_>
12575{
12576}
12577unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {}
12578impl<'a> ::std::ops::Deref for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
12579 type Target = PhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
12580 fn deref(&self) -> &Self::Target {
12581 &self.inner
12582 }
12583}
12584impl<'a> ::std::ops::DerefMut for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
12585 fn deref_mut(&mut self) -> &mut Self::Target {
12586 &mut self.inner
12587 }
12588}
12589impl<'a> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
12590 pub fn max_graphics_shader_group_count(mut self, max_graphics_shader_group_count: u32) -> Self {
12591 self.inner.max_graphics_shader_group_count = max_graphics_shader_group_count;
12592 self
12593 }
12594 pub fn max_indirect_sequence_count(mut self, max_indirect_sequence_count: u32) -> Self {
12595 self.inner.max_indirect_sequence_count = max_indirect_sequence_count;
12596 self
12597 }
12598 pub fn max_indirect_commands_token_count(
12599 mut self,
12600 max_indirect_commands_token_count: u32,
12601 ) -> Self {
12602 self.inner.max_indirect_commands_token_count = max_indirect_commands_token_count;
12603 self
12604 }
12605 pub fn max_indirect_commands_stream_count(
12606 mut self,
12607 max_indirect_commands_stream_count: u32,
12608 ) -> Self {
12609 self.inner.max_indirect_commands_stream_count = max_indirect_commands_stream_count;
12610 self
12611 }
12612 pub fn max_indirect_commands_token_offset(
12613 mut self,
12614 max_indirect_commands_token_offset: u32,
12615 ) -> Self {
12616 self.inner.max_indirect_commands_token_offset = max_indirect_commands_token_offset;
12617 self
12618 }
12619 pub fn max_indirect_commands_stream_stride(
12620 mut self,
12621 max_indirect_commands_stream_stride: u32,
12622 ) -> Self {
12623 self.inner.max_indirect_commands_stream_stride = max_indirect_commands_stream_stride;
12624 self
12625 }
12626 pub fn min_sequences_count_buffer_offset_alignment(
12627 mut self,
12628 min_sequences_count_buffer_offset_alignment: u32,
12629 ) -> Self {
12630 self.inner.min_sequences_count_buffer_offset_alignment =
12631 min_sequences_count_buffer_offset_alignment;
12632 self
12633 }
12634 pub fn min_sequences_index_buffer_offset_alignment(
12635 mut self,
12636 min_sequences_index_buffer_offset_alignment: u32,
12637 ) -> Self {
12638 self.inner.min_sequences_index_buffer_offset_alignment =
12639 min_sequences_index_buffer_offset_alignment;
12640 self
12641 }
12642 pub fn min_indirect_commands_buffer_offset_alignment(
12643 mut self,
12644 min_indirect_commands_buffer_offset_alignment: u32,
12645 ) -> Self {
12646 self.inner.min_indirect_commands_buffer_offset_alignment =
12647 min_indirect_commands_buffer_offset_alignment;
12648 self
12649 }
12650 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12651 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12652 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12653 pub fn build(self) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
12654 self.inner
12655 }
12656}
12657#[repr(C)]
12658#[cfg_attr(feature = "debug", derive(Debug))]
12659#[derive(Copy, Clone)]
12660#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiDrawPropertiesEXT.html>"]
12661pub struct PhysicalDeviceMultiDrawPropertiesEXT {
12662 pub s_type: StructureType,
12663 pub p_next: *mut c_void,
12664 pub max_multi_draw_count: u32,
12665}
12666impl ::std::default::Default for PhysicalDeviceMultiDrawPropertiesEXT {
12667 fn default() -> Self {
12668 Self {
12669 s_type: StructureType::PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT,
12670 p_next: ::std::ptr::null_mut(),
12671 max_multi_draw_count: u32::default(),
12672 }
12673 }
12674}
12675impl PhysicalDeviceMultiDrawPropertiesEXT {
12676 pub fn builder<'a>() -> PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> {
12677 PhysicalDeviceMultiDrawPropertiesEXTBuilder {
12678 inner: Self::default(),
12679 marker: ::std::marker::PhantomData,
12680 }
12681 }
12682}
12683#[repr(transparent)]
12684pub struct PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> {
12685 inner: PhysicalDeviceMultiDrawPropertiesEXT,
12686 marker: ::std::marker::PhantomData<&'a ()>,
12687}
12688unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiDrawPropertiesEXTBuilder<'_> {}
12689unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiDrawPropertiesEXT {}
12690impl<'a> ::std::ops::Deref for PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> {
12691 type Target = PhysicalDeviceMultiDrawPropertiesEXT;
12692 fn deref(&self) -> &Self::Target {
12693 &self.inner
12694 }
12695}
12696impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> {
12697 fn deref_mut(&mut self) -> &mut Self::Target {
12698 &mut self.inner
12699 }
12700}
12701impl<'a> PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> {
12702 pub fn max_multi_draw_count(mut self, max_multi_draw_count: u32) -> Self {
12703 self.inner.max_multi_draw_count = max_multi_draw_count;
12704 self
12705 }
12706 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12707 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12708 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12709 pub fn build(self) -> PhysicalDeviceMultiDrawPropertiesEXT {
12710 self.inner
12711 }
12712}
12713#[repr(C)]
12714#[cfg_attr(feature = "debug", derive(Debug))]
12715#[derive(Copy, Clone)]
12716#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGraphicsShaderGroupCreateInfoNV.html>"]
12717pub struct GraphicsShaderGroupCreateInfoNV {
12718 pub s_type: StructureType,
12719 pub p_next: *const c_void,
12720 pub stage_count: u32,
12721 pub p_stages: *const PipelineShaderStageCreateInfo,
12722 pub p_vertex_input_state: *const PipelineVertexInputStateCreateInfo,
12723 pub p_tessellation_state: *const PipelineTessellationStateCreateInfo,
12724}
12725impl ::std::default::Default for GraphicsShaderGroupCreateInfoNV {
12726 fn default() -> Self {
12727 Self {
12728 s_type: StructureType::GRAPHICS_SHADER_GROUP_CREATE_INFO_NV,
12729 p_next: ::std::ptr::null(),
12730 stage_count: u32::default(),
12731 p_stages: ::std::ptr::null(),
12732 p_vertex_input_state: ::std::ptr::null(),
12733 p_tessellation_state: ::std::ptr::null(),
12734 }
12735 }
12736}
12737impl GraphicsShaderGroupCreateInfoNV {
12738 pub fn builder<'a>() -> GraphicsShaderGroupCreateInfoNVBuilder<'a> {
12739 GraphicsShaderGroupCreateInfoNVBuilder {
12740 inner: Self::default(),
12741 marker: ::std::marker::PhantomData,
12742 }
12743 }
12744}
12745#[repr(transparent)]
12746pub struct GraphicsShaderGroupCreateInfoNVBuilder<'a> {
12747 inner: GraphicsShaderGroupCreateInfoNV,
12748 marker: ::std::marker::PhantomData<&'a ()>,
12749}
12750impl<'a> ::std::ops::Deref for GraphicsShaderGroupCreateInfoNVBuilder<'a> {
12751 type Target = GraphicsShaderGroupCreateInfoNV;
12752 fn deref(&self) -> &Self::Target {
12753 &self.inner
12754 }
12755}
12756impl<'a> ::std::ops::DerefMut for GraphicsShaderGroupCreateInfoNVBuilder<'a> {
12757 fn deref_mut(&mut self) -> &mut Self::Target {
12758 &mut self.inner
12759 }
12760}
12761impl<'a> GraphicsShaderGroupCreateInfoNVBuilder<'a> {
12762 pub fn stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self {
12763 self.inner.stage_count = stages.len() as _;
12764 self.inner.p_stages = stages.as_ptr();
12765 self
12766 }
12767 pub fn vertex_input_state(
12768 mut self,
12769 vertex_input_state: &'a PipelineVertexInputStateCreateInfo,
12770 ) -> Self {
12771 self.inner.p_vertex_input_state = vertex_input_state;
12772 self
12773 }
12774 pub fn tessellation_state(
12775 mut self,
12776 tessellation_state: &'a PipelineTessellationStateCreateInfo,
12777 ) -> Self {
12778 self.inner.p_tessellation_state = tessellation_state;
12779 self
12780 }
12781 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12782 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12783 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12784 pub fn build(self) -> GraphicsShaderGroupCreateInfoNV {
12785 self.inner
12786 }
12787}
12788#[repr(C)]
12789#[cfg_attr(feature = "debug", derive(Debug))]
12790#[derive(Copy, Clone)]
12791#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGraphicsPipelineShaderGroupsCreateInfoNV.html>"]
12792pub struct GraphicsPipelineShaderGroupsCreateInfoNV {
12793 pub s_type: StructureType,
12794 pub p_next: *const c_void,
12795 pub group_count: u32,
12796 pub p_groups: *const GraphicsShaderGroupCreateInfoNV,
12797 pub pipeline_count: u32,
12798 pub p_pipelines: *const Pipeline,
12799}
12800impl ::std::default::Default for GraphicsPipelineShaderGroupsCreateInfoNV {
12801 fn default() -> Self {
12802 Self {
12803 s_type: StructureType::GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV,
12804 p_next: ::std::ptr::null(),
12805 group_count: u32::default(),
12806 p_groups: ::std::ptr::null(),
12807 pipeline_count: u32::default(),
12808 p_pipelines: ::std::ptr::null(),
12809 }
12810 }
12811}
12812impl GraphicsPipelineShaderGroupsCreateInfoNV {
12813 pub fn builder<'a>() -> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
12814 GraphicsPipelineShaderGroupsCreateInfoNVBuilder {
12815 inner: Self::default(),
12816 marker: ::std::marker::PhantomData,
12817 }
12818 }
12819}
12820#[repr(transparent)]
12821pub struct GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
12822 inner: GraphicsPipelineShaderGroupsCreateInfoNV,
12823 marker: ::std::marker::PhantomData<&'a ()>,
12824}
12825unsafe impl ExtendsGraphicsPipelineCreateInfo
12826 for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'_>
12827{
12828}
12829unsafe impl ExtendsGraphicsPipelineCreateInfo for GraphicsPipelineShaderGroupsCreateInfoNV {}
12830impl<'a> ::std::ops::Deref for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
12831 type Target = GraphicsPipelineShaderGroupsCreateInfoNV;
12832 fn deref(&self) -> &Self::Target {
12833 &self.inner
12834 }
12835}
12836impl<'a> ::std::ops::DerefMut for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
12837 fn deref_mut(&mut self) -> &mut Self::Target {
12838 &mut self.inner
12839 }
12840}
12841impl<'a> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
12842 pub fn groups(mut self, groups: &'a [GraphicsShaderGroupCreateInfoNV]) -> Self {
12843 self.inner.group_count = groups.len() as _;
12844 self.inner.p_groups = groups.as_ptr();
12845 self
12846 }
12847 pub fn pipelines(mut self, pipelines: &'a [Pipeline]) -> Self {
12848 self.inner.pipeline_count = pipelines.len() as _;
12849 self.inner.p_pipelines = pipelines.as_ptr();
12850 self
12851 }
12852 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12853 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12854 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12855 pub fn build(self) -> GraphicsPipelineShaderGroupsCreateInfoNV {
12856 self.inner
12857 }
12858}
12859#[repr(C)]
12860#[cfg_attr(feature = "debug", derive(Debug))]
12861#[derive(Copy, Clone, Default)]
12862#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindShaderGroupIndirectCommandNV.html>"]
12863pub struct BindShaderGroupIndirectCommandNV {
12864 pub group_index: u32,
12865}
12866impl BindShaderGroupIndirectCommandNV {
12867 pub fn builder<'a>() -> BindShaderGroupIndirectCommandNVBuilder<'a> {
12868 BindShaderGroupIndirectCommandNVBuilder {
12869 inner: Self::default(),
12870 marker: ::std::marker::PhantomData,
12871 }
12872 }
12873}
12874#[repr(transparent)]
12875pub struct BindShaderGroupIndirectCommandNVBuilder<'a> {
12876 inner: BindShaderGroupIndirectCommandNV,
12877 marker: ::std::marker::PhantomData<&'a ()>,
12878}
12879impl<'a> ::std::ops::Deref for BindShaderGroupIndirectCommandNVBuilder<'a> {
12880 type Target = BindShaderGroupIndirectCommandNV;
12881 fn deref(&self) -> &Self::Target {
12882 &self.inner
12883 }
12884}
12885impl<'a> ::std::ops::DerefMut for BindShaderGroupIndirectCommandNVBuilder<'a> {
12886 fn deref_mut(&mut self) -> &mut Self::Target {
12887 &mut self.inner
12888 }
12889}
12890impl<'a> BindShaderGroupIndirectCommandNVBuilder<'a> {
12891 pub fn group_index(mut self, group_index: u32) -> Self {
12892 self.inner.group_index = group_index;
12893 self
12894 }
12895 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12896 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12897 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12898 pub fn build(self) -> BindShaderGroupIndirectCommandNV {
12899 self.inner
12900 }
12901}
12902#[repr(C)]
12903#[cfg_attr(feature = "debug", derive(Debug))]
12904#[derive(Copy, Clone, Default)]
12905#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindIndexBufferIndirectCommandNV.html>"]
12906pub struct BindIndexBufferIndirectCommandNV {
12907 pub buffer_address: DeviceAddress,
12908 pub size: u32,
12909 pub index_type: IndexType,
12910}
12911impl BindIndexBufferIndirectCommandNV {
12912 pub fn builder<'a>() -> BindIndexBufferIndirectCommandNVBuilder<'a> {
12913 BindIndexBufferIndirectCommandNVBuilder {
12914 inner: Self::default(),
12915 marker: ::std::marker::PhantomData,
12916 }
12917 }
12918}
12919#[repr(transparent)]
12920pub struct BindIndexBufferIndirectCommandNVBuilder<'a> {
12921 inner: BindIndexBufferIndirectCommandNV,
12922 marker: ::std::marker::PhantomData<&'a ()>,
12923}
12924impl<'a> ::std::ops::Deref for BindIndexBufferIndirectCommandNVBuilder<'a> {
12925 type Target = BindIndexBufferIndirectCommandNV;
12926 fn deref(&self) -> &Self::Target {
12927 &self.inner
12928 }
12929}
12930impl<'a> ::std::ops::DerefMut for BindIndexBufferIndirectCommandNVBuilder<'a> {
12931 fn deref_mut(&mut self) -> &mut Self::Target {
12932 &mut self.inner
12933 }
12934}
12935impl<'a> BindIndexBufferIndirectCommandNVBuilder<'a> {
12936 pub fn buffer_address(mut self, buffer_address: DeviceAddress) -> Self {
12937 self.inner.buffer_address = buffer_address;
12938 self
12939 }
12940 pub fn size(mut self, size: u32) -> Self {
12941 self.inner.size = size;
12942 self
12943 }
12944 pub fn index_type(mut self, index_type: IndexType) -> Self {
12945 self.inner.index_type = index_type;
12946 self
12947 }
12948 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12949 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12950 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12951 pub fn build(self) -> BindIndexBufferIndirectCommandNV {
12952 self.inner
12953 }
12954}
12955#[repr(C)]
12956#[cfg_attr(feature = "debug", derive(Debug))]
12957#[derive(Copy, Clone, Default)]
12958#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindVertexBufferIndirectCommandNV.html>"]
12959pub struct BindVertexBufferIndirectCommandNV {
12960 pub buffer_address: DeviceAddress,
12961 pub size: u32,
12962 pub stride: u32,
12963}
12964impl BindVertexBufferIndirectCommandNV {
12965 pub fn builder<'a>() -> BindVertexBufferIndirectCommandNVBuilder<'a> {
12966 BindVertexBufferIndirectCommandNVBuilder {
12967 inner: Self::default(),
12968 marker: ::std::marker::PhantomData,
12969 }
12970 }
12971}
12972#[repr(transparent)]
12973pub struct BindVertexBufferIndirectCommandNVBuilder<'a> {
12974 inner: BindVertexBufferIndirectCommandNV,
12975 marker: ::std::marker::PhantomData<&'a ()>,
12976}
12977impl<'a> ::std::ops::Deref for BindVertexBufferIndirectCommandNVBuilder<'a> {
12978 type Target = BindVertexBufferIndirectCommandNV;
12979 fn deref(&self) -> &Self::Target {
12980 &self.inner
12981 }
12982}
12983impl<'a> ::std::ops::DerefMut for BindVertexBufferIndirectCommandNVBuilder<'a> {
12984 fn deref_mut(&mut self) -> &mut Self::Target {
12985 &mut self.inner
12986 }
12987}
12988impl<'a> BindVertexBufferIndirectCommandNVBuilder<'a> {
12989 pub fn buffer_address(mut self, buffer_address: DeviceAddress) -> Self {
12990 self.inner.buffer_address = buffer_address;
12991 self
12992 }
12993 pub fn size(mut self, size: u32) -> Self {
12994 self.inner.size = size;
12995 self
12996 }
12997 pub fn stride(mut self, stride: u32) -> Self {
12998 self.inner.stride = stride;
12999 self
13000 }
13001 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13002 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13003 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
13004 pub fn build(self) -> BindVertexBufferIndirectCommandNV {
13005 self.inner
13006 }
13007}
13008#[repr(C)]
13009#[cfg_attr(feature = "debug", derive(Debug))]
13010#[derive(Copy, Clone, Default)]
13011#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSetStateFlagsIndirectCommandNV.html>"]
13012pub struct SetStateFlagsIndirectCommandNV {
13013 pub data: u32,
13014}
13015impl SetStateFlagsIndirectCommandNV {
13016 pub fn builder<'a>() -> SetStateFlagsIndirectCommandNVBuilder<'a> {
13017 SetStateFlagsIndirectCommandNVBuilder {
13018 inner: Self::default(),
13019 marker: ::std::marker::PhantomData,
13020 }
13021 }
13022}
13023#[repr(transparent)]
13024pub struct SetStateFlagsIndirectCommandNVBuilder<'a> {
13025 inner: SetStateFlagsIndirectCommandNV,
13026 marker: ::std::marker::PhantomData<&'a ()>,
13027}
13028impl<'a> ::std::ops::Deref for SetStateFlagsIndirectCommandNVBuilder<'a> {
13029 type Target = SetStateFlagsIndirectCommandNV;
13030 fn deref(&self) -> &Self::Target {
13031 &self.inner
13032 }
13033}
13034impl<'a> ::std::ops::DerefMut for SetStateFlagsIndirectCommandNVBuilder<'a> {
13035 fn deref_mut(&mut self) -> &mut Self::Target {
13036 &mut self.inner
13037 }
13038}
13039impl<'a> SetStateFlagsIndirectCommandNVBuilder<'a> {
13040 pub fn data(mut self, data: u32) -> Self {
13041 self.inner.data = data;
13042 self
13043 }
13044 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13045 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13046 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
13047 pub fn build(self) -> SetStateFlagsIndirectCommandNV {
13048 self.inner
13049 }
13050}
13051#[repr(C)]
13052#[cfg_attr(feature = "debug", derive(Debug))]
13053#[derive(Copy, Clone, Default)]
13054#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIndirectCommandsStreamNV.html>"]
13055pub struct IndirectCommandsStreamNV {
13056 pub buffer: Buffer,
13057 pub offset: DeviceSize,
13058}
13059impl IndirectCommandsStreamNV {
13060 pub fn builder<'a>() -> IndirectCommandsStreamNVBuilder<'a> {
13061 IndirectCommandsStreamNVBuilder {
13062 inner: Self::default(),
13063 marker: ::std::marker::PhantomData,
13064 }
13065 }
13066}
13067#[repr(transparent)]
13068pub struct IndirectCommandsStreamNVBuilder<'a> {
13069 inner: IndirectCommandsStreamNV,
13070 marker: ::std::marker::PhantomData<&'a ()>,
13071}
13072impl<'a> ::std::ops::Deref for IndirectCommandsStreamNVBuilder<'a> {
13073 type Target = IndirectCommandsStreamNV;
13074 fn deref(&self) -> &Self::Target {
13075 &self.inner
13076 }
13077}
13078impl<'a> ::std::ops::DerefMut for IndirectCommandsStreamNVBuilder<'a> {
13079 fn deref_mut(&mut self) -> &mut Self::Target {
13080 &mut self.inner
13081 }
13082}
13083impl<'a> IndirectCommandsStreamNVBuilder<'a> {
13084 pub fn buffer(mut self, buffer: Buffer) -> Self {
13085 self.inner.buffer = buffer;
13086 self
13087 }
13088 pub fn offset(mut self, offset: DeviceSize) -> Self {
13089 self.inner.offset = offset;
13090 self
13091 }
13092 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13093 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13094 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
13095 pub fn build(self) -> IndirectCommandsStreamNV {
13096 self.inner
13097 }
13098}
13099#[repr(C)]
13100#[cfg_attr(feature = "debug", derive(Debug))]
13101#[derive(Copy, Clone)]
13102#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIndirectCommandsLayoutTokenNV.html>"]
13103pub struct IndirectCommandsLayoutTokenNV {
13104 pub s_type: StructureType,
13105 pub p_next: *const c_void,
13106 pub token_type: IndirectCommandsTokenTypeNV,
13107 pub stream: u32,
13108 pub offset: u32,
13109 pub vertex_binding_unit: u32,
13110 pub vertex_dynamic_stride: Bool32,
13111 pub pushconstant_pipeline_layout: PipelineLayout,
13112 pub pushconstant_shader_stage_flags: ShaderStageFlags,
13113 pub pushconstant_offset: u32,
13114 pub pushconstant_size: u32,
13115 pub indirect_state_flags: IndirectStateFlagsNV,
13116 pub index_type_count: u32,
13117 pub p_index_types: *const IndexType,
13118 pub p_index_type_values: *const u32,
13119}
13120impl ::std::default::Default for IndirectCommandsLayoutTokenNV {
13121 fn default() -> Self {
13122 Self {
13123 s_type: StructureType::INDIRECT_COMMANDS_LAYOUT_TOKEN_NV,
13124 p_next: ::std::ptr::null(),
13125 token_type: IndirectCommandsTokenTypeNV::default(),
13126 stream: u32::default(),
13127 offset: u32::default(),
13128 vertex_binding_unit: u32::default(),
13129 vertex_dynamic_stride: Bool32::default(),
13130 pushconstant_pipeline_layout: PipelineLayout::default(),
13131 pushconstant_shader_stage_flags: ShaderStageFlags::default(),
13132 pushconstant_offset: u32::default(),
13133 pushconstant_size: u32::default(),
13134 indirect_state_flags: IndirectStateFlagsNV::default(),
13135 index_type_count: u32::default(),
13136 p_index_types: ::std::ptr::null(),
13137 p_index_type_values: ::std::ptr::null(),
13138 }
13139 }
13140}
13141impl IndirectCommandsLayoutTokenNV {
13142 pub fn builder<'a>() -> IndirectCommandsLayoutTokenNVBuilder<'a> {
13143 IndirectCommandsLayoutTokenNVBuilder {
13144 inner: Self::default(),
13145 marker: ::std::marker::PhantomData,
13146 }
13147 }
13148}
13149#[repr(transparent)]
13150pub struct IndirectCommandsLayoutTokenNVBuilder<'a> {
13151 inner: IndirectCommandsLayoutTokenNV,
13152 marker: ::std::marker::PhantomData<&'a ()>,
13153}
13154impl<'a> ::std::ops::Deref for IndirectCommandsLayoutTokenNVBuilder<'a> {
13155 type Target = IndirectCommandsLayoutTokenNV;
13156 fn deref(&self) -> &Self::Target {
13157 &self.inner
13158 }
13159}
13160impl<'a> ::std::ops::DerefMut for IndirectCommandsLayoutTokenNVBuilder<'a> {
13161 fn deref_mut(&mut self) -> &mut Self::Target {
13162 &mut self.inner
13163 }
13164}
13165impl<'a> IndirectCommandsLayoutTokenNVBuilder<'a> {
13166 pub fn token_type(mut self, token_type: IndirectCommandsTokenTypeNV) -> Self {
13167 self.inner.token_type = token_type;
13168 self
13169 }
13170 pub fn stream(mut self, stream: u32) -> Self {
13171 self.inner.stream = stream;
13172 self
13173 }
13174 pub fn offset(mut self, offset: u32) -> Self {
13175 self.inner.offset = offset;
13176 self
13177 }
13178 pub fn vertex_binding_unit(mut self, vertex_binding_unit: u32) -> Self {
13179 self.inner.vertex_binding_unit = vertex_binding_unit;
13180 self
13181 }
13182 pub fn vertex_dynamic_stride(mut self, vertex_dynamic_stride: bool) -> Self {
13183 self.inner.vertex_dynamic_stride = vertex_dynamic_stride.into();
13184 self
13185 }
13186 pub fn pushconstant_pipeline_layout(
13187 mut self,
13188 pushconstant_pipeline_layout: PipelineLayout,
13189 ) -> Self {
13190 self.inner.pushconstant_pipeline_layout = pushconstant_pipeline_layout;
13191 self
13192 }
13193 pub fn pushconstant_shader_stage_flags(
13194 mut self,
13195 pushconstant_shader_stage_flags: ShaderStageFlags,
13196 ) -> Self {
13197 self.inner.pushconstant_shader_stage_flags = pushconstant_shader_stage_flags;
13198 self
13199 }
13200 pub fn pushconstant_offset(mut self, pushconstant_offset: u32) -> Self {
13201 self.inner.pushconstant_offset = pushconstant_offset;
13202 self
13203 }
13204 pub fn pushconstant_size(mut self, pushconstant_size: u32) -> Self {
13205 self.inner.pushconstant_size = pushconstant_size;
13206 self
13207 }
13208 pub fn indirect_state_flags(mut self, indirect_state_flags: IndirectStateFlagsNV) -> Self {
13209 self.inner.indirect_state_flags = indirect_state_flags;
13210 self
13211 }
13212 pub fn index_types(mut self, index_types: &'a [IndexType]) -> Self {
13213 self.inner.index_type_count = index_types.len() as _;
13214 self.inner.p_index_types = index_types.as_ptr();
13215 self
13216 }
13217 pub fn index_type_values(mut self, index_type_values: &'a [u32]) -> Self {
13218 self.inner.index_type_count = index_type_values.len() as _;
13219 self.inner.p_index_type_values = index_type_values.as_ptr();
13220 self
13221 }
13222 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13223 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13224 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
13225 pub fn build(self) -> IndirectCommandsLayoutTokenNV {
13226 self.inner
13227 }
13228}
13229#[repr(C)]
13230#[cfg_attr(feature = "debug", derive(Debug))]
13231#[derive(Copy, Clone)]
13232#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIndirectCommandsLayoutCreateInfoNV.html>"]
13233pub struct IndirectCommandsLayoutCreateInfoNV {
13234 pub s_type: StructureType,
13235 pub p_next: *const c_void,
13236 pub flags: IndirectCommandsLayoutUsageFlagsNV,
13237 pub pipeline_bind_point: PipelineBindPoint,
13238 pub token_count: u32,
13239 pub p_tokens: *const IndirectCommandsLayoutTokenNV,
13240 pub stream_count: u32,
13241 pub p_stream_strides: *const u32,
13242}
13243impl ::std::default::Default for IndirectCommandsLayoutCreateInfoNV {
13244 fn default() -> Self {
13245 Self {
13246 s_type: StructureType::INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV,
13247 p_next: ::std::ptr::null(),
13248 flags: IndirectCommandsLayoutUsageFlagsNV::default(),
13249 pipeline_bind_point: PipelineBindPoint::default(),
13250 token_count: u32::default(),
13251 p_tokens: ::std::ptr::null(),
13252 stream_count: u32::default(),
13253 p_stream_strides: ::std::ptr::null(),
13254 }
13255 }
13256}
13257impl IndirectCommandsLayoutCreateInfoNV {
13258 pub fn builder<'a>() -> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
13259 IndirectCommandsLayoutCreateInfoNVBuilder {
13260 inner: Self::default(),
13261 marker: ::std::marker::PhantomData,
13262 }
13263 }
13264}
13265#[repr(transparent)]
13266pub struct IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
13267 inner: IndirectCommandsLayoutCreateInfoNV,
13268 marker: ::std::marker::PhantomData<&'a ()>,
13269}
13270impl<'a> ::std::ops::Deref for IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
13271 type Target = IndirectCommandsLayoutCreateInfoNV;
13272 fn deref(&self) -> &Self::Target {
13273 &self.inner
13274 }
13275}
13276impl<'a> ::std::ops::DerefMut for IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
13277 fn deref_mut(&mut self) -> &mut Self::Target {
13278 &mut self.inner
13279 }
13280}
13281impl<'a> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
13282 pub fn flags(mut self, flags: IndirectCommandsLayoutUsageFlagsNV) -> Self {
13283 self.inner.flags = flags;
13284 self
13285 }
13286 pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self {
13287 self.inner.pipeline_bind_point = pipeline_bind_point;
13288 self
13289 }
13290 pub fn tokens(mut self, tokens: &'a [IndirectCommandsLayoutTokenNV]) -> Self {
13291 self.inner.token_count = tokens.len() as _;
13292 self.inner.p_tokens = tokens.as_ptr();
13293 self
13294 }
13295 pub fn stream_strides(mut self, stream_strides: &'a [u32]) -> Self {
13296 self.inner.stream_count = stream_strides.len() as _;
13297 self.inner.p_stream_strides = stream_strides.as_ptr();
13298 self
13299 }
13300 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13301 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13302 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
13303 pub fn build(self) -> IndirectCommandsLayoutCreateInfoNV {
13304 self.inner
13305 }
13306}
13307#[repr(C)]
13308#[cfg_attr(feature = "debug", derive(Debug))]
13309#[derive(Copy, Clone)]
13310#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeneratedCommandsInfoNV.html>"]
13311pub struct GeneratedCommandsInfoNV {
13312 pub s_type: StructureType,
13313 pub p_next: *const c_void,
13314 pub pipeline_bind_point: PipelineBindPoint,
13315 pub pipeline: Pipeline,
13316 pub indirect_commands_layout: IndirectCommandsLayoutNV,
13317 pub stream_count: u32,
13318 pub p_streams: *const IndirectCommandsStreamNV,
13319 pub sequences_count: u32,
13320 pub preprocess_buffer: Buffer,
13321 pub preprocess_offset: DeviceSize,
13322 pub preprocess_size: DeviceSize,
13323 pub sequences_count_buffer: Buffer,
13324 pub sequences_count_offset: DeviceSize,
13325 pub sequences_index_buffer: Buffer,
13326 pub sequences_index_offset: DeviceSize,
13327}
13328impl ::std::default::Default for GeneratedCommandsInfoNV {
13329 fn default() -> Self {
13330 Self {
13331 s_type: StructureType::GENERATED_COMMANDS_INFO_NV,
13332 p_next: ::std::ptr::null(),
13333 pipeline_bind_point: PipelineBindPoint::default(),
13334 pipeline: Pipeline::default(),
13335 indirect_commands_layout: IndirectCommandsLayoutNV::default(),
13336 stream_count: u32::default(),
13337 p_streams: ::std::ptr::null(),
13338 sequences_count: u32::default(),
13339 preprocess_buffer: Buffer::default(),
13340 preprocess_offset: DeviceSize::default(),
13341 preprocess_size: DeviceSize::default(),
13342 sequences_count_buffer: Buffer::default(),
13343 sequences_count_offset: DeviceSize::default(),
13344 sequences_index_buffer: Buffer::default(),
13345 sequences_index_offset: DeviceSize::default(),
13346 }
13347 }
13348}
13349impl GeneratedCommandsInfoNV {
13350 pub fn builder<'a>() -> GeneratedCommandsInfoNVBuilder<'a> {
13351 GeneratedCommandsInfoNVBuilder {
13352 inner: Self::default(),
13353 marker: ::std::marker::PhantomData,
13354 }
13355 }
13356}
13357#[repr(transparent)]
13358pub struct GeneratedCommandsInfoNVBuilder<'a> {
13359 inner: GeneratedCommandsInfoNV,
13360 marker: ::std::marker::PhantomData<&'a ()>,
13361}
13362impl<'a> ::std::ops::Deref for GeneratedCommandsInfoNVBuilder<'a> {
13363 type Target = GeneratedCommandsInfoNV;
13364 fn deref(&self) -> &Self::Target {
13365 &self.inner
13366 }
13367}
13368impl<'a> ::std::ops::DerefMut for GeneratedCommandsInfoNVBuilder<'a> {
13369 fn deref_mut(&mut self) -> &mut Self::Target {
13370 &mut self.inner
13371 }
13372}
13373impl<'a> GeneratedCommandsInfoNVBuilder<'a> {
13374 pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self {
13375 self.inner.pipeline_bind_point = pipeline_bind_point;
13376 self
13377 }
13378 pub fn pipeline(mut self, pipeline: Pipeline) -> Self {
13379 self.inner.pipeline = pipeline;
13380 self
13381 }
13382 pub fn indirect_commands_layout(
13383 mut self,
13384 indirect_commands_layout: IndirectCommandsLayoutNV,
13385 ) -> Self {
13386 self.inner.indirect_commands_layout = indirect_commands_layout;
13387 self
13388 }
13389 pub fn streams(mut self, streams: &'a [IndirectCommandsStreamNV]) -> Self {
13390 self.inner.stream_count = streams.len() as _;
13391 self.inner.p_streams = streams.as_ptr();
13392 self
13393 }
13394 pub fn sequences_count(mut self, sequences_count: u32) -> Self {
13395 self.inner.sequences_count = sequences_count;
13396 self
13397 }
13398 pub fn preprocess_buffer(mut self, preprocess_buffer: Buffer) -> Self {
13399 self.inner.preprocess_buffer = preprocess_buffer;
13400 self
13401 }
13402 pub fn preprocess_offset(mut self, preprocess_offset: DeviceSize) -> Self {
13403 self.inner.preprocess_offset = preprocess_offset;
13404 self
13405 }
13406 pub fn preprocess_size(mut self, preprocess_size: DeviceSize) -> Self {
13407 self.inner.preprocess_size = preprocess_size;
13408 self
13409 }
13410 pub fn sequences_count_buffer(mut self, sequences_count_buffer: Buffer) -> Self {
13411 self.inner.sequences_count_buffer = sequences_count_buffer;
13412 self
13413 }
13414 pub fn sequences_count_offset(mut self, sequences_count_offset: DeviceSize) -> Self {
13415 self.inner.sequences_count_offset = sequences_count_offset;
13416 self
13417 }
13418 pub fn sequences_index_buffer(mut self, sequences_index_buffer: Buffer) -> Self {
13419 self.inner.sequences_index_buffer = sequences_index_buffer;
13420 self
13421 }
13422 pub fn sequences_index_offset(mut self, sequences_index_offset: DeviceSize) -> Self {
13423 self.inner.sequences_index_offset = sequences_index_offset;
13424 self
13425 }
13426 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13427 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13428 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
13429 pub fn build(self) -> GeneratedCommandsInfoNV {
13430 self.inner
13431 }
13432}
13433#[repr(C)]
13434#[cfg_attr(feature = "debug", derive(Debug))]
13435#[derive(Copy, Clone)]
13436#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeneratedCommandsMemoryRequirementsInfoNV.html>"]
13437pub struct GeneratedCommandsMemoryRequirementsInfoNV {
13438 pub s_type: StructureType,
13439 pub p_next: *const c_void,
13440 pub pipeline_bind_point: PipelineBindPoint,
13441 pub pipeline: Pipeline,
13442 pub indirect_commands_layout: IndirectCommandsLayoutNV,
13443 pub max_sequences_count: u32,
13444}
13445impl ::std::default::Default for GeneratedCommandsMemoryRequirementsInfoNV {
13446 fn default() -> Self {
13447 Self {
13448 s_type: StructureType::GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV,
13449 p_next: ::std::ptr::null(),
13450 pipeline_bind_point: PipelineBindPoint::default(),
13451 pipeline: Pipeline::default(),
13452 indirect_commands_layout: IndirectCommandsLayoutNV::default(),
13453 max_sequences_count: u32::default(),
13454 }
13455 }
13456}
13457impl GeneratedCommandsMemoryRequirementsInfoNV {
13458 pub fn builder<'a>() -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
13459 GeneratedCommandsMemoryRequirementsInfoNVBuilder {
13460 inner: Self::default(),
13461 marker: ::std::marker::PhantomData,
13462 }
13463 }
13464}
13465#[repr(transparent)]
13466pub struct GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
13467 inner: GeneratedCommandsMemoryRequirementsInfoNV,
13468 marker: ::std::marker::PhantomData<&'a ()>,
13469}
13470impl<'a> ::std::ops::Deref for GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
13471 type Target = GeneratedCommandsMemoryRequirementsInfoNV;
13472 fn deref(&self) -> &Self::Target {
13473 &self.inner
13474 }
13475}
13476impl<'a> ::std::ops::DerefMut for GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
13477 fn deref_mut(&mut self) -> &mut Self::Target {
13478 &mut self.inner
13479 }
13480}
13481impl<'a> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
13482 pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self {
13483 self.inner.pipeline_bind_point = pipeline_bind_point;
13484 self
13485 }
13486 pub fn pipeline(mut self, pipeline: Pipeline) -> Self {
13487 self.inner.pipeline = pipeline;
13488 self
13489 }
13490 pub fn indirect_commands_layout(
13491 mut self,
13492 indirect_commands_layout: IndirectCommandsLayoutNV,
13493 ) -> Self {
13494 self.inner.indirect_commands_layout = indirect_commands_layout;
13495 self
13496 }
13497 pub fn max_sequences_count(mut self, max_sequences_count: u32) -> Self {
13498 self.inner.max_sequences_count = max_sequences_count;
13499 self
13500 }
13501 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13502 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13503 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
13504 pub fn build(self) -> GeneratedCommandsMemoryRequirementsInfoNV {
13505 self.inner
13506 }
13507}
13508#[repr(C)]
13509#[cfg_attr(feature = "debug", derive(Debug))]
13510#[derive(Copy, Clone)]
13511#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFeatures2.html>"]
13512pub struct PhysicalDeviceFeatures2 {
13513 pub s_type: StructureType,
13514 pub p_next: *mut c_void,
13515 pub features: PhysicalDeviceFeatures,
13516}
13517impl ::std::default::Default for PhysicalDeviceFeatures2 {
13518 fn default() -> Self {
13519 Self {
13520 s_type: StructureType::PHYSICAL_DEVICE_FEATURES_2,
13521 p_next: ::std::ptr::null_mut(),
13522 features: PhysicalDeviceFeatures::default(),
13523 }
13524 }
13525}
13526impl PhysicalDeviceFeatures2 {
13527 pub fn builder<'a>() -> PhysicalDeviceFeatures2Builder<'a> {
13528 PhysicalDeviceFeatures2Builder {
13529 inner: Self::default(),
13530 marker: ::std::marker::PhantomData,
13531 }
13532 }
13533}
13534#[repr(transparent)]
13535pub struct PhysicalDeviceFeatures2Builder<'a> {
13536 inner: PhysicalDeviceFeatures2,
13537 marker: ::std::marker::PhantomData<&'a ()>,
13538}
13539unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFeatures2Builder<'_> {}
13540unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFeatures2 {}
13541pub unsafe trait ExtendsPhysicalDeviceFeatures2 {}
13542impl<'a> ::std::ops::Deref for PhysicalDeviceFeatures2Builder<'a> {
13543 type Target = PhysicalDeviceFeatures2;
13544 fn deref(&self) -> &Self::Target {
13545 &self.inner
13546 }
13547}
13548impl<'a> ::std::ops::DerefMut for PhysicalDeviceFeatures2Builder<'a> {
13549 fn deref_mut(&mut self) -> &mut Self::Target {
13550 &mut self.inner
13551 }
13552}
13553impl<'a> PhysicalDeviceFeatures2Builder<'a> {
13554 pub fn features(mut self, features: PhysicalDeviceFeatures) -> Self {
13555 self.inner.features = features;
13556 self
13557 }
13558 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
13559 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
13560 #[doc = r" valid extension structs can be pushed into the chain."]
13561 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
13562 #[doc = r" chain will look like `A -> D -> B -> C`."]
13563 pub fn push_next<T: ExtendsPhysicalDeviceFeatures2>(mut self, next: &'a mut T) -> Self {
13564 unsafe {
13565 let next_ptr = <*mut T>::cast(next);
13566 let last_next = ptr_chain_iter(next).last().unwrap();
13567 (*last_next).p_next = self.inner.p_next as _;
13568 self.inner.p_next = next_ptr;
13569 }
13570 self
13571 }
13572 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13573 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13574 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
13575 pub fn build(self) -> PhysicalDeviceFeatures2 {
13576 self.inner
13577 }
13578}
13579#[repr(C)]
13580#[cfg_attr(feature = "debug", derive(Debug))]
13581#[derive(Copy, Clone)]
13582#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProperties2.html>"]
13583pub struct PhysicalDeviceProperties2 {
13584 pub s_type: StructureType,
13585 pub p_next: *mut c_void,
13586 pub properties: PhysicalDeviceProperties,
13587}
13588impl ::std::default::Default for PhysicalDeviceProperties2 {
13589 fn default() -> Self {
13590 Self {
13591 s_type: StructureType::PHYSICAL_DEVICE_PROPERTIES_2,
13592 p_next: ::std::ptr::null_mut(),
13593 properties: PhysicalDeviceProperties::default(),
13594 }
13595 }
13596}
13597impl PhysicalDeviceProperties2 {
13598 pub fn builder<'a>() -> PhysicalDeviceProperties2Builder<'a> {
13599 PhysicalDeviceProperties2Builder {
13600 inner: Self::default(),
13601 marker: ::std::marker::PhantomData,
13602 }
13603 }
13604}
13605#[repr(transparent)]
13606pub struct PhysicalDeviceProperties2Builder<'a> {
13607 inner: PhysicalDeviceProperties2,
13608 marker: ::std::marker::PhantomData<&'a ()>,
13609}
13610pub unsafe trait ExtendsPhysicalDeviceProperties2 {}
13611impl<'a> ::std::ops::Deref for PhysicalDeviceProperties2Builder<'a> {
13612 type Target = PhysicalDeviceProperties2;
13613 fn deref(&self) -> &Self::Target {
13614 &self.inner
13615 }
13616}
13617impl<'a> ::std::ops::DerefMut for PhysicalDeviceProperties2Builder<'a> {
13618 fn deref_mut(&mut self) -> &mut Self::Target {
13619 &mut self.inner
13620 }
13621}
13622impl<'a> PhysicalDeviceProperties2Builder<'a> {
13623 pub fn properties(mut self, properties: PhysicalDeviceProperties) -> Self {
13624 self.inner.properties = properties;
13625 self
13626 }
13627 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
13628 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
13629 #[doc = r" valid extension structs can be pushed into the chain."]
13630 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
13631 #[doc = r" chain will look like `A -> D -> B -> C`."]
13632 pub fn push_next<T: ExtendsPhysicalDeviceProperties2>(mut self, next: &'a mut T) -> Self {
13633 unsafe {
13634 let next_ptr = <*mut T>::cast(next);
13635 let last_next = ptr_chain_iter(next).last().unwrap();
13636 (*last_next).p_next = self.inner.p_next as _;
13637 self.inner.p_next = next_ptr;
13638 }
13639 self
13640 }
13641 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13642 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13643 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
13644 pub fn build(self) -> PhysicalDeviceProperties2 {
13645 self.inner
13646 }
13647}
13648#[repr(C)]
13649#[cfg_attr(feature = "debug", derive(Debug))]
13650#[derive(Copy, Clone)]
13651#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFormatProperties2.html>"]
13652pub struct FormatProperties2 {
13653 pub s_type: StructureType,
13654 pub p_next: *mut c_void,
13655 pub format_properties: FormatProperties,
13656}
13657impl ::std::default::Default for FormatProperties2 {
13658 fn default() -> Self {
13659 Self {
13660 s_type: StructureType::FORMAT_PROPERTIES_2,
13661 p_next: ::std::ptr::null_mut(),
13662 format_properties: FormatProperties::default(),
13663 }
13664 }
13665}
13666impl FormatProperties2 {
13667 pub fn builder<'a>() -> FormatProperties2Builder<'a> {
13668 FormatProperties2Builder {
13669 inner: Self::default(),
13670 marker: ::std::marker::PhantomData,
13671 }
13672 }
13673}
13674#[repr(transparent)]
13675pub struct FormatProperties2Builder<'a> {
13676 inner: FormatProperties2,
13677 marker: ::std::marker::PhantomData<&'a ()>,
13678}
13679pub unsafe trait ExtendsFormatProperties2 {}
13680impl<'a> ::std::ops::Deref for FormatProperties2Builder<'a> {
13681 type Target = FormatProperties2;
13682 fn deref(&self) -> &Self::Target {
13683 &self.inner
13684 }
13685}
13686impl<'a> ::std::ops::DerefMut for FormatProperties2Builder<'a> {
13687 fn deref_mut(&mut self) -> &mut Self::Target {
13688 &mut self.inner
13689 }
13690}
13691impl<'a> FormatProperties2Builder<'a> {
13692 pub fn format_properties(mut self, format_properties: FormatProperties) -> Self {
13693 self.inner.format_properties = format_properties;
13694 self
13695 }
13696 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
13697 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
13698 #[doc = r" valid extension structs can be pushed into the chain."]
13699 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
13700 #[doc = r" chain will look like `A -> D -> B -> C`."]
13701 pub fn push_next<T: ExtendsFormatProperties2>(mut self, next: &'a mut T) -> Self {
13702 unsafe {
13703 let next_ptr = <*mut T>::cast(next);
13704 let last_next = ptr_chain_iter(next).last().unwrap();
13705 (*last_next).p_next = self.inner.p_next as _;
13706 self.inner.p_next = next_ptr;
13707 }
13708 self
13709 }
13710 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13711 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13712 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
13713 pub fn build(self) -> FormatProperties2 {
13714 self.inner
13715 }
13716}
13717#[repr(C)]
13718#[cfg_attr(feature = "debug", derive(Debug))]
13719#[derive(Copy, Clone)]
13720#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageFormatProperties2.html>"]
13721pub struct ImageFormatProperties2 {
13722 pub s_type: StructureType,
13723 pub p_next: *mut c_void,
13724 pub image_format_properties: ImageFormatProperties,
13725}
13726impl ::std::default::Default for ImageFormatProperties2 {
13727 fn default() -> Self {
13728 Self {
13729 s_type: StructureType::IMAGE_FORMAT_PROPERTIES_2,
13730 p_next: ::std::ptr::null_mut(),
13731 image_format_properties: ImageFormatProperties::default(),
13732 }
13733 }
13734}
13735impl ImageFormatProperties2 {
13736 pub fn builder<'a>() -> ImageFormatProperties2Builder<'a> {
13737 ImageFormatProperties2Builder {
13738 inner: Self::default(),
13739 marker: ::std::marker::PhantomData,
13740 }
13741 }
13742}
13743#[repr(transparent)]
13744pub struct ImageFormatProperties2Builder<'a> {
13745 inner: ImageFormatProperties2,
13746 marker: ::std::marker::PhantomData<&'a ()>,
13747}
13748pub unsafe trait ExtendsImageFormatProperties2 {}
13749impl<'a> ::std::ops::Deref for ImageFormatProperties2Builder<'a> {
13750 type Target = ImageFormatProperties2;
13751 fn deref(&self) -> &Self::Target {
13752 &self.inner
13753 }
13754}
13755impl<'a> ::std::ops::DerefMut for ImageFormatProperties2Builder<'a> {
13756 fn deref_mut(&mut self) -> &mut Self::Target {
13757 &mut self.inner
13758 }
13759}
13760impl<'a> ImageFormatProperties2Builder<'a> {
13761 pub fn image_format_properties(
13762 mut self,
13763 image_format_properties: ImageFormatProperties,
13764 ) -> Self {
13765 self.inner.image_format_properties = image_format_properties;
13766 self
13767 }
13768 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
13769 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
13770 #[doc = r" valid extension structs can be pushed into the chain."]
13771 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
13772 #[doc = r" chain will look like `A -> D -> B -> C`."]
13773 pub fn push_next<T: ExtendsImageFormatProperties2>(mut self, next: &'a mut T) -> Self {
13774 unsafe {
13775 let next_ptr = <*mut T>::cast(next);
13776 let last_next = ptr_chain_iter(next).last().unwrap();
13777 (*last_next).p_next = self.inner.p_next as _;
13778 self.inner.p_next = next_ptr;
13779 }
13780 self
13781 }
13782 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13783 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13784 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
13785 pub fn build(self) -> ImageFormatProperties2 {
13786 self.inner
13787 }
13788}
13789#[repr(C)]
13790#[cfg_attr(feature = "debug", derive(Debug))]
13791#[derive(Copy, Clone)]
13792#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageFormatInfo2.html>"]
13793pub struct PhysicalDeviceImageFormatInfo2 {
13794 pub s_type: StructureType,
13795 pub p_next: *const c_void,
13796 pub format: Format,
13797 pub ty: ImageType,
13798 pub tiling: ImageTiling,
13799 pub usage: ImageUsageFlags,
13800 pub flags: ImageCreateFlags,
13801}
13802impl ::std::default::Default for PhysicalDeviceImageFormatInfo2 {
13803 fn default() -> Self {
13804 Self {
13805 s_type: StructureType::PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
13806 p_next: ::std::ptr::null(),
13807 format: Format::default(),
13808 ty: ImageType::default(),
13809 tiling: ImageTiling::default(),
13810 usage: ImageUsageFlags::default(),
13811 flags: ImageCreateFlags::default(),
13812 }
13813 }
13814}
13815impl PhysicalDeviceImageFormatInfo2 {
13816 pub fn builder<'a>() -> PhysicalDeviceImageFormatInfo2Builder<'a> {
13817 PhysicalDeviceImageFormatInfo2Builder {
13818 inner: Self::default(),
13819 marker: ::std::marker::PhantomData,
13820 }
13821 }
13822}
13823#[repr(transparent)]
13824pub struct PhysicalDeviceImageFormatInfo2Builder<'a> {
13825 inner: PhysicalDeviceImageFormatInfo2,
13826 marker: ::std::marker::PhantomData<&'a ()>,
13827}
13828pub unsafe trait ExtendsPhysicalDeviceImageFormatInfo2 {}
13829impl<'a> ::std::ops::Deref for PhysicalDeviceImageFormatInfo2Builder<'a> {
13830 type Target = PhysicalDeviceImageFormatInfo2;
13831 fn deref(&self) -> &Self::Target {
13832 &self.inner
13833 }
13834}
13835impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageFormatInfo2Builder<'a> {
13836 fn deref_mut(&mut self) -> &mut Self::Target {
13837 &mut self.inner
13838 }
13839}
13840impl<'a> PhysicalDeviceImageFormatInfo2Builder<'a> {
13841 pub fn format(mut self, format: Format) -> Self {
13842 self.inner.format = format;
13843 self
13844 }
13845 pub fn ty(mut self, ty: ImageType) -> Self {
13846 self.inner.ty = ty;
13847 self
13848 }
13849 pub fn tiling(mut self, tiling: ImageTiling) -> Self {
13850 self.inner.tiling = tiling;
13851 self
13852 }
13853 pub fn usage(mut self, usage: ImageUsageFlags) -> Self {
13854 self.inner.usage = usage;
13855 self
13856 }
13857 pub fn flags(mut self, flags: ImageCreateFlags) -> Self {
13858 self.inner.flags = flags;
13859 self
13860 }
13861 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
13862 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
13863 #[doc = r" valid extension structs can be pushed into the chain."]
13864 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
13865 #[doc = r" chain will look like `A -> D -> B -> C`."]
13866 pub fn push_next<T: ExtendsPhysicalDeviceImageFormatInfo2>(mut self, next: &'a mut T) -> Self {
13867 unsafe {
13868 let next_ptr = <*const T>::cast(next);
13869 let last_next = ptr_chain_iter(next).last().unwrap();
13870 (*last_next).p_next = self.inner.p_next as _;
13871 self.inner.p_next = next_ptr;
13872 }
13873 self
13874 }
13875 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13876 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13877 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
13878 pub fn build(self) -> PhysicalDeviceImageFormatInfo2 {
13879 self.inner
13880 }
13881}
13882#[repr(C)]
13883#[cfg_attr(feature = "debug", derive(Debug))]
13884#[derive(Copy, Clone)]
13885#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyProperties2.html>"]
13886pub struct QueueFamilyProperties2 {
13887 pub s_type: StructureType,
13888 pub p_next: *mut c_void,
13889 pub queue_family_properties: QueueFamilyProperties,
13890}
13891impl ::std::default::Default for QueueFamilyProperties2 {
13892 fn default() -> Self {
13893 Self {
13894 s_type: StructureType::QUEUE_FAMILY_PROPERTIES_2,
13895 p_next: ::std::ptr::null_mut(),
13896 queue_family_properties: QueueFamilyProperties::default(),
13897 }
13898 }
13899}
13900impl QueueFamilyProperties2 {
13901 pub fn builder<'a>() -> QueueFamilyProperties2Builder<'a> {
13902 QueueFamilyProperties2Builder {
13903 inner: Self::default(),
13904 marker: ::std::marker::PhantomData,
13905 }
13906 }
13907}
13908#[repr(transparent)]
13909pub struct QueueFamilyProperties2Builder<'a> {
13910 inner: QueueFamilyProperties2,
13911 marker: ::std::marker::PhantomData<&'a ()>,
13912}
13913pub unsafe trait ExtendsQueueFamilyProperties2 {}
13914impl<'a> ::std::ops::Deref for QueueFamilyProperties2Builder<'a> {
13915 type Target = QueueFamilyProperties2;
13916 fn deref(&self) -> &Self::Target {
13917 &self.inner
13918 }
13919}
13920impl<'a> ::std::ops::DerefMut for QueueFamilyProperties2Builder<'a> {
13921 fn deref_mut(&mut self) -> &mut Self::Target {
13922 &mut self.inner
13923 }
13924}
13925impl<'a> QueueFamilyProperties2Builder<'a> {
13926 pub fn queue_family_properties(
13927 mut self,
13928 queue_family_properties: QueueFamilyProperties,
13929 ) -> Self {
13930 self.inner.queue_family_properties = queue_family_properties;
13931 self
13932 }
13933 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
13934 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
13935 #[doc = r" valid extension structs can be pushed into the chain."]
13936 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
13937 #[doc = r" chain will look like `A -> D -> B -> C`."]
13938 pub fn push_next<T: ExtendsQueueFamilyProperties2>(mut self, next: &'a mut T) -> Self {
13939 unsafe {
13940 let next_ptr = <*mut T>::cast(next);
13941 let last_next = ptr_chain_iter(next).last().unwrap();
13942 (*last_next).p_next = self.inner.p_next as _;
13943 self.inner.p_next = next_ptr;
13944 }
13945 self
13946 }
13947 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13948 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13949 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
13950 pub fn build(self) -> QueueFamilyProperties2 {
13951 self.inner
13952 }
13953}
13954#[repr(C)]
13955#[cfg_attr(feature = "debug", derive(Debug))]
13956#[derive(Copy, Clone)]
13957#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMemoryProperties2.html>"]
13958pub struct PhysicalDeviceMemoryProperties2 {
13959 pub s_type: StructureType,
13960 pub p_next: *mut c_void,
13961 pub memory_properties: PhysicalDeviceMemoryProperties,
13962}
13963impl ::std::default::Default for PhysicalDeviceMemoryProperties2 {
13964 fn default() -> Self {
13965 Self {
13966 s_type: StructureType::PHYSICAL_DEVICE_MEMORY_PROPERTIES_2,
13967 p_next: ::std::ptr::null_mut(),
13968 memory_properties: PhysicalDeviceMemoryProperties::default(),
13969 }
13970 }
13971}
13972impl PhysicalDeviceMemoryProperties2 {
13973 pub fn builder<'a>() -> PhysicalDeviceMemoryProperties2Builder<'a> {
13974 PhysicalDeviceMemoryProperties2Builder {
13975 inner: Self::default(),
13976 marker: ::std::marker::PhantomData,
13977 }
13978 }
13979}
13980#[repr(transparent)]
13981pub struct PhysicalDeviceMemoryProperties2Builder<'a> {
13982 inner: PhysicalDeviceMemoryProperties2,
13983 marker: ::std::marker::PhantomData<&'a ()>,
13984}
13985pub unsafe trait ExtendsPhysicalDeviceMemoryProperties2 {}
13986impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryProperties2Builder<'a> {
13987 type Target = PhysicalDeviceMemoryProperties2;
13988 fn deref(&self) -> &Self::Target {
13989 &self.inner
13990 }
13991}
13992impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryProperties2Builder<'a> {
13993 fn deref_mut(&mut self) -> &mut Self::Target {
13994 &mut self.inner
13995 }
13996}
13997impl<'a> PhysicalDeviceMemoryProperties2Builder<'a> {
13998 pub fn memory_properties(mut self, memory_properties: PhysicalDeviceMemoryProperties) -> Self {
13999 self.inner.memory_properties = memory_properties;
14000 self
14001 }
14002 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
14003 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
14004 #[doc = r" valid extension structs can be pushed into the chain."]
14005 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
14006 #[doc = r" chain will look like `A -> D -> B -> C`."]
14007 pub fn push_next<T: ExtendsPhysicalDeviceMemoryProperties2>(mut self, next: &'a mut T) -> Self {
14008 unsafe {
14009 let next_ptr = <*mut T>::cast(next);
14010 let last_next = ptr_chain_iter(next).last().unwrap();
14011 (*last_next).p_next = self.inner.p_next as _;
14012 self.inner.p_next = next_ptr;
14013 }
14014 self
14015 }
14016 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14017 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14018 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14019 pub fn build(self) -> PhysicalDeviceMemoryProperties2 {
14020 self.inner
14021 }
14022}
14023#[repr(C)]
14024#[cfg_attr(feature = "debug", derive(Debug))]
14025#[derive(Copy, Clone)]
14026#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageFormatProperties2.html>"]
14027pub struct SparseImageFormatProperties2 {
14028 pub s_type: StructureType,
14029 pub p_next: *mut c_void,
14030 pub properties: SparseImageFormatProperties,
14031}
14032impl ::std::default::Default for SparseImageFormatProperties2 {
14033 fn default() -> Self {
14034 Self {
14035 s_type: StructureType::SPARSE_IMAGE_FORMAT_PROPERTIES_2,
14036 p_next: ::std::ptr::null_mut(),
14037 properties: SparseImageFormatProperties::default(),
14038 }
14039 }
14040}
14041impl SparseImageFormatProperties2 {
14042 pub fn builder<'a>() -> SparseImageFormatProperties2Builder<'a> {
14043 SparseImageFormatProperties2Builder {
14044 inner: Self::default(),
14045 marker: ::std::marker::PhantomData,
14046 }
14047 }
14048}
14049#[repr(transparent)]
14050pub struct SparseImageFormatProperties2Builder<'a> {
14051 inner: SparseImageFormatProperties2,
14052 marker: ::std::marker::PhantomData<&'a ()>,
14053}
14054impl<'a> ::std::ops::Deref for SparseImageFormatProperties2Builder<'a> {
14055 type Target = SparseImageFormatProperties2;
14056 fn deref(&self) -> &Self::Target {
14057 &self.inner
14058 }
14059}
14060impl<'a> ::std::ops::DerefMut for SparseImageFormatProperties2Builder<'a> {
14061 fn deref_mut(&mut self) -> &mut Self::Target {
14062 &mut self.inner
14063 }
14064}
14065impl<'a> SparseImageFormatProperties2Builder<'a> {
14066 pub fn properties(mut self, properties: SparseImageFormatProperties) -> Self {
14067 self.inner.properties = properties;
14068 self
14069 }
14070 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14071 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14072 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14073 pub fn build(self) -> SparseImageFormatProperties2 {
14074 self.inner
14075 }
14076}
14077#[repr(C)]
14078#[cfg_attr(feature = "debug", derive(Debug))]
14079#[derive(Copy, Clone)]
14080#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSparseImageFormatInfo2.html>"]
14081pub struct PhysicalDeviceSparseImageFormatInfo2 {
14082 pub s_type: StructureType,
14083 pub p_next: *const c_void,
14084 pub format: Format,
14085 pub ty: ImageType,
14086 pub samples: SampleCountFlags,
14087 pub usage: ImageUsageFlags,
14088 pub tiling: ImageTiling,
14089}
14090impl ::std::default::Default for PhysicalDeviceSparseImageFormatInfo2 {
14091 fn default() -> Self {
14092 Self {
14093 s_type: StructureType::PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2,
14094 p_next: ::std::ptr::null(),
14095 format: Format::default(),
14096 ty: ImageType::default(),
14097 samples: SampleCountFlags::default(),
14098 usage: ImageUsageFlags::default(),
14099 tiling: ImageTiling::default(),
14100 }
14101 }
14102}
14103impl PhysicalDeviceSparseImageFormatInfo2 {
14104 pub fn builder<'a>() -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
14105 PhysicalDeviceSparseImageFormatInfo2Builder {
14106 inner: Self::default(),
14107 marker: ::std::marker::PhantomData,
14108 }
14109 }
14110}
14111#[repr(transparent)]
14112pub struct PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
14113 inner: PhysicalDeviceSparseImageFormatInfo2,
14114 marker: ::std::marker::PhantomData<&'a ()>,
14115}
14116impl<'a> ::std::ops::Deref for PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
14117 type Target = PhysicalDeviceSparseImageFormatInfo2;
14118 fn deref(&self) -> &Self::Target {
14119 &self.inner
14120 }
14121}
14122impl<'a> ::std::ops::DerefMut for PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
14123 fn deref_mut(&mut self) -> &mut Self::Target {
14124 &mut self.inner
14125 }
14126}
14127impl<'a> PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
14128 pub fn format(mut self, format: Format) -> Self {
14129 self.inner.format = format;
14130 self
14131 }
14132 pub fn ty(mut self, ty: ImageType) -> Self {
14133 self.inner.ty = ty;
14134 self
14135 }
14136 pub fn samples(mut self, samples: SampleCountFlags) -> Self {
14137 self.inner.samples = samples;
14138 self
14139 }
14140 pub fn usage(mut self, usage: ImageUsageFlags) -> Self {
14141 self.inner.usage = usage;
14142 self
14143 }
14144 pub fn tiling(mut self, tiling: ImageTiling) -> Self {
14145 self.inner.tiling = tiling;
14146 self
14147 }
14148 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14149 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14150 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14151 pub fn build(self) -> PhysicalDeviceSparseImageFormatInfo2 {
14152 self.inner
14153 }
14154}
14155#[repr(C)]
14156#[cfg_attr(feature = "debug", derive(Debug))]
14157#[derive(Copy, Clone)]
14158#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePushDescriptorPropertiesKHR.html>"]
14159pub struct PhysicalDevicePushDescriptorPropertiesKHR {
14160 pub s_type: StructureType,
14161 pub p_next: *mut c_void,
14162 pub max_push_descriptors: u32,
14163}
14164impl ::std::default::Default for PhysicalDevicePushDescriptorPropertiesKHR {
14165 fn default() -> Self {
14166 Self {
14167 s_type: StructureType::PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR,
14168 p_next: ::std::ptr::null_mut(),
14169 max_push_descriptors: u32::default(),
14170 }
14171 }
14172}
14173impl PhysicalDevicePushDescriptorPropertiesKHR {
14174 pub fn builder<'a>() -> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
14175 PhysicalDevicePushDescriptorPropertiesKHRBuilder {
14176 inner: Self::default(),
14177 marker: ::std::marker::PhantomData,
14178 }
14179 }
14180}
14181#[repr(transparent)]
14182pub struct PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
14183 inner: PhysicalDevicePushDescriptorPropertiesKHR,
14184 marker: ::std::marker::PhantomData<&'a ()>,
14185}
14186unsafe impl ExtendsPhysicalDeviceProperties2
14187 for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'_>
14188{
14189}
14190unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePushDescriptorPropertiesKHR {}
14191impl<'a> ::std::ops::Deref for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
14192 type Target = PhysicalDevicePushDescriptorPropertiesKHR;
14193 fn deref(&self) -> &Self::Target {
14194 &self.inner
14195 }
14196}
14197impl<'a> ::std::ops::DerefMut for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
14198 fn deref_mut(&mut self) -> &mut Self::Target {
14199 &mut self.inner
14200 }
14201}
14202impl<'a> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
14203 pub fn max_push_descriptors(mut self, max_push_descriptors: u32) -> Self {
14204 self.inner.max_push_descriptors = max_push_descriptors;
14205 self
14206 }
14207 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14208 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14209 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14210 pub fn build(self) -> PhysicalDevicePushDescriptorPropertiesKHR {
14211 self.inner
14212 }
14213}
14214#[repr(C)]
14215#[cfg_attr(feature = "debug", derive(Debug))]
14216#[derive(Copy, Clone, Default)]
14217#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkConformanceVersion.html>"]
14218pub struct ConformanceVersion {
14219 pub major: u8,
14220 pub minor: u8,
14221 pub subminor: u8,
14222 pub patch: u8,
14223}
14224impl ConformanceVersion {
14225 pub fn builder<'a>() -> ConformanceVersionBuilder<'a> {
14226 ConformanceVersionBuilder {
14227 inner: Self::default(),
14228 marker: ::std::marker::PhantomData,
14229 }
14230 }
14231}
14232#[repr(transparent)]
14233pub struct ConformanceVersionBuilder<'a> {
14234 inner: ConformanceVersion,
14235 marker: ::std::marker::PhantomData<&'a ()>,
14236}
14237impl<'a> ::std::ops::Deref for ConformanceVersionBuilder<'a> {
14238 type Target = ConformanceVersion;
14239 fn deref(&self) -> &Self::Target {
14240 &self.inner
14241 }
14242}
14243impl<'a> ::std::ops::DerefMut for ConformanceVersionBuilder<'a> {
14244 fn deref_mut(&mut self) -> &mut Self::Target {
14245 &mut self.inner
14246 }
14247}
14248impl<'a> ConformanceVersionBuilder<'a> {
14249 pub fn major(mut self, major: u8) -> Self {
14250 self.inner.major = major;
14251 self
14252 }
14253 pub fn minor(mut self, minor: u8) -> Self {
14254 self.inner.minor = minor;
14255 self
14256 }
14257 pub fn subminor(mut self, subminor: u8) -> Self {
14258 self.inner.subminor = subminor;
14259 self
14260 }
14261 pub fn patch(mut self, patch: u8) -> Self {
14262 self.inner.patch = patch;
14263 self
14264 }
14265 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14266 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14267 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14268 pub fn build(self) -> ConformanceVersion {
14269 self.inner
14270 }
14271}
14272#[repr(C)]
14273#[derive(Copy, Clone)]
14274#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDriverProperties.html>"]
14275pub struct PhysicalDeviceDriverProperties {
14276 pub s_type: StructureType,
14277 pub p_next: *mut c_void,
14278 pub driver_id: DriverId,
14279 pub driver_name: [c_char; MAX_DRIVER_NAME_SIZE],
14280 pub driver_info: [c_char; MAX_DRIVER_INFO_SIZE],
14281 pub conformance_version: ConformanceVersion,
14282}
14283#[cfg(feature = "debug")]
14284impl fmt::Debug for PhysicalDeviceDriverProperties {
14285 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
14286 fmt.debug_struct("PhysicalDeviceDriverProperties")
14287 .field("s_type", &self.s_type)
14288 .field("p_next", &self.p_next)
14289 .field("driver_id", &self.driver_id)
14290 .field("driver_name", &unsafe {
14291 ::std::ffi::CStr::from_ptr(self.driver_name.as_ptr())
14292 })
14293 .field("driver_info", &unsafe {
14294 ::std::ffi::CStr::from_ptr(self.driver_info.as_ptr())
14295 })
14296 .field("conformance_version", &self.conformance_version)
14297 .finish()
14298 }
14299}
14300impl ::std::default::Default for PhysicalDeviceDriverProperties {
14301 fn default() -> Self {
14302 Self {
14303 s_type: StructureType::PHYSICAL_DEVICE_DRIVER_PROPERTIES,
14304 p_next: ::std::ptr::null_mut(),
14305 driver_id: DriverId::default(),
14306 driver_name: unsafe { ::std::mem::zeroed() },
14307 driver_info: unsafe { ::std::mem::zeroed() },
14308 conformance_version: ConformanceVersion::default(),
14309 }
14310 }
14311}
14312impl PhysicalDeviceDriverProperties {
14313 pub fn builder<'a>() -> PhysicalDeviceDriverPropertiesBuilder<'a> {
14314 PhysicalDeviceDriverPropertiesBuilder {
14315 inner: Self::default(),
14316 marker: ::std::marker::PhantomData,
14317 }
14318 }
14319}
14320#[repr(transparent)]
14321pub struct PhysicalDeviceDriverPropertiesBuilder<'a> {
14322 inner: PhysicalDeviceDriverProperties,
14323 marker: ::std::marker::PhantomData<&'a ()>,
14324}
14325unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDriverPropertiesBuilder<'_> {}
14326unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDriverProperties {}
14327impl<'a> ::std::ops::Deref for PhysicalDeviceDriverPropertiesBuilder<'a> {
14328 type Target = PhysicalDeviceDriverProperties;
14329 fn deref(&self) -> &Self::Target {
14330 &self.inner
14331 }
14332}
14333impl<'a> ::std::ops::DerefMut for PhysicalDeviceDriverPropertiesBuilder<'a> {
14334 fn deref_mut(&mut self) -> &mut Self::Target {
14335 &mut self.inner
14336 }
14337}
14338impl<'a> PhysicalDeviceDriverPropertiesBuilder<'a> {
14339 pub fn driver_id(mut self, driver_id: DriverId) -> Self {
14340 self.inner.driver_id = driver_id;
14341 self
14342 }
14343 pub fn driver_name(mut self, driver_name: [c_char; MAX_DRIVER_NAME_SIZE]) -> Self {
14344 self.inner.driver_name = driver_name;
14345 self
14346 }
14347 pub fn driver_info(mut self, driver_info: [c_char; MAX_DRIVER_INFO_SIZE]) -> Self {
14348 self.inner.driver_info = driver_info;
14349 self
14350 }
14351 pub fn conformance_version(mut self, conformance_version: ConformanceVersion) -> Self {
14352 self.inner.conformance_version = conformance_version;
14353 self
14354 }
14355 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14356 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14357 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14358 pub fn build(self) -> PhysicalDeviceDriverProperties {
14359 self.inner
14360 }
14361}
14362#[repr(C)]
14363#[cfg_attr(feature = "debug", derive(Debug))]
14364#[derive(Copy, Clone)]
14365#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentRegionsKHR.html>"]
14366pub struct PresentRegionsKHR {
14367 pub s_type: StructureType,
14368 pub p_next: *const c_void,
14369 pub swapchain_count: u32,
14370 pub p_regions: *const PresentRegionKHR,
14371}
14372impl ::std::default::Default for PresentRegionsKHR {
14373 fn default() -> Self {
14374 Self {
14375 s_type: StructureType::PRESENT_REGIONS_KHR,
14376 p_next: ::std::ptr::null(),
14377 swapchain_count: u32::default(),
14378 p_regions: ::std::ptr::null(),
14379 }
14380 }
14381}
14382impl PresentRegionsKHR {
14383 pub fn builder<'a>() -> PresentRegionsKHRBuilder<'a> {
14384 PresentRegionsKHRBuilder {
14385 inner: Self::default(),
14386 marker: ::std::marker::PhantomData,
14387 }
14388 }
14389}
14390#[repr(transparent)]
14391pub struct PresentRegionsKHRBuilder<'a> {
14392 inner: PresentRegionsKHR,
14393 marker: ::std::marker::PhantomData<&'a ()>,
14394}
14395unsafe impl ExtendsPresentInfoKHR for PresentRegionsKHRBuilder<'_> {}
14396unsafe impl ExtendsPresentInfoKHR for PresentRegionsKHR {}
14397impl<'a> ::std::ops::Deref for PresentRegionsKHRBuilder<'a> {
14398 type Target = PresentRegionsKHR;
14399 fn deref(&self) -> &Self::Target {
14400 &self.inner
14401 }
14402}
14403impl<'a> ::std::ops::DerefMut for PresentRegionsKHRBuilder<'a> {
14404 fn deref_mut(&mut self) -> &mut Self::Target {
14405 &mut self.inner
14406 }
14407}
14408impl<'a> PresentRegionsKHRBuilder<'a> {
14409 pub fn regions(mut self, regions: &'a [PresentRegionKHR]) -> Self {
14410 self.inner.swapchain_count = regions.len() as _;
14411 self.inner.p_regions = regions.as_ptr();
14412 self
14413 }
14414 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14415 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14416 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14417 pub fn build(self) -> PresentRegionsKHR {
14418 self.inner
14419 }
14420}
14421#[repr(C)]
14422#[cfg_attr(feature = "debug", derive(Debug))]
14423#[derive(Copy, Clone)]
14424#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentRegionKHR.html>"]
14425pub struct PresentRegionKHR {
14426 pub rectangle_count: u32,
14427 pub p_rectangles: *const RectLayerKHR,
14428}
14429impl ::std::default::Default for PresentRegionKHR {
14430 fn default() -> Self {
14431 Self {
14432 rectangle_count: u32::default(),
14433 p_rectangles: ::std::ptr::null(),
14434 }
14435 }
14436}
14437impl PresentRegionKHR {
14438 pub fn builder<'a>() -> PresentRegionKHRBuilder<'a> {
14439 PresentRegionKHRBuilder {
14440 inner: Self::default(),
14441 marker: ::std::marker::PhantomData,
14442 }
14443 }
14444}
14445#[repr(transparent)]
14446pub struct PresentRegionKHRBuilder<'a> {
14447 inner: PresentRegionKHR,
14448 marker: ::std::marker::PhantomData<&'a ()>,
14449}
14450impl<'a> ::std::ops::Deref for PresentRegionKHRBuilder<'a> {
14451 type Target = PresentRegionKHR;
14452 fn deref(&self) -> &Self::Target {
14453 &self.inner
14454 }
14455}
14456impl<'a> ::std::ops::DerefMut for PresentRegionKHRBuilder<'a> {
14457 fn deref_mut(&mut self) -> &mut Self::Target {
14458 &mut self.inner
14459 }
14460}
14461impl<'a> PresentRegionKHRBuilder<'a> {
14462 pub fn rectangles(mut self, rectangles: &'a [RectLayerKHR]) -> Self {
14463 self.inner.rectangle_count = rectangles.len() as _;
14464 self.inner.p_rectangles = rectangles.as_ptr();
14465 self
14466 }
14467 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14468 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14469 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14470 pub fn build(self) -> PresentRegionKHR {
14471 self.inner
14472 }
14473}
14474#[repr(C)]
14475#[cfg_attr(feature = "debug", derive(Debug))]
14476#[derive(Copy, Clone, Default)]
14477#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRectLayerKHR.html>"]
14478pub struct RectLayerKHR {
14479 pub offset: Offset2D,
14480 pub extent: Extent2D,
14481 pub layer: u32,
14482}
14483impl RectLayerKHR {
14484 pub fn builder<'a>() -> RectLayerKHRBuilder<'a> {
14485 RectLayerKHRBuilder {
14486 inner: Self::default(),
14487 marker: ::std::marker::PhantomData,
14488 }
14489 }
14490}
14491#[repr(transparent)]
14492pub struct RectLayerKHRBuilder<'a> {
14493 inner: RectLayerKHR,
14494 marker: ::std::marker::PhantomData<&'a ()>,
14495}
14496impl<'a> ::std::ops::Deref for RectLayerKHRBuilder<'a> {
14497 type Target = RectLayerKHR;
14498 fn deref(&self) -> &Self::Target {
14499 &self.inner
14500 }
14501}
14502impl<'a> ::std::ops::DerefMut for RectLayerKHRBuilder<'a> {
14503 fn deref_mut(&mut self) -> &mut Self::Target {
14504 &mut self.inner
14505 }
14506}
14507impl<'a> RectLayerKHRBuilder<'a> {
14508 pub fn offset(mut self, offset: Offset2D) -> Self {
14509 self.inner.offset = offset;
14510 self
14511 }
14512 pub fn extent(mut self, extent: Extent2D) -> Self {
14513 self.inner.extent = extent;
14514 self
14515 }
14516 pub fn layer(mut self, layer: u32) -> Self {
14517 self.inner.layer = layer;
14518 self
14519 }
14520 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14521 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14522 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14523 pub fn build(self) -> RectLayerKHR {
14524 self.inner
14525 }
14526}
14527#[repr(C)]
14528#[cfg_attr(feature = "debug", derive(Debug))]
14529#[derive(Copy, Clone)]
14530#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVariablePointersFeatures.html>"]
14531pub struct PhysicalDeviceVariablePointersFeatures {
14532 pub s_type: StructureType,
14533 pub p_next: *mut c_void,
14534 pub variable_pointers_storage_buffer: Bool32,
14535 pub variable_pointers: Bool32,
14536}
14537impl ::std::default::Default for PhysicalDeviceVariablePointersFeatures {
14538 fn default() -> Self {
14539 Self {
14540 s_type: StructureType::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
14541 p_next: ::std::ptr::null_mut(),
14542 variable_pointers_storage_buffer: Bool32::default(),
14543 variable_pointers: Bool32::default(),
14544 }
14545 }
14546}
14547impl PhysicalDeviceVariablePointersFeatures {
14548 pub fn builder<'a>() -> PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
14549 PhysicalDeviceVariablePointersFeaturesBuilder {
14550 inner: Self::default(),
14551 marker: ::std::marker::PhantomData,
14552 }
14553 }
14554}
14555#[repr(transparent)]
14556pub struct PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
14557 inner: PhysicalDeviceVariablePointersFeatures,
14558 marker: ::std::marker::PhantomData<&'a ()>,
14559}
14560unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVariablePointersFeaturesBuilder<'_> {}
14561unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVariablePointersFeatures {}
14562unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVariablePointersFeaturesBuilder<'_> {}
14563unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVariablePointersFeatures {}
14564impl<'a> ::std::ops::Deref for PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
14565 type Target = PhysicalDeviceVariablePointersFeatures;
14566 fn deref(&self) -> &Self::Target {
14567 &self.inner
14568 }
14569}
14570impl<'a> ::std::ops::DerefMut for PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
14571 fn deref_mut(&mut self) -> &mut Self::Target {
14572 &mut self.inner
14573 }
14574}
14575impl<'a> PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
14576 pub fn variable_pointers_storage_buffer(
14577 mut self,
14578 variable_pointers_storage_buffer: bool,
14579 ) -> Self {
14580 self.inner.variable_pointers_storage_buffer = variable_pointers_storage_buffer.into();
14581 self
14582 }
14583 pub fn variable_pointers(mut self, variable_pointers: bool) -> Self {
14584 self.inner.variable_pointers = variable_pointers.into();
14585 self
14586 }
14587 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14588 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14589 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14590 pub fn build(self) -> PhysicalDeviceVariablePointersFeatures {
14591 self.inner
14592 }
14593}
14594#[repr(C)]
14595#[cfg_attr(feature = "debug", derive(Debug))]
14596#[derive(Copy, Clone, Default)]
14597#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryProperties.html>"]
14598pub struct ExternalMemoryProperties {
14599 pub external_memory_features: ExternalMemoryFeatureFlags,
14600 pub export_from_imported_handle_types: ExternalMemoryHandleTypeFlags,
14601 pub compatible_handle_types: ExternalMemoryHandleTypeFlags,
14602}
14603impl ExternalMemoryProperties {
14604 pub fn builder<'a>() -> ExternalMemoryPropertiesBuilder<'a> {
14605 ExternalMemoryPropertiesBuilder {
14606 inner: Self::default(),
14607 marker: ::std::marker::PhantomData,
14608 }
14609 }
14610}
14611#[repr(transparent)]
14612pub struct ExternalMemoryPropertiesBuilder<'a> {
14613 inner: ExternalMemoryProperties,
14614 marker: ::std::marker::PhantomData<&'a ()>,
14615}
14616impl<'a> ::std::ops::Deref for ExternalMemoryPropertiesBuilder<'a> {
14617 type Target = ExternalMemoryProperties;
14618 fn deref(&self) -> &Self::Target {
14619 &self.inner
14620 }
14621}
14622impl<'a> ::std::ops::DerefMut for ExternalMemoryPropertiesBuilder<'a> {
14623 fn deref_mut(&mut self) -> &mut Self::Target {
14624 &mut self.inner
14625 }
14626}
14627impl<'a> ExternalMemoryPropertiesBuilder<'a> {
14628 pub fn external_memory_features(
14629 mut self,
14630 external_memory_features: ExternalMemoryFeatureFlags,
14631 ) -> Self {
14632 self.inner.external_memory_features = external_memory_features;
14633 self
14634 }
14635 pub fn export_from_imported_handle_types(
14636 mut self,
14637 export_from_imported_handle_types: ExternalMemoryHandleTypeFlags,
14638 ) -> Self {
14639 self.inner.export_from_imported_handle_types = export_from_imported_handle_types;
14640 self
14641 }
14642 pub fn compatible_handle_types(
14643 mut self,
14644 compatible_handle_types: ExternalMemoryHandleTypeFlags,
14645 ) -> Self {
14646 self.inner.compatible_handle_types = compatible_handle_types;
14647 self
14648 }
14649 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14650 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14651 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14652 pub fn build(self) -> ExternalMemoryProperties {
14653 self.inner
14654 }
14655}
14656#[repr(C)]
14657#[cfg_attr(feature = "debug", derive(Debug))]
14658#[derive(Copy, Clone)]
14659#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalImageFormatInfo.html>"]
14660pub struct PhysicalDeviceExternalImageFormatInfo {
14661 pub s_type: StructureType,
14662 pub p_next: *const c_void,
14663 pub handle_type: ExternalMemoryHandleTypeFlags,
14664}
14665impl ::std::default::Default for PhysicalDeviceExternalImageFormatInfo {
14666 fn default() -> Self {
14667 Self {
14668 s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
14669 p_next: ::std::ptr::null(),
14670 handle_type: ExternalMemoryHandleTypeFlags::default(),
14671 }
14672 }
14673}
14674impl PhysicalDeviceExternalImageFormatInfo {
14675 pub fn builder<'a>() -> PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
14676 PhysicalDeviceExternalImageFormatInfoBuilder {
14677 inner: Self::default(),
14678 marker: ::std::marker::PhantomData,
14679 }
14680 }
14681}
14682#[repr(transparent)]
14683pub struct PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
14684 inner: PhysicalDeviceExternalImageFormatInfo,
14685 marker: ::std::marker::PhantomData<&'a ()>,
14686}
14687unsafe impl ExtendsPhysicalDeviceImageFormatInfo2
14688 for PhysicalDeviceExternalImageFormatInfoBuilder<'_>
14689{
14690}
14691unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceExternalImageFormatInfo {}
14692impl<'a> ::std::ops::Deref for PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
14693 type Target = PhysicalDeviceExternalImageFormatInfo;
14694 fn deref(&self) -> &Self::Target {
14695 &self.inner
14696 }
14697}
14698impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
14699 fn deref_mut(&mut self) -> &mut Self::Target {
14700 &mut self.inner
14701 }
14702}
14703impl<'a> PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
14704 pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
14705 self.inner.handle_type = handle_type;
14706 self
14707 }
14708 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14709 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14710 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14711 pub fn build(self) -> PhysicalDeviceExternalImageFormatInfo {
14712 self.inner
14713 }
14714}
14715#[repr(C)]
14716#[cfg_attr(feature = "debug", derive(Debug))]
14717#[derive(Copy, Clone)]
14718#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalImageFormatProperties.html>"]
14719pub struct ExternalImageFormatProperties {
14720 pub s_type: StructureType,
14721 pub p_next: *mut c_void,
14722 pub external_memory_properties: ExternalMemoryProperties,
14723}
14724impl ::std::default::Default for ExternalImageFormatProperties {
14725 fn default() -> Self {
14726 Self {
14727 s_type: StructureType::EXTERNAL_IMAGE_FORMAT_PROPERTIES,
14728 p_next: ::std::ptr::null_mut(),
14729 external_memory_properties: ExternalMemoryProperties::default(),
14730 }
14731 }
14732}
14733impl ExternalImageFormatProperties {
14734 pub fn builder<'a>() -> ExternalImageFormatPropertiesBuilder<'a> {
14735 ExternalImageFormatPropertiesBuilder {
14736 inner: Self::default(),
14737 marker: ::std::marker::PhantomData,
14738 }
14739 }
14740}
14741#[repr(transparent)]
14742pub struct ExternalImageFormatPropertiesBuilder<'a> {
14743 inner: ExternalImageFormatProperties,
14744 marker: ::std::marker::PhantomData<&'a ()>,
14745}
14746unsafe impl ExtendsImageFormatProperties2 for ExternalImageFormatPropertiesBuilder<'_> {}
14747unsafe impl ExtendsImageFormatProperties2 for ExternalImageFormatProperties {}
14748impl<'a> ::std::ops::Deref for ExternalImageFormatPropertiesBuilder<'a> {
14749 type Target = ExternalImageFormatProperties;
14750 fn deref(&self) -> &Self::Target {
14751 &self.inner
14752 }
14753}
14754impl<'a> ::std::ops::DerefMut for ExternalImageFormatPropertiesBuilder<'a> {
14755 fn deref_mut(&mut self) -> &mut Self::Target {
14756 &mut self.inner
14757 }
14758}
14759impl<'a> ExternalImageFormatPropertiesBuilder<'a> {
14760 pub fn external_memory_properties(
14761 mut self,
14762 external_memory_properties: ExternalMemoryProperties,
14763 ) -> Self {
14764 self.inner.external_memory_properties = external_memory_properties;
14765 self
14766 }
14767 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14768 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14769 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14770 pub fn build(self) -> ExternalImageFormatProperties {
14771 self.inner
14772 }
14773}
14774#[repr(C)]
14775#[cfg_attr(feature = "debug", derive(Debug))]
14776#[derive(Copy, Clone)]
14777#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalBufferInfo.html>"]
14778pub struct PhysicalDeviceExternalBufferInfo {
14779 pub s_type: StructureType,
14780 pub p_next: *const c_void,
14781 pub flags: BufferCreateFlags,
14782 pub usage: BufferUsageFlags,
14783 pub handle_type: ExternalMemoryHandleTypeFlags,
14784}
14785impl ::std::default::Default for PhysicalDeviceExternalBufferInfo {
14786 fn default() -> Self {
14787 Self {
14788 s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,
14789 p_next: ::std::ptr::null(),
14790 flags: BufferCreateFlags::default(),
14791 usage: BufferUsageFlags::default(),
14792 handle_type: ExternalMemoryHandleTypeFlags::default(),
14793 }
14794 }
14795}
14796impl PhysicalDeviceExternalBufferInfo {
14797 pub fn builder<'a>() -> PhysicalDeviceExternalBufferInfoBuilder<'a> {
14798 PhysicalDeviceExternalBufferInfoBuilder {
14799 inner: Self::default(),
14800 marker: ::std::marker::PhantomData,
14801 }
14802 }
14803}
14804#[repr(transparent)]
14805pub struct PhysicalDeviceExternalBufferInfoBuilder<'a> {
14806 inner: PhysicalDeviceExternalBufferInfo,
14807 marker: ::std::marker::PhantomData<&'a ()>,
14808}
14809impl<'a> ::std::ops::Deref for PhysicalDeviceExternalBufferInfoBuilder<'a> {
14810 type Target = PhysicalDeviceExternalBufferInfo;
14811 fn deref(&self) -> &Self::Target {
14812 &self.inner
14813 }
14814}
14815impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalBufferInfoBuilder<'a> {
14816 fn deref_mut(&mut self) -> &mut Self::Target {
14817 &mut self.inner
14818 }
14819}
14820impl<'a> PhysicalDeviceExternalBufferInfoBuilder<'a> {
14821 pub fn flags(mut self, flags: BufferCreateFlags) -> Self {
14822 self.inner.flags = flags;
14823 self
14824 }
14825 pub fn usage(mut self, usage: BufferUsageFlags) -> Self {
14826 self.inner.usage = usage;
14827 self
14828 }
14829 pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
14830 self.inner.handle_type = handle_type;
14831 self
14832 }
14833 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14834 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14835 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14836 pub fn build(self) -> PhysicalDeviceExternalBufferInfo {
14837 self.inner
14838 }
14839}
14840#[repr(C)]
14841#[cfg_attr(feature = "debug", derive(Debug))]
14842#[derive(Copy, Clone)]
14843#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalBufferProperties.html>"]
14844pub struct ExternalBufferProperties {
14845 pub s_type: StructureType,
14846 pub p_next: *mut c_void,
14847 pub external_memory_properties: ExternalMemoryProperties,
14848}
14849impl ::std::default::Default for ExternalBufferProperties {
14850 fn default() -> Self {
14851 Self {
14852 s_type: StructureType::EXTERNAL_BUFFER_PROPERTIES,
14853 p_next: ::std::ptr::null_mut(),
14854 external_memory_properties: ExternalMemoryProperties::default(),
14855 }
14856 }
14857}
14858impl ExternalBufferProperties {
14859 pub fn builder<'a>() -> ExternalBufferPropertiesBuilder<'a> {
14860 ExternalBufferPropertiesBuilder {
14861 inner: Self::default(),
14862 marker: ::std::marker::PhantomData,
14863 }
14864 }
14865}
14866#[repr(transparent)]
14867pub struct ExternalBufferPropertiesBuilder<'a> {
14868 inner: ExternalBufferProperties,
14869 marker: ::std::marker::PhantomData<&'a ()>,
14870}
14871impl<'a> ::std::ops::Deref for ExternalBufferPropertiesBuilder<'a> {
14872 type Target = ExternalBufferProperties;
14873 fn deref(&self) -> &Self::Target {
14874 &self.inner
14875 }
14876}
14877impl<'a> ::std::ops::DerefMut for ExternalBufferPropertiesBuilder<'a> {
14878 fn deref_mut(&mut self) -> &mut Self::Target {
14879 &mut self.inner
14880 }
14881}
14882impl<'a> ExternalBufferPropertiesBuilder<'a> {
14883 pub fn external_memory_properties(
14884 mut self,
14885 external_memory_properties: ExternalMemoryProperties,
14886 ) -> Self {
14887 self.inner.external_memory_properties = external_memory_properties;
14888 self
14889 }
14890 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14891 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14892 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14893 pub fn build(self) -> ExternalBufferProperties {
14894 self.inner
14895 }
14896}
14897#[repr(C)]
14898#[cfg_attr(feature = "debug", derive(Debug))]
14899#[derive(Copy, Clone)]
14900#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceIDProperties.html>"]
14901pub struct PhysicalDeviceIDProperties {
14902 pub s_type: StructureType,
14903 pub p_next: *mut c_void,
14904 pub device_uuid: [u8; UUID_SIZE],
14905 pub driver_uuid: [u8; UUID_SIZE],
14906 pub device_luid: [u8; LUID_SIZE],
14907 pub device_node_mask: u32,
14908 pub device_luid_valid: Bool32,
14909}
14910impl ::std::default::Default for PhysicalDeviceIDProperties {
14911 fn default() -> Self {
14912 Self {
14913 s_type: StructureType::PHYSICAL_DEVICE_ID_PROPERTIES,
14914 p_next: ::std::ptr::null_mut(),
14915 device_uuid: unsafe { ::std::mem::zeroed() },
14916 driver_uuid: unsafe { ::std::mem::zeroed() },
14917 device_luid: unsafe { ::std::mem::zeroed() },
14918 device_node_mask: u32::default(),
14919 device_luid_valid: Bool32::default(),
14920 }
14921 }
14922}
14923impl PhysicalDeviceIDProperties {
14924 pub fn builder<'a>() -> PhysicalDeviceIDPropertiesBuilder<'a> {
14925 PhysicalDeviceIDPropertiesBuilder {
14926 inner: Self::default(),
14927 marker: ::std::marker::PhantomData,
14928 }
14929 }
14930}
14931#[repr(transparent)]
14932pub struct PhysicalDeviceIDPropertiesBuilder<'a> {
14933 inner: PhysicalDeviceIDProperties,
14934 marker: ::std::marker::PhantomData<&'a ()>,
14935}
14936unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceIDPropertiesBuilder<'_> {}
14937unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceIDProperties {}
14938impl<'a> ::std::ops::Deref for PhysicalDeviceIDPropertiesBuilder<'a> {
14939 type Target = PhysicalDeviceIDProperties;
14940 fn deref(&self) -> &Self::Target {
14941 &self.inner
14942 }
14943}
14944impl<'a> ::std::ops::DerefMut for PhysicalDeviceIDPropertiesBuilder<'a> {
14945 fn deref_mut(&mut self) -> &mut Self::Target {
14946 &mut self.inner
14947 }
14948}
14949impl<'a> PhysicalDeviceIDPropertiesBuilder<'a> {
14950 pub fn device_uuid(mut self, device_uuid: [u8; UUID_SIZE]) -> Self {
14951 self.inner.device_uuid = device_uuid;
14952 self
14953 }
14954 pub fn driver_uuid(mut self, driver_uuid: [u8; UUID_SIZE]) -> Self {
14955 self.inner.driver_uuid = driver_uuid;
14956 self
14957 }
14958 pub fn device_luid(mut self, device_luid: [u8; LUID_SIZE]) -> Self {
14959 self.inner.device_luid = device_luid;
14960 self
14961 }
14962 pub fn device_node_mask(mut self, device_node_mask: u32) -> Self {
14963 self.inner.device_node_mask = device_node_mask;
14964 self
14965 }
14966 pub fn device_luid_valid(mut self, device_luid_valid: bool) -> Self {
14967 self.inner.device_luid_valid = device_luid_valid.into();
14968 self
14969 }
14970 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14971 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14972 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14973 pub fn build(self) -> PhysicalDeviceIDProperties {
14974 self.inner
14975 }
14976}
14977#[repr(C)]
14978#[cfg_attr(feature = "debug", derive(Debug))]
14979#[derive(Copy, Clone)]
14980#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryImageCreateInfo.html>"]
14981pub struct ExternalMemoryImageCreateInfo {
14982 pub s_type: StructureType,
14983 pub p_next: *const c_void,
14984 pub handle_types: ExternalMemoryHandleTypeFlags,
14985}
14986impl ::std::default::Default for ExternalMemoryImageCreateInfo {
14987 fn default() -> Self {
14988 Self {
14989 s_type: StructureType::EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
14990 p_next: ::std::ptr::null(),
14991 handle_types: ExternalMemoryHandleTypeFlags::default(),
14992 }
14993 }
14994}
14995impl ExternalMemoryImageCreateInfo {
14996 pub fn builder<'a>() -> ExternalMemoryImageCreateInfoBuilder<'a> {
14997 ExternalMemoryImageCreateInfoBuilder {
14998 inner: Self::default(),
14999 marker: ::std::marker::PhantomData,
15000 }
15001 }
15002}
15003#[repr(transparent)]
15004pub struct ExternalMemoryImageCreateInfoBuilder<'a> {
15005 inner: ExternalMemoryImageCreateInfo,
15006 marker: ::std::marker::PhantomData<&'a ()>,
15007}
15008unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoBuilder<'_> {}
15009unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfo {}
15010impl<'a> ::std::ops::Deref for ExternalMemoryImageCreateInfoBuilder<'a> {
15011 type Target = ExternalMemoryImageCreateInfo;
15012 fn deref(&self) -> &Self::Target {
15013 &self.inner
15014 }
15015}
15016impl<'a> ::std::ops::DerefMut for ExternalMemoryImageCreateInfoBuilder<'a> {
15017 fn deref_mut(&mut self) -> &mut Self::Target {
15018 &mut self.inner
15019 }
15020}
15021impl<'a> ExternalMemoryImageCreateInfoBuilder<'a> {
15022 pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlags) -> Self {
15023 self.inner.handle_types = handle_types;
15024 self
15025 }
15026 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15027 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15028 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15029 pub fn build(self) -> ExternalMemoryImageCreateInfo {
15030 self.inner
15031 }
15032}
15033#[repr(C)]
15034#[cfg_attr(feature = "debug", derive(Debug))]
15035#[derive(Copy, Clone)]
15036#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryBufferCreateInfo.html>"]
15037pub struct ExternalMemoryBufferCreateInfo {
15038 pub s_type: StructureType,
15039 pub p_next: *const c_void,
15040 pub handle_types: ExternalMemoryHandleTypeFlags,
15041}
15042impl ::std::default::Default for ExternalMemoryBufferCreateInfo {
15043 fn default() -> Self {
15044 Self {
15045 s_type: StructureType::EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
15046 p_next: ::std::ptr::null(),
15047 handle_types: ExternalMemoryHandleTypeFlags::default(),
15048 }
15049 }
15050}
15051impl ExternalMemoryBufferCreateInfo {
15052 pub fn builder<'a>() -> ExternalMemoryBufferCreateInfoBuilder<'a> {
15053 ExternalMemoryBufferCreateInfoBuilder {
15054 inner: Self::default(),
15055 marker: ::std::marker::PhantomData,
15056 }
15057 }
15058}
15059#[repr(transparent)]
15060pub struct ExternalMemoryBufferCreateInfoBuilder<'a> {
15061 inner: ExternalMemoryBufferCreateInfo,
15062 marker: ::std::marker::PhantomData<&'a ()>,
15063}
15064unsafe impl ExtendsBufferCreateInfo for ExternalMemoryBufferCreateInfoBuilder<'_> {}
15065unsafe impl ExtendsBufferCreateInfo for ExternalMemoryBufferCreateInfo {}
15066impl<'a> ::std::ops::Deref for ExternalMemoryBufferCreateInfoBuilder<'a> {
15067 type Target = ExternalMemoryBufferCreateInfo;
15068 fn deref(&self) -> &Self::Target {
15069 &self.inner
15070 }
15071}
15072impl<'a> ::std::ops::DerefMut for ExternalMemoryBufferCreateInfoBuilder<'a> {
15073 fn deref_mut(&mut self) -> &mut Self::Target {
15074 &mut self.inner
15075 }
15076}
15077impl<'a> ExternalMemoryBufferCreateInfoBuilder<'a> {
15078 pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlags) -> Self {
15079 self.inner.handle_types = handle_types;
15080 self
15081 }
15082 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15083 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15084 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15085 pub fn build(self) -> ExternalMemoryBufferCreateInfo {
15086 self.inner
15087 }
15088}
15089#[repr(C)]
15090#[cfg_attr(feature = "debug", derive(Debug))]
15091#[derive(Copy, Clone)]
15092#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMemoryAllocateInfo.html>"]
15093pub struct ExportMemoryAllocateInfo {
15094 pub s_type: StructureType,
15095 pub p_next: *const c_void,
15096 pub handle_types: ExternalMemoryHandleTypeFlags,
15097}
15098impl ::std::default::Default for ExportMemoryAllocateInfo {
15099 fn default() -> Self {
15100 Self {
15101 s_type: StructureType::EXPORT_MEMORY_ALLOCATE_INFO,
15102 p_next: ::std::ptr::null(),
15103 handle_types: ExternalMemoryHandleTypeFlags::default(),
15104 }
15105 }
15106}
15107impl ExportMemoryAllocateInfo {
15108 pub fn builder<'a>() -> ExportMemoryAllocateInfoBuilder<'a> {
15109 ExportMemoryAllocateInfoBuilder {
15110 inner: Self::default(),
15111 marker: ::std::marker::PhantomData,
15112 }
15113 }
15114}
15115#[repr(transparent)]
15116pub struct ExportMemoryAllocateInfoBuilder<'a> {
15117 inner: ExportMemoryAllocateInfo,
15118 marker: ::std::marker::PhantomData<&'a ()>,
15119}
15120unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoBuilder<'_> {}
15121unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfo {}
15122impl<'a> ::std::ops::Deref for ExportMemoryAllocateInfoBuilder<'a> {
15123 type Target = ExportMemoryAllocateInfo;
15124 fn deref(&self) -> &Self::Target {
15125 &self.inner
15126 }
15127}
15128impl<'a> ::std::ops::DerefMut for ExportMemoryAllocateInfoBuilder<'a> {
15129 fn deref_mut(&mut self) -> &mut Self::Target {
15130 &mut self.inner
15131 }
15132}
15133impl<'a> ExportMemoryAllocateInfoBuilder<'a> {
15134 pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlags) -> Self {
15135 self.inner.handle_types = handle_types;
15136 self
15137 }
15138 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15139 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15140 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15141 pub fn build(self) -> ExportMemoryAllocateInfo {
15142 self.inner
15143 }
15144}
15145#[repr(C)]
15146#[cfg_attr(feature = "debug", derive(Debug))]
15147#[derive(Copy, Clone)]
15148#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMemoryWin32HandleInfoKHR.html>"]
15149pub struct ImportMemoryWin32HandleInfoKHR {
15150 pub s_type: StructureType,
15151 pub p_next: *const c_void,
15152 pub handle_type: ExternalMemoryHandleTypeFlags,
15153 pub handle: HANDLE,
15154 pub name: LPCWSTR,
15155}
15156impl ::std::default::Default for ImportMemoryWin32HandleInfoKHR {
15157 fn default() -> Self {
15158 Self {
15159 s_type: StructureType::IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
15160 p_next: ::std::ptr::null(),
15161 handle_type: ExternalMemoryHandleTypeFlags::default(),
15162 handle: unsafe { ::std::mem::zeroed() },
15163 name: unsafe { ::std::mem::zeroed() },
15164 }
15165 }
15166}
15167impl ImportMemoryWin32HandleInfoKHR {
15168 pub fn builder<'a>() -> ImportMemoryWin32HandleInfoKHRBuilder<'a> {
15169 ImportMemoryWin32HandleInfoKHRBuilder {
15170 inner: Self::default(),
15171 marker: ::std::marker::PhantomData,
15172 }
15173 }
15174}
15175#[repr(transparent)]
15176pub struct ImportMemoryWin32HandleInfoKHRBuilder<'a> {
15177 inner: ImportMemoryWin32HandleInfoKHR,
15178 marker: ::std::marker::PhantomData<&'a ()>,
15179}
15180unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoKHRBuilder<'_> {}
15181unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoKHR {}
15182impl<'a> ::std::ops::Deref for ImportMemoryWin32HandleInfoKHRBuilder<'a> {
15183 type Target = ImportMemoryWin32HandleInfoKHR;
15184 fn deref(&self) -> &Self::Target {
15185 &self.inner
15186 }
15187}
15188impl<'a> ::std::ops::DerefMut for ImportMemoryWin32HandleInfoKHRBuilder<'a> {
15189 fn deref_mut(&mut self) -> &mut Self::Target {
15190 &mut self.inner
15191 }
15192}
15193impl<'a> ImportMemoryWin32HandleInfoKHRBuilder<'a> {
15194 pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
15195 self.inner.handle_type = handle_type;
15196 self
15197 }
15198 pub fn handle(mut self, handle: HANDLE) -> Self {
15199 self.inner.handle = handle;
15200 self
15201 }
15202 pub fn name(mut self, name: LPCWSTR) -> Self {
15203 self.inner.name = name;
15204 self
15205 }
15206 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15207 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15208 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15209 pub fn build(self) -> ImportMemoryWin32HandleInfoKHR {
15210 self.inner
15211 }
15212}
15213#[repr(C)]
15214#[cfg_attr(feature = "debug", derive(Debug))]
15215#[derive(Copy, Clone)]
15216#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMemoryWin32HandleInfoKHR.html>"]
15217pub struct ExportMemoryWin32HandleInfoKHR {
15218 pub s_type: StructureType,
15219 pub p_next: *const c_void,
15220 pub p_attributes: *const SECURITY_ATTRIBUTES,
15221 pub dw_access: DWORD,
15222 pub name: LPCWSTR,
15223}
15224impl ::std::default::Default for ExportMemoryWin32HandleInfoKHR {
15225 fn default() -> Self {
15226 Self {
15227 s_type: StructureType::EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
15228 p_next: ::std::ptr::null(),
15229 p_attributes: ::std::ptr::null(),
15230 dw_access: DWORD::default(),
15231 name: unsafe { ::std::mem::zeroed() },
15232 }
15233 }
15234}
15235impl ExportMemoryWin32HandleInfoKHR {
15236 pub fn builder<'a>() -> ExportMemoryWin32HandleInfoKHRBuilder<'a> {
15237 ExportMemoryWin32HandleInfoKHRBuilder {
15238 inner: Self::default(),
15239 marker: ::std::marker::PhantomData,
15240 }
15241 }
15242}
15243#[repr(transparent)]
15244pub struct ExportMemoryWin32HandleInfoKHRBuilder<'a> {
15245 inner: ExportMemoryWin32HandleInfoKHR,
15246 marker: ::std::marker::PhantomData<&'a ()>,
15247}
15248unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoKHRBuilder<'_> {}
15249unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoKHR {}
15250impl<'a> ::std::ops::Deref for ExportMemoryWin32HandleInfoKHRBuilder<'a> {
15251 type Target = ExportMemoryWin32HandleInfoKHR;
15252 fn deref(&self) -> &Self::Target {
15253 &self.inner
15254 }
15255}
15256impl<'a> ::std::ops::DerefMut for ExportMemoryWin32HandleInfoKHRBuilder<'a> {
15257 fn deref_mut(&mut self) -> &mut Self::Target {
15258 &mut self.inner
15259 }
15260}
15261impl<'a> ExportMemoryWin32HandleInfoKHRBuilder<'a> {
15262 pub fn attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self {
15263 self.inner.p_attributes = attributes;
15264 self
15265 }
15266 pub fn dw_access(mut self, dw_access: DWORD) -> Self {
15267 self.inner.dw_access = dw_access;
15268 self
15269 }
15270 pub fn name(mut self, name: LPCWSTR) -> Self {
15271 self.inner.name = name;
15272 self
15273 }
15274 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15275 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15276 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15277 pub fn build(self) -> ExportMemoryWin32HandleInfoKHR {
15278 self.inner
15279 }
15280}
15281#[repr(C)]
15282#[cfg_attr(feature = "debug", derive(Debug))]
15283#[derive(Copy, Clone)]
15284#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMemoryZirconHandleInfoFUCHSIA.html>"]
15285pub struct ImportMemoryZirconHandleInfoFUCHSIA {
15286 pub s_type: StructureType,
15287 pub p_next: *const c_void,
15288 pub handle_type: ExternalMemoryHandleTypeFlags,
15289 pub handle: zx_handle_t,
15290}
15291impl ::std::default::Default for ImportMemoryZirconHandleInfoFUCHSIA {
15292 fn default() -> Self {
15293 Self {
15294 s_type: StructureType::IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA,
15295 p_next: ::std::ptr::null(),
15296 handle_type: ExternalMemoryHandleTypeFlags::default(),
15297 handle: zx_handle_t::default(),
15298 }
15299 }
15300}
15301impl ImportMemoryZirconHandleInfoFUCHSIA {
15302 pub fn builder<'a>() -> ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> {
15303 ImportMemoryZirconHandleInfoFUCHSIABuilder {
15304 inner: Self::default(),
15305 marker: ::std::marker::PhantomData,
15306 }
15307 }
15308}
15309#[repr(transparent)]
15310pub struct ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> {
15311 inner: ImportMemoryZirconHandleInfoFUCHSIA,
15312 marker: ::std::marker::PhantomData<&'a ()>,
15313}
15314unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryZirconHandleInfoFUCHSIABuilder<'_> {}
15315unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryZirconHandleInfoFUCHSIA {}
15316impl<'a> ::std::ops::Deref for ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> {
15317 type Target = ImportMemoryZirconHandleInfoFUCHSIA;
15318 fn deref(&self) -> &Self::Target {
15319 &self.inner
15320 }
15321}
15322impl<'a> ::std::ops::DerefMut for ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> {
15323 fn deref_mut(&mut self) -> &mut Self::Target {
15324 &mut self.inner
15325 }
15326}
15327impl<'a> ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> {
15328 pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
15329 self.inner.handle_type = handle_type;
15330 self
15331 }
15332 pub fn handle(mut self, handle: zx_handle_t) -> Self {
15333 self.inner.handle = handle;
15334 self
15335 }
15336 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15337 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15338 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15339 pub fn build(self) -> ImportMemoryZirconHandleInfoFUCHSIA {
15340 self.inner
15341 }
15342}
15343#[repr(C)]
15344#[cfg_attr(feature = "debug", derive(Debug))]
15345#[derive(Copy, Clone)]
15346#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryZirconHandlePropertiesFUCHSIA.html>"]
15347pub struct MemoryZirconHandlePropertiesFUCHSIA {
15348 pub s_type: StructureType,
15349 pub p_next: *mut c_void,
15350 pub memory_type_bits: u32,
15351}
15352impl ::std::default::Default for MemoryZirconHandlePropertiesFUCHSIA {
15353 fn default() -> Self {
15354 Self {
15355 s_type: StructureType::MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA,
15356 p_next: ::std::ptr::null_mut(),
15357 memory_type_bits: u32::default(),
15358 }
15359 }
15360}
15361impl MemoryZirconHandlePropertiesFUCHSIA {
15362 pub fn builder<'a>() -> MemoryZirconHandlePropertiesFUCHSIABuilder<'a> {
15363 MemoryZirconHandlePropertiesFUCHSIABuilder {
15364 inner: Self::default(),
15365 marker: ::std::marker::PhantomData,
15366 }
15367 }
15368}
15369#[repr(transparent)]
15370pub struct MemoryZirconHandlePropertiesFUCHSIABuilder<'a> {
15371 inner: MemoryZirconHandlePropertiesFUCHSIA,
15372 marker: ::std::marker::PhantomData<&'a ()>,
15373}
15374impl<'a> ::std::ops::Deref for MemoryZirconHandlePropertiesFUCHSIABuilder<'a> {
15375 type Target = MemoryZirconHandlePropertiesFUCHSIA;
15376 fn deref(&self) -> &Self::Target {
15377 &self.inner
15378 }
15379}
15380impl<'a> ::std::ops::DerefMut for MemoryZirconHandlePropertiesFUCHSIABuilder<'a> {
15381 fn deref_mut(&mut self) -> &mut Self::Target {
15382 &mut self.inner
15383 }
15384}
15385impl<'a> MemoryZirconHandlePropertiesFUCHSIABuilder<'a> {
15386 pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self {
15387 self.inner.memory_type_bits = memory_type_bits;
15388 self
15389 }
15390 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15391 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15392 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15393 pub fn build(self) -> MemoryZirconHandlePropertiesFUCHSIA {
15394 self.inner
15395 }
15396}
15397#[repr(C)]
15398#[cfg_attr(feature = "debug", derive(Debug))]
15399#[derive(Copy, Clone)]
15400#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryGetZirconHandleInfoFUCHSIA.html>"]
15401pub struct MemoryGetZirconHandleInfoFUCHSIA {
15402 pub s_type: StructureType,
15403 pub p_next: *const c_void,
15404 pub memory: DeviceMemory,
15405 pub handle_type: ExternalMemoryHandleTypeFlags,
15406}
15407impl ::std::default::Default for MemoryGetZirconHandleInfoFUCHSIA {
15408 fn default() -> Self {
15409 Self {
15410 s_type: StructureType::MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA,
15411 p_next: ::std::ptr::null(),
15412 memory: DeviceMemory::default(),
15413 handle_type: ExternalMemoryHandleTypeFlags::default(),
15414 }
15415 }
15416}
15417impl MemoryGetZirconHandleInfoFUCHSIA {
15418 pub fn builder<'a>() -> MemoryGetZirconHandleInfoFUCHSIABuilder<'a> {
15419 MemoryGetZirconHandleInfoFUCHSIABuilder {
15420 inner: Self::default(),
15421 marker: ::std::marker::PhantomData,
15422 }
15423 }
15424}
15425#[repr(transparent)]
15426pub struct MemoryGetZirconHandleInfoFUCHSIABuilder<'a> {
15427 inner: MemoryGetZirconHandleInfoFUCHSIA,
15428 marker: ::std::marker::PhantomData<&'a ()>,
15429}
15430impl<'a> ::std::ops::Deref for MemoryGetZirconHandleInfoFUCHSIABuilder<'a> {
15431 type Target = MemoryGetZirconHandleInfoFUCHSIA;
15432 fn deref(&self) -> &Self::Target {
15433 &self.inner
15434 }
15435}
15436impl<'a> ::std::ops::DerefMut for MemoryGetZirconHandleInfoFUCHSIABuilder<'a> {
15437 fn deref_mut(&mut self) -> &mut Self::Target {
15438 &mut self.inner
15439 }
15440}
15441impl<'a> MemoryGetZirconHandleInfoFUCHSIABuilder<'a> {
15442 pub fn memory(mut self, memory: DeviceMemory) -> Self {
15443 self.inner.memory = memory;
15444 self
15445 }
15446 pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
15447 self.inner.handle_type = handle_type;
15448 self
15449 }
15450 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15451 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15452 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15453 pub fn build(self) -> MemoryGetZirconHandleInfoFUCHSIA {
15454 self.inner
15455 }
15456}
15457#[repr(C)]
15458#[cfg_attr(feature = "debug", derive(Debug))]
15459#[derive(Copy, Clone)]
15460#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryWin32HandlePropertiesKHR.html>"]
15461pub struct MemoryWin32HandlePropertiesKHR {
15462 pub s_type: StructureType,
15463 pub p_next: *mut c_void,
15464 pub memory_type_bits: u32,
15465}
15466impl ::std::default::Default for MemoryWin32HandlePropertiesKHR {
15467 fn default() -> Self {
15468 Self {
15469 s_type: StructureType::MEMORY_WIN32_HANDLE_PROPERTIES_KHR,
15470 p_next: ::std::ptr::null_mut(),
15471 memory_type_bits: u32::default(),
15472 }
15473 }
15474}
15475impl MemoryWin32HandlePropertiesKHR {
15476 pub fn builder<'a>() -> MemoryWin32HandlePropertiesKHRBuilder<'a> {
15477 MemoryWin32HandlePropertiesKHRBuilder {
15478 inner: Self::default(),
15479 marker: ::std::marker::PhantomData,
15480 }
15481 }
15482}
15483#[repr(transparent)]
15484pub struct MemoryWin32HandlePropertiesKHRBuilder<'a> {
15485 inner: MemoryWin32HandlePropertiesKHR,
15486 marker: ::std::marker::PhantomData<&'a ()>,
15487}
15488impl<'a> ::std::ops::Deref for MemoryWin32HandlePropertiesKHRBuilder<'a> {
15489 type Target = MemoryWin32HandlePropertiesKHR;
15490 fn deref(&self) -> &Self::Target {
15491 &self.inner
15492 }
15493}
15494impl<'a> ::std::ops::DerefMut for MemoryWin32HandlePropertiesKHRBuilder<'a> {
15495 fn deref_mut(&mut self) -> &mut Self::Target {
15496 &mut self.inner
15497 }
15498}
15499impl<'a> MemoryWin32HandlePropertiesKHRBuilder<'a> {
15500 pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self {
15501 self.inner.memory_type_bits = memory_type_bits;
15502 self
15503 }
15504 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15505 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15506 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15507 pub fn build(self) -> MemoryWin32HandlePropertiesKHR {
15508 self.inner
15509 }
15510}
15511#[repr(C)]
15512#[cfg_attr(feature = "debug", derive(Debug))]
15513#[derive(Copy, Clone)]
15514#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryGetWin32HandleInfoKHR.html>"]
15515pub struct MemoryGetWin32HandleInfoKHR {
15516 pub s_type: StructureType,
15517 pub p_next: *const c_void,
15518 pub memory: DeviceMemory,
15519 pub handle_type: ExternalMemoryHandleTypeFlags,
15520}
15521impl ::std::default::Default for MemoryGetWin32HandleInfoKHR {
15522 fn default() -> Self {
15523 Self {
15524 s_type: StructureType::MEMORY_GET_WIN32_HANDLE_INFO_KHR,
15525 p_next: ::std::ptr::null(),
15526 memory: DeviceMemory::default(),
15527 handle_type: ExternalMemoryHandleTypeFlags::default(),
15528 }
15529 }
15530}
15531impl MemoryGetWin32HandleInfoKHR {
15532 pub fn builder<'a>() -> MemoryGetWin32HandleInfoKHRBuilder<'a> {
15533 MemoryGetWin32HandleInfoKHRBuilder {
15534 inner: Self::default(),
15535 marker: ::std::marker::PhantomData,
15536 }
15537 }
15538}
15539#[repr(transparent)]
15540pub struct MemoryGetWin32HandleInfoKHRBuilder<'a> {
15541 inner: MemoryGetWin32HandleInfoKHR,
15542 marker: ::std::marker::PhantomData<&'a ()>,
15543}
15544impl<'a> ::std::ops::Deref for MemoryGetWin32HandleInfoKHRBuilder<'a> {
15545 type Target = MemoryGetWin32HandleInfoKHR;
15546 fn deref(&self) -> &Self::Target {
15547 &self.inner
15548 }
15549}
15550impl<'a> ::std::ops::DerefMut for MemoryGetWin32HandleInfoKHRBuilder<'a> {
15551 fn deref_mut(&mut self) -> &mut Self::Target {
15552 &mut self.inner
15553 }
15554}
15555impl<'a> MemoryGetWin32HandleInfoKHRBuilder<'a> {
15556 pub fn memory(mut self, memory: DeviceMemory) -> Self {
15557 self.inner.memory = memory;
15558 self
15559 }
15560 pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
15561 self.inner.handle_type = handle_type;
15562 self
15563 }
15564 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15565 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15566 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15567 pub fn build(self) -> MemoryGetWin32HandleInfoKHR {
15568 self.inner
15569 }
15570}
15571#[repr(C)]
15572#[cfg_attr(feature = "debug", derive(Debug))]
15573#[derive(Copy, Clone)]
15574#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMemoryFdInfoKHR.html>"]
15575pub struct ImportMemoryFdInfoKHR {
15576 pub s_type: StructureType,
15577 pub p_next: *const c_void,
15578 pub handle_type: ExternalMemoryHandleTypeFlags,
15579 pub fd: c_int,
15580}
15581impl ::std::default::Default for ImportMemoryFdInfoKHR {
15582 fn default() -> Self {
15583 Self {
15584 s_type: StructureType::IMPORT_MEMORY_FD_INFO_KHR,
15585 p_next: ::std::ptr::null(),
15586 handle_type: ExternalMemoryHandleTypeFlags::default(),
15587 fd: c_int::default(),
15588 }
15589 }
15590}
15591impl ImportMemoryFdInfoKHR {
15592 pub fn builder<'a>() -> ImportMemoryFdInfoKHRBuilder<'a> {
15593 ImportMemoryFdInfoKHRBuilder {
15594 inner: Self::default(),
15595 marker: ::std::marker::PhantomData,
15596 }
15597 }
15598}
15599#[repr(transparent)]
15600pub struct ImportMemoryFdInfoKHRBuilder<'a> {
15601 inner: ImportMemoryFdInfoKHR,
15602 marker: ::std::marker::PhantomData<&'a ()>,
15603}
15604unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryFdInfoKHRBuilder<'_> {}
15605unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryFdInfoKHR {}
15606impl<'a> ::std::ops::Deref for ImportMemoryFdInfoKHRBuilder<'a> {
15607 type Target = ImportMemoryFdInfoKHR;
15608 fn deref(&self) -> &Self::Target {
15609 &self.inner
15610 }
15611}
15612impl<'a> ::std::ops::DerefMut for ImportMemoryFdInfoKHRBuilder<'a> {
15613 fn deref_mut(&mut self) -> &mut Self::Target {
15614 &mut self.inner
15615 }
15616}
15617impl<'a> ImportMemoryFdInfoKHRBuilder<'a> {
15618 pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
15619 self.inner.handle_type = handle_type;
15620 self
15621 }
15622 pub fn fd(mut self, fd: c_int) -> Self {
15623 self.inner.fd = fd;
15624 self
15625 }
15626 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15627 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15628 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15629 pub fn build(self) -> ImportMemoryFdInfoKHR {
15630 self.inner
15631 }
15632}
15633#[repr(C)]
15634#[cfg_attr(feature = "debug", derive(Debug))]
15635#[derive(Copy, Clone)]
15636#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryFdPropertiesKHR.html>"]
15637pub struct MemoryFdPropertiesKHR {
15638 pub s_type: StructureType,
15639 pub p_next: *mut c_void,
15640 pub memory_type_bits: u32,
15641}
15642impl ::std::default::Default for MemoryFdPropertiesKHR {
15643 fn default() -> Self {
15644 Self {
15645 s_type: StructureType::MEMORY_FD_PROPERTIES_KHR,
15646 p_next: ::std::ptr::null_mut(),
15647 memory_type_bits: u32::default(),
15648 }
15649 }
15650}
15651impl MemoryFdPropertiesKHR {
15652 pub fn builder<'a>() -> MemoryFdPropertiesKHRBuilder<'a> {
15653 MemoryFdPropertiesKHRBuilder {
15654 inner: Self::default(),
15655 marker: ::std::marker::PhantomData,
15656 }
15657 }
15658}
15659#[repr(transparent)]
15660pub struct MemoryFdPropertiesKHRBuilder<'a> {
15661 inner: MemoryFdPropertiesKHR,
15662 marker: ::std::marker::PhantomData<&'a ()>,
15663}
15664impl<'a> ::std::ops::Deref for MemoryFdPropertiesKHRBuilder<'a> {
15665 type Target = MemoryFdPropertiesKHR;
15666 fn deref(&self) -> &Self::Target {
15667 &self.inner
15668 }
15669}
15670impl<'a> ::std::ops::DerefMut for MemoryFdPropertiesKHRBuilder<'a> {
15671 fn deref_mut(&mut self) -> &mut Self::Target {
15672 &mut self.inner
15673 }
15674}
15675impl<'a> MemoryFdPropertiesKHRBuilder<'a> {
15676 pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self {
15677 self.inner.memory_type_bits = memory_type_bits;
15678 self
15679 }
15680 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15681 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15682 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15683 pub fn build(self) -> MemoryFdPropertiesKHR {
15684 self.inner
15685 }
15686}
15687#[repr(C)]
15688#[cfg_attr(feature = "debug", derive(Debug))]
15689#[derive(Copy, Clone)]
15690#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryGetFdInfoKHR.html>"]
15691pub struct MemoryGetFdInfoKHR {
15692 pub s_type: StructureType,
15693 pub p_next: *const c_void,
15694 pub memory: DeviceMemory,
15695 pub handle_type: ExternalMemoryHandleTypeFlags,
15696}
15697impl ::std::default::Default for MemoryGetFdInfoKHR {
15698 fn default() -> Self {
15699 Self {
15700 s_type: StructureType::MEMORY_GET_FD_INFO_KHR,
15701 p_next: ::std::ptr::null(),
15702 memory: DeviceMemory::default(),
15703 handle_type: ExternalMemoryHandleTypeFlags::default(),
15704 }
15705 }
15706}
15707impl MemoryGetFdInfoKHR {
15708 pub fn builder<'a>() -> MemoryGetFdInfoKHRBuilder<'a> {
15709 MemoryGetFdInfoKHRBuilder {
15710 inner: Self::default(),
15711 marker: ::std::marker::PhantomData,
15712 }
15713 }
15714}
15715#[repr(transparent)]
15716pub struct MemoryGetFdInfoKHRBuilder<'a> {
15717 inner: MemoryGetFdInfoKHR,
15718 marker: ::std::marker::PhantomData<&'a ()>,
15719}
15720impl<'a> ::std::ops::Deref for MemoryGetFdInfoKHRBuilder<'a> {
15721 type Target = MemoryGetFdInfoKHR;
15722 fn deref(&self) -> &Self::Target {
15723 &self.inner
15724 }
15725}
15726impl<'a> ::std::ops::DerefMut for MemoryGetFdInfoKHRBuilder<'a> {
15727 fn deref_mut(&mut self) -> &mut Self::Target {
15728 &mut self.inner
15729 }
15730}
15731impl<'a> MemoryGetFdInfoKHRBuilder<'a> {
15732 pub fn memory(mut self, memory: DeviceMemory) -> Self {
15733 self.inner.memory = memory;
15734 self
15735 }
15736 pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
15737 self.inner.handle_type = handle_type;
15738 self
15739 }
15740 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15741 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15742 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15743 pub fn build(self) -> MemoryGetFdInfoKHR {
15744 self.inner
15745 }
15746}
15747#[repr(C)]
15748#[cfg_attr(feature = "debug", derive(Debug))]
15749#[derive(Copy, Clone)]
15750#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWin32KeyedMutexAcquireReleaseInfoKHR.html>"]
15751pub struct Win32KeyedMutexAcquireReleaseInfoKHR {
15752 pub s_type: StructureType,
15753 pub p_next: *const c_void,
15754 pub acquire_count: u32,
15755 pub p_acquire_syncs: *const DeviceMemory,
15756 pub p_acquire_keys: *const u64,
15757 pub p_acquire_timeouts: *const u32,
15758 pub release_count: u32,
15759 pub p_release_syncs: *const DeviceMemory,
15760 pub p_release_keys: *const u64,
15761}
15762impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoKHR {
15763 fn default() -> Self {
15764 Self {
15765 s_type: StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR,
15766 p_next: ::std::ptr::null(),
15767 acquire_count: u32::default(),
15768 p_acquire_syncs: ::std::ptr::null(),
15769 p_acquire_keys: ::std::ptr::null(),
15770 p_acquire_timeouts: ::std::ptr::null(),
15771 release_count: u32::default(),
15772 p_release_syncs: ::std::ptr::null(),
15773 p_release_keys: ::std::ptr::null(),
15774 }
15775 }
15776}
15777impl Win32KeyedMutexAcquireReleaseInfoKHR {
15778 pub fn builder<'a>() -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
15779 Win32KeyedMutexAcquireReleaseInfoKHRBuilder {
15780 inner: Self::default(),
15781 marker: ::std::marker::PhantomData,
15782 }
15783 }
15784}
15785#[repr(transparent)]
15786pub struct Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
15787 inner: Win32KeyedMutexAcquireReleaseInfoKHR,
15788 marker: ::std::marker::PhantomData<&'a ()>,
15789}
15790unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'_> {}
15791unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoKHR {}
15792unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'_> {}
15793unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoKHR {}
15794impl<'a> ::std::ops::Deref for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
15795 type Target = Win32KeyedMutexAcquireReleaseInfoKHR;
15796 fn deref(&self) -> &Self::Target {
15797 &self.inner
15798 }
15799}
15800impl<'a> ::std::ops::DerefMut for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
15801 fn deref_mut(&mut self) -> &mut Self::Target {
15802 &mut self.inner
15803 }
15804}
15805impl<'a> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
15806 pub fn acquire_syncs(mut self, acquire_syncs: &'a [DeviceMemory]) -> Self {
15807 self.inner.acquire_count = acquire_syncs.len() as _;
15808 self.inner.p_acquire_syncs = acquire_syncs.as_ptr();
15809 self
15810 }
15811 pub fn acquire_keys(mut self, acquire_keys: &'a [u64]) -> Self {
15812 self.inner.acquire_count = acquire_keys.len() as _;
15813 self.inner.p_acquire_keys = acquire_keys.as_ptr();
15814 self
15815 }
15816 pub fn acquire_timeouts(mut self, acquire_timeouts: &'a [u32]) -> Self {
15817 self.inner.acquire_count = acquire_timeouts.len() as _;
15818 self.inner.p_acquire_timeouts = acquire_timeouts.as_ptr();
15819 self
15820 }
15821 pub fn release_syncs(mut self, release_syncs: &'a [DeviceMemory]) -> Self {
15822 self.inner.release_count = release_syncs.len() as _;
15823 self.inner.p_release_syncs = release_syncs.as_ptr();
15824 self
15825 }
15826 pub fn release_keys(mut self, release_keys: &'a [u64]) -> Self {
15827 self.inner.release_count = release_keys.len() as _;
15828 self.inner.p_release_keys = release_keys.as_ptr();
15829 self
15830 }
15831 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15832 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15833 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15834 pub fn build(self) -> Win32KeyedMutexAcquireReleaseInfoKHR {
15835 self.inner
15836 }
15837}
15838#[repr(C)]
15839#[cfg_attr(feature = "debug", derive(Debug))]
15840#[derive(Copy, Clone)]
15841#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalSemaphoreInfo.html>"]
15842pub struct PhysicalDeviceExternalSemaphoreInfo {
15843 pub s_type: StructureType,
15844 pub p_next: *const c_void,
15845 pub handle_type: ExternalSemaphoreHandleTypeFlags,
15846}
15847impl ::std::default::Default for PhysicalDeviceExternalSemaphoreInfo {
15848 fn default() -> Self {
15849 Self {
15850 s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
15851 p_next: ::std::ptr::null(),
15852 handle_type: ExternalSemaphoreHandleTypeFlags::default(),
15853 }
15854 }
15855}
15856impl PhysicalDeviceExternalSemaphoreInfo {
15857 pub fn builder<'a>() -> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
15858 PhysicalDeviceExternalSemaphoreInfoBuilder {
15859 inner: Self::default(),
15860 marker: ::std::marker::PhantomData,
15861 }
15862 }
15863}
15864#[repr(transparent)]
15865pub struct PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
15866 inner: PhysicalDeviceExternalSemaphoreInfo,
15867 marker: ::std::marker::PhantomData<&'a ()>,
15868}
15869pub unsafe trait ExtendsPhysicalDeviceExternalSemaphoreInfo {}
15870impl<'a> ::std::ops::Deref for PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
15871 type Target = PhysicalDeviceExternalSemaphoreInfo;
15872 fn deref(&self) -> &Self::Target {
15873 &self.inner
15874 }
15875}
15876impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
15877 fn deref_mut(&mut self) -> &mut Self::Target {
15878 &mut self.inner
15879 }
15880}
15881impl<'a> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
15882 pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self {
15883 self.inner.handle_type = handle_type;
15884 self
15885 }
15886 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
15887 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
15888 #[doc = r" valid extension structs can be pushed into the chain."]
15889 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
15890 #[doc = r" chain will look like `A -> D -> B -> C`."]
15891 pub fn push_next<T: ExtendsPhysicalDeviceExternalSemaphoreInfo>(
15892 mut self,
15893 next: &'a mut T,
15894 ) -> Self {
15895 unsafe {
15896 let next_ptr = <*const T>::cast(next);
15897 let last_next = ptr_chain_iter(next).last().unwrap();
15898 (*last_next).p_next = self.inner.p_next as _;
15899 self.inner.p_next = next_ptr;
15900 }
15901 self
15902 }
15903 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15904 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15905 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15906 pub fn build(self) -> PhysicalDeviceExternalSemaphoreInfo {
15907 self.inner
15908 }
15909}
15910#[repr(C)]
15911#[cfg_attr(feature = "debug", derive(Debug))]
15912#[derive(Copy, Clone)]
15913#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalSemaphoreProperties.html>"]
15914pub struct ExternalSemaphoreProperties {
15915 pub s_type: StructureType,
15916 pub p_next: *mut c_void,
15917 pub export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags,
15918 pub compatible_handle_types: ExternalSemaphoreHandleTypeFlags,
15919 pub external_semaphore_features: ExternalSemaphoreFeatureFlags,
15920}
15921impl ::std::default::Default for ExternalSemaphoreProperties {
15922 fn default() -> Self {
15923 Self {
15924 s_type: StructureType::EXTERNAL_SEMAPHORE_PROPERTIES,
15925 p_next: ::std::ptr::null_mut(),
15926 export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags::default(),
15927 compatible_handle_types: ExternalSemaphoreHandleTypeFlags::default(),
15928 external_semaphore_features: ExternalSemaphoreFeatureFlags::default(),
15929 }
15930 }
15931}
15932impl ExternalSemaphoreProperties {
15933 pub fn builder<'a>() -> ExternalSemaphorePropertiesBuilder<'a> {
15934 ExternalSemaphorePropertiesBuilder {
15935 inner: Self::default(),
15936 marker: ::std::marker::PhantomData,
15937 }
15938 }
15939}
15940#[repr(transparent)]
15941pub struct ExternalSemaphorePropertiesBuilder<'a> {
15942 inner: ExternalSemaphoreProperties,
15943 marker: ::std::marker::PhantomData<&'a ()>,
15944}
15945impl<'a> ::std::ops::Deref for ExternalSemaphorePropertiesBuilder<'a> {
15946 type Target = ExternalSemaphoreProperties;
15947 fn deref(&self) -> &Self::Target {
15948 &self.inner
15949 }
15950}
15951impl<'a> ::std::ops::DerefMut for ExternalSemaphorePropertiesBuilder<'a> {
15952 fn deref_mut(&mut self) -> &mut Self::Target {
15953 &mut self.inner
15954 }
15955}
15956impl<'a> ExternalSemaphorePropertiesBuilder<'a> {
15957 pub fn export_from_imported_handle_types(
15958 mut self,
15959 export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags,
15960 ) -> Self {
15961 self.inner.export_from_imported_handle_types = export_from_imported_handle_types;
15962 self
15963 }
15964 pub fn compatible_handle_types(
15965 mut self,
15966 compatible_handle_types: ExternalSemaphoreHandleTypeFlags,
15967 ) -> Self {
15968 self.inner.compatible_handle_types = compatible_handle_types;
15969 self
15970 }
15971 pub fn external_semaphore_features(
15972 mut self,
15973 external_semaphore_features: ExternalSemaphoreFeatureFlags,
15974 ) -> Self {
15975 self.inner.external_semaphore_features = external_semaphore_features;
15976 self
15977 }
15978 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15979 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15980 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15981 pub fn build(self) -> ExternalSemaphoreProperties {
15982 self.inner
15983 }
15984}
15985#[repr(C)]
15986#[cfg_attr(feature = "debug", derive(Debug))]
15987#[derive(Copy, Clone)]
15988#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportSemaphoreCreateInfo.html>"]
15989pub struct ExportSemaphoreCreateInfo {
15990 pub s_type: StructureType,
15991 pub p_next: *const c_void,
15992 pub handle_types: ExternalSemaphoreHandleTypeFlags,
15993}
15994impl ::std::default::Default for ExportSemaphoreCreateInfo {
15995 fn default() -> Self {
15996 Self {
15997 s_type: StructureType::EXPORT_SEMAPHORE_CREATE_INFO,
15998 p_next: ::std::ptr::null(),
15999 handle_types: ExternalSemaphoreHandleTypeFlags::default(),
16000 }
16001 }
16002}
16003impl ExportSemaphoreCreateInfo {
16004 pub fn builder<'a>() -> ExportSemaphoreCreateInfoBuilder<'a> {
16005 ExportSemaphoreCreateInfoBuilder {
16006 inner: Self::default(),
16007 marker: ::std::marker::PhantomData,
16008 }
16009 }
16010}
16011#[repr(transparent)]
16012pub struct ExportSemaphoreCreateInfoBuilder<'a> {
16013 inner: ExportSemaphoreCreateInfo,
16014 marker: ::std::marker::PhantomData<&'a ()>,
16015}
16016unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreCreateInfoBuilder<'_> {}
16017unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreCreateInfo {}
16018impl<'a> ::std::ops::Deref for ExportSemaphoreCreateInfoBuilder<'a> {
16019 type Target = ExportSemaphoreCreateInfo;
16020 fn deref(&self) -> &Self::Target {
16021 &self.inner
16022 }
16023}
16024impl<'a> ::std::ops::DerefMut for ExportSemaphoreCreateInfoBuilder<'a> {
16025 fn deref_mut(&mut self) -> &mut Self::Target {
16026 &mut self.inner
16027 }
16028}
16029impl<'a> ExportSemaphoreCreateInfoBuilder<'a> {
16030 pub fn handle_types(mut self, handle_types: ExternalSemaphoreHandleTypeFlags) -> Self {
16031 self.inner.handle_types = handle_types;
16032 self
16033 }
16034 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16035 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16036 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
16037 pub fn build(self) -> ExportSemaphoreCreateInfo {
16038 self.inner
16039 }
16040}
16041#[repr(C)]
16042#[cfg_attr(feature = "debug", derive(Debug))]
16043#[derive(Copy, Clone)]
16044#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportSemaphoreWin32HandleInfoKHR.html>"]
16045pub struct ImportSemaphoreWin32HandleInfoKHR {
16046 pub s_type: StructureType,
16047 pub p_next: *const c_void,
16048 pub semaphore: Semaphore,
16049 pub flags: SemaphoreImportFlags,
16050 pub handle_type: ExternalSemaphoreHandleTypeFlags,
16051 pub handle: HANDLE,
16052 pub name: LPCWSTR,
16053}
16054impl ::std::default::Default for ImportSemaphoreWin32HandleInfoKHR {
16055 fn default() -> Self {
16056 Self {
16057 s_type: StructureType::IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR,
16058 p_next: ::std::ptr::null(),
16059 semaphore: Semaphore::default(),
16060 flags: SemaphoreImportFlags::default(),
16061 handle_type: ExternalSemaphoreHandleTypeFlags::default(),
16062 handle: unsafe { ::std::mem::zeroed() },
16063 name: unsafe { ::std::mem::zeroed() },
16064 }
16065 }
16066}
16067impl ImportSemaphoreWin32HandleInfoKHR {
16068 pub fn builder<'a>() -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
16069 ImportSemaphoreWin32HandleInfoKHRBuilder {
16070 inner: Self::default(),
16071 marker: ::std::marker::PhantomData,
16072 }
16073 }
16074}
16075#[repr(transparent)]
16076pub struct ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
16077 inner: ImportSemaphoreWin32HandleInfoKHR,
16078 marker: ::std::marker::PhantomData<&'a ()>,
16079}
16080impl<'a> ::std::ops::Deref for ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
16081 type Target = ImportSemaphoreWin32HandleInfoKHR;
16082 fn deref(&self) -> &Self::Target {
16083 &self.inner
16084 }
16085}
16086impl<'a> ::std::ops::DerefMut for ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
16087 fn deref_mut(&mut self) -> &mut Self::Target {
16088 &mut self.inner
16089 }
16090}
16091impl<'a> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
16092 pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
16093 self.inner.semaphore = semaphore;
16094 self
16095 }
16096 pub fn flags(mut self, flags: SemaphoreImportFlags) -> Self {
16097 self.inner.flags = flags;
16098 self
16099 }
16100 pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self {
16101 self.inner.handle_type = handle_type;
16102 self
16103 }
16104 pub fn handle(mut self, handle: HANDLE) -> Self {
16105 self.inner.handle = handle;
16106 self
16107 }
16108 pub fn name(mut self, name: LPCWSTR) -> Self {
16109 self.inner.name = name;
16110 self
16111 }
16112 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16113 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16114 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
16115 pub fn build(self) -> ImportSemaphoreWin32HandleInfoKHR {
16116 self.inner
16117 }
16118}
16119#[repr(C)]
16120#[cfg_attr(feature = "debug", derive(Debug))]
16121#[derive(Copy, Clone)]
16122#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportSemaphoreWin32HandleInfoKHR.html>"]
16123pub struct ExportSemaphoreWin32HandleInfoKHR {
16124 pub s_type: StructureType,
16125 pub p_next: *const c_void,
16126 pub p_attributes: *const SECURITY_ATTRIBUTES,
16127 pub dw_access: DWORD,
16128 pub name: LPCWSTR,
16129}
16130impl ::std::default::Default for ExportSemaphoreWin32HandleInfoKHR {
16131 fn default() -> Self {
16132 Self {
16133 s_type: StructureType::EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR,
16134 p_next: ::std::ptr::null(),
16135 p_attributes: ::std::ptr::null(),
16136 dw_access: DWORD::default(),
16137 name: unsafe { ::std::mem::zeroed() },
16138 }
16139 }
16140}
16141impl ExportSemaphoreWin32HandleInfoKHR {
16142 pub fn builder<'a>() -> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
16143 ExportSemaphoreWin32HandleInfoKHRBuilder {
16144 inner: Self::default(),
16145 marker: ::std::marker::PhantomData,
16146 }
16147 }
16148}
16149#[repr(transparent)]
16150pub struct ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
16151 inner: ExportSemaphoreWin32HandleInfoKHR,
16152 marker: ::std::marker::PhantomData<&'a ()>,
16153}
16154unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreWin32HandleInfoKHRBuilder<'_> {}
16155unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreWin32HandleInfoKHR {}
16156impl<'a> ::std::ops::Deref for ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
16157 type Target = ExportSemaphoreWin32HandleInfoKHR;
16158 fn deref(&self) -> &Self::Target {
16159 &self.inner
16160 }
16161}
16162impl<'a> ::std::ops::DerefMut for ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
16163 fn deref_mut(&mut self) -> &mut Self::Target {
16164 &mut self.inner
16165 }
16166}
16167impl<'a> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
16168 pub fn attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self {
16169 self.inner.p_attributes = attributes;
16170 self
16171 }
16172 pub fn dw_access(mut self, dw_access: DWORD) -> Self {
16173 self.inner.dw_access = dw_access;
16174 self
16175 }
16176 pub fn name(mut self, name: LPCWSTR) -> Self {
16177 self.inner.name = name;
16178 self
16179 }
16180 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16181 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16182 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
16183 pub fn build(self) -> ExportSemaphoreWin32HandleInfoKHR {
16184 self.inner
16185 }
16186}
16187#[repr(C)]
16188#[cfg_attr(feature = "debug", derive(Debug))]
16189#[derive(Copy, Clone)]
16190#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkD3D12FenceSubmitInfoKHR.html>"]
16191pub struct D3D12FenceSubmitInfoKHR {
16192 pub s_type: StructureType,
16193 pub p_next: *const c_void,
16194 pub wait_semaphore_values_count: u32,
16195 pub p_wait_semaphore_values: *const u64,
16196 pub signal_semaphore_values_count: u32,
16197 pub p_signal_semaphore_values: *const u64,
16198}
16199impl ::std::default::Default for D3D12FenceSubmitInfoKHR {
16200 fn default() -> Self {
16201 Self {
16202 s_type: StructureType::D3D12_FENCE_SUBMIT_INFO_KHR,
16203 p_next: ::std::ptr::null(),
16204 wait_semaphore_values_count: u32::default(),
16205 p_wait_semaphore_values: ::std::ptr::null(),
16206 signal_semaphore_values_count: u32::default(),
16207 p_signal_semaphore_values: ::std::ptr::null(),
16208 }
16209 }
16210}
16211impl D3D12FenceSubmitInfoKHR {
16212 pub fn builder<'a>() -> D3D12FenceSubmitInfoKHRBuilder<'a> {
16213 D3D12FenceSubmitInfoKHRBuilder {
16214 inner: Self::default(),
16215 marker: ::std::marker::PhantomData,
16216 }
16217 }
16218}
16219#[repr(transparent)]
16220pub struct D3D12FenceSubmitInfoKHRBuilder<'a> {
16221 inner: D3D12FenceSubmitInfoKHR,
16222 marker: ::std::marker::PhantomData<&'a ()>,
16223}
16224unsafe impl ExtendsSubmitInfo for D3D12FenceSubmitInfoKHRBuilder<'_> {}
16225unsafe impl ExtendsSubmitInfo for D3D12FenceSubmitInfoKHR {}
16226impl<'a> ::std::ops::Deref for D3D12FenceSubmitInfoKHRBuilder<'a> {
16227 type Target = D3D12FenceSubmitInfoKHR;
16228 fn deref(&self) -> &Self::Target {
16229 &self.inner
16230 }
16231}
16232impl<'a> ::std::ops::DerefMut for D3D12FenceSubmitInfoKHRBuilder<'a> {
16233 fn deref_mut(&mut self) -> &mut Self::Target {
16234 &mut self.inner
16235 }
16236}
16237impl<'a> D3D12FenceSubmitInfoKHRBuilder<'a> {
16238 pub fn wait_semaphore_values(mut self, wait_semaphore_values: &'a [u64]) -> Self {
16239 self.inner.wait_semaphore_values_count = wait_semaphore_values.len() as _;
16240 self.inner.p_wait_semaphore_values = wait_semaphore_values.as_ptr();
16241 self
16242 }
16243 pub fn signal_semaphore_values(mut self, signal_semaphore_values: &'a [u64]) -> Self {
16244 self.inner.signal_semaphore_values_count = signal_semaphore_values.len() as _;
16245 self.inner.p_signal_semaphore_values = signal_semaphore_values.as_ptr();
16246 self
16247 }
16248 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16249 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16250 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
16251 pub fn build(self) -> D3D12FenceSubmitInfoKHR {
16252 self.inner
16253 }
16254}
16255#[repr(C)]
16256#[cfg_attr(feature = "debug", derive(Debug))]
16257#[derive(Copy, Clone)]
16258#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreGetWin32HandleInfoKHR.html>"]
16259pub struct SemaphoreGetWin32HandleInfoKHR {
16260 pub s_type: StructureType,
16261 pub p_next: *const c_void,
16262 pub semaphore: Semaphore,
16263 pub handle_type: ExternalSemaphoreHandleTypeFlags,
16264}
16265impl ::std::default::Default for SemaphoreGetWin32HandleInfoKHR {
16266 fn default() -> Self {
16267 Self {
16268 s_type: StructureType::SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR,
16269 p_next: ::std::ptr::null(),
16270 semaphore: Semaphore::default(),
16271 handle_type: ExternalSemaphoreHandleTypeFlags::default(),
16272 }
16273 }
16274}
16275impl SemaphoreGetWin32HandleInfoKHR {
16276 pub fn builder<'a>() -> SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
16277 SemaphoreGetWin32HandleInfoKHRBuilder {
16278 inner: Self::default(),
16279 marker: ::std::marker::PhantomData,
16280 }
16281 }
16282}
16283#[repr(transparent)]
16284pub struct SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
16285 inner: SemaphoreGetWin32HandleInfoKHR,
16286 marker: ::std::marker::PhantomData<&'a ()>,
16287}
16288impl<'a> ::std::ops::Deref for SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
16289 type Target = SemaphoreGetWin32HandleInfoKHR;
16290 fn deref(&self) -> &Self::Target {
16291 &self.inner
16292 }
16293}
16294impl<'a> ::std::ops::DerefMut for SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
16295 fn deref_mut(&mut self) -> &mut Self::Target {
16296 &mut self.inner
16297 }
16298}
16299impl<'a> SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
16300 pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
16301 self.inner.semaphore = semaphore;
16302 self
16303 }
16304 pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self {
16305 self.inner.handle_type = handle_type;
16306 self
16307 }
16308 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16309 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16310 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
16311 pub fn build(self) -> SemaphoreGetWin32HandleInfoKHR {
16312 self.inner
16313 }
16314}
16315#[repr(C)]
16316#[cfg_attr(feature = "debug", derive(Debug))]
16317#[derive(Copy, Clone)]
16318#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportSemaphoreFdInfoKHR.html>"]
16319pub struct ImportSemaphoreFdInfoKHR {
16320 pub s_type: StructureType,
16321 pub p_next: *const c_void,
16322 pub semaphore: Semaphore,
16323 pub flags: SemaphoreImportFlags,
16324 pub handle_type: ExternalSemaphoreHandleTypeFlags,
16325 pub fd: c_int,
16326}
16327impl ::std::default::Default for ImportSemaphoreFdInfoKHR {
16328 fn default() -> Self {
16329 Self {
16330 s_type: StructureType::IMPORT_SEMAPHORE_FD_INFO_KHR,
16331 p_next: ::std::ptr::null(),
16332 semaphore: Semaphore::default(),
16333 flags: SemaphoreImportFlags::default(),
16334 handle_type: ExternalSemaphoreHandleTypeFlags::default(),
16335 fd: c_int::default(),
16336 }
16337 }
16338}
16339impl ImportSemaphoreFdInfoKHR {
16340 pub fn builder<'a>() -> ImportSemaphoreFdInfoKHRBuilder<'a> {
16341 ImportSemaphoreFdInfoKHRBuilder {
16342 inner: Self::default(),
16343 marker: ::std::marker::PhantomData,
16344 }
16345 }
16346}
16347#[repr(transparent)]
16348pub struct ImportSemaphoreFdInfoKHRBuilder<'a> {
16349 inner: ImportSemaphoreFdInfoKHR,
16350 marker: ::std::marker::PhantomData<&'a ()>,
16351}
16352impl<'a> ::std::ops::Deref for ImportSemaphoreFdInfoKHRBuilder<'a> {
16353 type Target = ImportSemaphoreFdInfoKHR;
16354 fn deref(&self) -> &Self::Target {
16355 &self.inner
16356 }
16357}
16358impl<'a> ::std::ops::DerefMut for ImportSemaphoreFdInfoKHRBuilder<'a> {
16359 fn deref_mut(&mut self) -> &mut Self::Target {
16360 &mut self.inner
16361 }
16362}
16363impl<'a> ImportSemaphoreFdInfoKHRBuilder<'a> {
16364 pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
16365 self.inner.semaphore = semaphore;
16366 self
16367 }
16368 pub fn flags(mut self, flags: SemaphoreImportFlags) -> Self {
16369 self.inner.flags = flags;
16370 self
16371 }
16372 pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self {
16373 self.inner.handle_type = handle_type;
16374 self
16375 }
16376 pub fn fd(mut self, fd: c_int) -> Self {
16377 self.inner.fd = fd;
16378 self
16379 }
16380 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16381 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16382 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
16383 pub fn build(self) -> ImportSemaphoreFdInfoKHR {
16384 self.inner
16385 }
16386}
16387#[repr(C)]
16388#[cfg_attr(feature = "debug", derive(Debug))]
16389#[derive(Copy, Clone)]
16390#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreGetFdInfoKHR.html>"]
16391pub struct SemaphoreGetFdInfoKHR {
16392 pub s_type: StructureType,
16393 pub p_next: *const c_void,
16394 pub semaphore: Semaphore,
16395 pub handle_type: ExternalSemaphoreHandleTypeFlags,
16396}
16397impl ::std::default::Default for SemaphoreGetFdInfoKHR {
16398 fn default() -> Self {
16399 Self {
16400 s_type: StructureType::SEMAPHORE_GET_FD_INFO_KHR,
16401 p_next: ::std::ptr::null(),
16402 semaphore: Semaphore::default(),
16403 handle_type: ExternalSemaphoreHandleTypeFlags::default(),
16404 }
16405 }
16406}
16407impl SemaphoreGetFdInfoKHR {
16408 pub fn builder<'a>() -> SemaphoreGetFdInfoKHRBuilder<'a> {
16409 SemaphoreGetFdInfoKHRBuilder {
16410 inner: Self::default(),
16411 marker: ::std::marker::PhantomData,
16412 }
16413 }
16414}
16415#[repr(transparent)]
16416pub struct SemaphoreGetFdInfoKHRBuilder<'a> {
16417 inner: SemaphoreGetFdInfoKHR,
16418 marker: ::std::marker::PhantomData<&'a ()>,
16419}
16420impl<'a> ::std::ops::Deref for SemaphoreGetFdInfoKHRBuilder<'a> {
16421 type Target = SemaphoreGetFdInfoKHR;
16422 fn deref(&self) -> &Self::Target {
16423 &self.inner
16424 }
16425}
16426impl<'a> ::std::ops::DerefMut for SemaphoreGetFdInfoKHRBuilder<'a> {
16427 fn deref_mut(&mut self) -> &mut Self::Target {
16428 &mut self.inner
16429 }
16430}
16431impl<'a> SemaphoreGetFdInfoKHRBuilder<'a> {
16432 pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
16433 self.inner.semaphore = semaphore;
16434 self
16435 }
16436 pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self {
16437 self.inner.handle_type = handle_type;
16438 self
16439 }
16440 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16441 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16442 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
16443 pub fn build(self) -> SemaphoreGetFdInfoKHR {
16444 self.inner
16445 }
16446}
16447#[repr(C)]
16448#[cfg_attr(feature = "debug", derive(Debug))]
16449#[derive(Copy, Clone)]
16450#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportSemaphoreZirconHandleInfoFUCHSIA.html>"]
16451pub struct ImportSemaphoreZirconHandleInfoFUCHSIA {
16452 pub s_type: StructureType,
16453 pub p_next: *const c_void,
16454 pub semaphore: Semaphore,
16455 pub flags: SemaphoreImportFlags,
16456 pub handle_type: ExternalSemaphoreHandleTypeFlags,
16457 pub zircon_handle: zx_handle_t,
16458}
16459impl ::std::default::Default for ImportSemaphoreZirconHandleInfoFUCHSIA {
16460 fn default() -> Self {
16461 Self {
16462 s_type: StructureType::IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA,
16463 p_next: ::std::ptr::null(),
16464 semaphore: Semaphore::default(),
16465 flags: SemaphoreImportFlags::default(),
16466 handle_type: ExternalSemaphoreHandleTypeFlags::default(),
16467 zircon_handle: zx_handle_t::default(),
16468 }
16469 }
16470}
16471impl ImportSemaphoreZirconHandleInfoFUCHSIA {
16472 pub fn builder<'a>() -> ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> {
16473 ImportSemaphoreZirconHandleInfoFUCHSIABuilder {
16474 inner: Self::default(),
16475 marker: ::std::marker::PhantomData,
16476 }
16477 }
16478}
16479#[repr(transparent)]
16480pub struct ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> {
16481 inner: ImportSemaphoreZirconHandleInfoFUCHSIA,
16482 marker: ::std::marker::PhantomData<&'a ()>,
16483}
16484impl<'a> ::std::ops::Deref for ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> {
16485 type Target = ImportSemaphoreZirconHandleInfoFUCHSIA;
16486 fn deref(&self) -> &Self::Target {
16487 &self.inner
16488 }
16489}
16490impl<'a> ::std::ops::DerefMut for ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> {
16491 fn deref_mut(&mut self) -> &mut Self::Target {
16492 &mut self.inner
16493 }
16494}
16495impl<'a> ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> {
16496 pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
16497 self.inner.semaphore = semaphore;
16498 self
16499 }
16500 pub fn flags(mut self, flags: SemaphoreImportFlags) -> Self {
16501 self.inner.flags = flags;
16502 self
16503 }
16504 pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self {
16505 self.inner.handle_type = handle_type;
16506 self
16507 }
16508 pub fn zircon_handle(mut self, zircon_handle: zx_handle_t) -> Self {
16509 self.inner.zircon_handle = zircon_handle;
16510 self
16511 }
16512 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16513 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16514 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
16515 pub fn build(self) -> ImportSemaphoreZirconHandleInfoFUCHSIA {
16516 self.inner
16517 }
16518}
16519#[repr(C)]
16520#[cfg_attr(feature = "debug", derive(Debug))]
16521#[derive(Copy, Clone)]
16522#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreGetZirconHandleInfoFUCHSIA.html>"]
16523pub struct SemaphoreGetZirconHandleInfoFUCHSIA {
16524 pub s_type: StructureType,
16525 pub p_next: *const c_void,
16526 pub semaphore: Semaphore,
16527 pub handle_type: ExternalSemaphoreHandleTypeFlags,
16528}
16529impl ::std::default::Default for SemaphoreGetZirconHandleInfoFUCHSIA {
16530 fn default() -> Self {
16531 Self {
16532 s_type: StructureType::SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA,
16533 p_next: ::std::ptr::null(),
16534 semaphore: Semaphore::default(),
16535 handle_type: ExternalSemaphoreHandleTypeFlags::default(),
16536 }
16537 }
16538}
16539impl SemaphoreGetZirconHandleInfoFUCHSIA {
16540 pub fn builder<'a>() -> SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> {
16541 SemaphoreGetZirconHandleInfoFUCHSIABuilder {
16542 inner: Self::default(),
16543 marker: ::std::marker::PhantomData,
16544 }
16545 }
16546}
16547#[repr(transparent)]
16548pub struct SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> {
16549 inner: SemaphoreGetZirconHandleInfoFUCHSIA,
16550 marker: ::std::marker::PhantomData<&'a ()>,
16551}
16552impl<'a> ::std::ops::Deref for SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> {
16553 type Target = SemaphoreGetZirconHandleInfoFUCHSIA;
16554 fn deref(&self) -> &Self::Target {
16555 &self.inner
16556 }
16557}
16558impl<'a> ::std::ops::DerefMut for SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> {
16559 fn deref_mut(&mut self) -> &mut Self::Target {
16560 &mut self.inner
16561 }
16562}
16563impl<'a> SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> {
16564 pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
16565 self.inner.semaphore = semaphore;
16566 self
16567 }
16568 pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self {
16569 self.inner.handle_type = handle_type;
16570 self
16571 }
16572 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16573 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16574 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
16575 pub fn build(self) -> SemaphoreGetZirconHandleInfoFUCHSIA {
16576 self.inner
16577 }
16578}
16579#[repr(C)]
16580#[cfg_attr(feature = "debug", derive(Debug))]
16581#[derive(Copy, Clone)]
16582#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalFenceInfo.html>"]
16583pub struct PhysicalDeviceExternalFenceInfo {
16584 pub s_type: StructureType,
16585 pub p_next: *const c_void,
16586 pub handle_type: ExternalFenceHandleTypeFlags,
16587}
16588impl ::std::default::Default for PhysicalDeviceExternalFenceInfo {
16589 fn default() -> Self {
16590 Self {
16591 s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO,
16592 p_next: ::std::ptr::null(),
16593 handle_type: ExternalFenceHandleTypeFlags::default(),
16594 }
16595 }
16596}
16597impl PhysicalDeviceExternalFenceInfo {
16598 pub fn builder<'a>() -> PhysicalDeviceExternalFenceInfoBuilder<'a> {
16599 PhysicalDeviceExternalFenceInfoBuilder {
16600 inner: Self::default(),
16601 marker: ::std::marker::PhantomData,
16602 }
16603 }
16604}
16605#[repr(transparent)]
16606pub struct PhysicalDeviceExternalFenceInfoBuilder<'a> {
16607 inner: PhysicalDeviceExternalFenceInfo,
16608 marker: ::std::marker::PhantomData<&'a ()>,
16609}
16610impl<'a> ::std::ops::Deref for PhysicalDeviceExternalFenceInfoBuilder<'a> {
16611 type Target = PhysicalDeviceExternalFenceInfo;
16612 fn deref(&self) -> &Self::Target {
16613 &self.inner
16614 }
16615}
16616impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalFenceInfoBuilder<'a> {
16617 fn deref_mut(&mut self) -> &mut Self::Target {
16618 &mut self.inner
16619 }
16620}
16621impl<'a> PhysicalDeviceExternalFenceInfoBuilder<'a> {
16622 pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self {
16623 self.inner.handle_type = handle_type;
16624 self
16625 }
16626 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16627 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16628 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
16629 pub fn build(self) -> PhysicalDeviceExternalFenceInfo {
16630 self.inner
16631 }
16632}
16633#[repr(C)]
16634#[cfg_attr(feature = "debug", derive(Debug))]
16635#[derive(Copy, Clone)]
16636#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalFenceProperties.html>"]
16637pub struct ExternalFenceProperties {
16638 pub s_type: StructureType,
16639 pub p_next: *mut c_void,
16640 pub export_from_imported_handle_types: ExternalFenceHandleTypeFlags,
16641 pub compatible_handle_types: ExternalFenceHandleTypeFlags,
16642 pub external_fence_features: ExternalFenceFeatureFlags,
16643}
16644impl ::std::default::Default for ExternalFenceProperties {
16645 fn default() -> Self {
16646 Self {
16647 s_type: StructureType::EXTERNAL_FENCE_PROPERTIES,
16648 p_next: ::std::ptr::null_mut(),
16649 export_from_imported_handle_types: ExternalFenceHandleTypeFlags::default(),
16650 compatible_handle_types: ExternalFenceHandleTypeFlags::default(),
16651 external_fence_features: ExternalFenceFeatureFlags::default(),
16652 }
16653 }
16654}
16655impl ExternalFenceProperties {
16656 pub fn builder<'a>() -> ExternalFencePropertiesBuilder<'a> {
16657 ExternalFencePropertiesBuilder {
16658 inner: Self::default(),
16659 marker: ::std::marker::PhantomData,
16660 }
16661 }
16662}
16663#[repr(transparent)]
16664pub struct ExternalFencePropertiesBuilder<'a> {
16665 inner: ExternalFenceProperties,
16666 marker: ::std::marker::PhantomData<&'a ()>,
16667}
16668impl<'a> ::std::ops::Deref for ExternalFencePropertiesBuilder<'a> {
16669 type Target = ExternalFenceProperties;
16670 fn deref(&self) -> &Self::Target {
16671 &self.inner
16672 }
16673}
16674impl<'a> ::std::ops::DerefMut for ExternalFencePropertiesBuilder<'a> {
16675 fn deref_mut(&mut self) -> &mut Self::Target {
16676 &mut self.inner
16677 }
16678}
16679impl<'a> ExternalFencePropertiesBuilder<'a> {
16680 pub fn export_from_imported_handle_types(
16681 mut self,
16682 export_from_imported_handle_types: ExternalFenceHandleTypeFlags,
16683 ) -> Self {
16684 self.inner.export_from_imported_handle_types = export_from_imported_handle_types;
16685 self
16686 }
16687 pub fn compatible_handle_types(
16688 mut self,
16689 compatible_handle_types: ExternalFenceHandleTypeFlags,
16690 ) -> Self {
16691 self.inner.compatible_handle_types = compatible_handle_types;
16692 self
16693 }
16694 pub fn external_fence_features(
16695 mut self,
16696 external_fence_features: ExternalFenceFeatureFlags,
16697 ) -> Self {
16698 self.inner.external_fence_features = external_fence_features;
16699 self
16700 }
16701 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16702 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16703 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
16704 pub fn build(self) -> ExternalFenceProperties {
16705 self.inner
16706 }
16707}
16708#[repr(C)]
16709#[cfg_attr(feature = "debug", derive(Debug))]
16710#[derive(Copy, Clone)]
16711#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportFenceCreateInfo.html>"]
16712pub struct ExportFenceCreateInfo {
16713 pub s_type: StructureType,
16714 pub p_next: *const c_void,
16715 pub handle_types: ExternalFenceHandleTypeFlags,
16716}
16717impl ::std::default::Default for ExportFenceCreateInfo {
16718 fn default() -> Self {
16719 Self {
16720 s_type: StructureType::EXPORT_FENCE_CREATE_INFO,
16721 p_next: ::std::ptr::null(),
16722 handle_types: ExternalFenceHandleTypeFlags::default(),
16723 }
16724 }
16725}
16726impl ExportFenceCreateInfo {
16727 pub fn builder<'a>() -> ExportFenceCreateInfoBuilder<'a> {
16728 ExportFenceCreateInfoBuilder {
16729 inner: Self::default(),
16730 marker: ::std::marker::PhantomData,
16731 }
16732 }
16733}
16734#[repr(transparent)]
16735pub struct ExportFenceCreateInfoBuilder<'a> {
16736 inner: ExportFenceCreateInfo,
16737 marker: ::std::marker::PhantomData<&'a ()>,
16738}
16739unsafe impl ExtendsFenceCreateInfo for ExportFenceCreateInfoBuilder<'_> {}
16740unsafe impl ExtendsFenceCreateInfo for ExportFenceCreateInfo {}
16741impl<'a> ::std::ops::Deref for ExportFenceCreateInfoBuilder<'a> {
16742 type Target = ExportFenceCreateInfo;
16743 fn deref(&self) -> &Self::Target {
16744 &self.inner
16745 }
16746}
16747impl<'a> ::std::ops::DerefMut for ExportFenceCreateInfoBuilder<'a> {
16748 fn deref_mut(&mut self) -> &mut Self::Target {
16749 &mut self.inner
16750 }
16751}
16752impl<'a> ExportFenceCreateInfoBuilder<'a> {
16753 pub fn handle_types(mut self, handle_types: ExternalFenceHandleTypeFlags) -> Self {
16754 self.inner.handle_types = handle_types;
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."]
16760 pub fn build(self) -> ExportFenceCreateInfo {
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/VkImportFenceWin32HandleInfoKHR.html>"]
16768pub struct ImportFenceWin32HandleInfoKHR {
16769 pub s_type: StructureType,
16770 pub p_next: *const c_void,
16771 pub fence: Fence,
16772 pub flags: FenceImportFlags,
16773 pub handle_type: ExternalFenceHandleTypeFlags,
16774 pub handle: HANDLE,
16775 pub name: LPCWSTR,
16776}
16777impl ::std::default::Default for ImportFenceWin32HandleInfoKHR {
16778 fn default() -> Self {
16779 Self {
16780 s_type: StructureType::IMPORT_FENCE_WIN32_HANDLE_INFO_KHR,
16781 p_next: ::std::ptr::null(),
16782 fence: Fence::default(),
16783 flags: FenceImportFlags::default(),
16784 handle_type: ExternalFenceHandleTypeFlags::default(),
16785 handle: unsafe { ::std::mem::zeroed() },
16786 name: unsafe { ::std::mem::zeroed() },
16787 }
16788 }
16789}
16790impl ImportFenceWin32HandleInfoKHR {
16791 pub fn builder<'a>() -> ImportFenceWin32HandleInfoKHRBuilder<'a> {
16792 ImportFenceWin32HandleInfoKHRBuilder {
16793 inner: Self::default(),
16794 marker: ::std::marker::PhantomData,
16795 }
16796 }
16797}
16798#[repr(transparent)]
16799pub struct ImportFenceWin32HandleInfoKHRBuilder<'a> {
16800 inner: ImportFenceWin32HandleInfoKHR,
16801 marker: ::std::marker::PhantomData<&'a ()>,
16802}
16803impl<'a> ::std::ops::Deref for ImportFenceWin32HandleInfoKHRBuilder<'a> {
16804 type Target = ImportFenceWin32HandleInfoKHR;
16805 fn deref(&self) -> &Self::Target {
16806 &self.inner
16807 }
16808}
16809impl<'a> ::std::ops::DerefMut for ImportFenceWin32HandleInfoKHRBuilder<'a> {
16810 fn deref_mut(&mut self) -> &mut Self::Target {
16811 &mut self.inner
16812 }
16813}
16814impl<'a> ImportFenceWin32HandleInfoKHRBuilder<'a> {
16815 pub fn fence(mut self, fence: Fence) -> Self {
16816 self.inner.fence = fence;
16817 self
16818 }
16819 pub fn flags(mut self, flags: FenceImportFlags) -> Self {
16820 self.inner.flags = flags;
16821 self
16822 }
16823 pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self {
16824 self.inner.handle_type = handle_type;
16825 self
16826 }
16827 pub fn handle(mut self, handle: HANDLE) -> Self {
16828 self.inner.handle = handle;
16829 self
16830 }
16831 pub fn name(mut self, name: LPCWSTR) -> Self {
16832 self.inner.name = name;
16833 self
16834 }
16835 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16836 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16837 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
16838 pub fn build(self) -> ImportFenceWin32HandleInfoKHR {
16839 self.inner
16840 }
16841}
16842#[repr(C)]
16843#[cfg_attr(feature = "debug", derive(Debug))]
16844#[derive(Copy, Clone)]
16845#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportFenceWin32HandleInfoKHR.html>"]
16846pub struct ExportFenceWin32HandleInfoKHR {
16847 pub s_type: StructureType,
16848 pub p_next: *const c_void,
16849 pub p_attributes: *const SECURITY_ATTRIBUTES,
16850 pub dw_access: DWORD,
16851 pub name: LPCWSTR,
16852}
16853impl ::std::default::Default for ExportFenceWin32HandleInfoKHR {
16854 fn default() -> Self {
16855 Self {
16856 s_type: StructureType::EXPORT_FENCE_WIN32_HANDLE_INFO_KHR,
16857 p_next: ::std::ptr::null(),
16858 p_attributes: ::std::ptr::null(),
16859 dw_access: DWORD::default(),
16860 name: unsafe { ::std::mem::zeroed() },
16861 }
16862 }
16863}
16864impl ExportFenceWin32HandleInfoKHR {
16865 pub fn builder<'a>() -> ExportFenceWin32HandleInfoKHRBuilder<'a> {
16866 ExportFenceWin32HandleInfoKHRBuilder {
16867 inner: Self::default(),
16868 marker: ::std::marker::PhantomData,
16869 }
16870 }
16871}
16872#[repr(transparent)]
16873pub struct ExportFenceWin32HandleInfoKHRBuilder<'a> {
16874 inner: ExportFenceWin32HandleInfoKHR,
16875 marker: ::std::marker::PhantomData<&'a ()>,
16876}
16877unsafe impl ExtendsFenceCreateInfo for ExportFenceWin32HandleInfoKHRBuilder<'_> {}
16878unsafe impl ExtendsFenceCreateInfo for ExportFenceWin32HandleInfoKHR {}
16879impl<'a> ::std::ops::Deref for ExportFenceWin32HandleInfoKHRBuilder<'a> {
16880 type Target = ExportFenceWin32HandleInfoKHR;
16881 fn deref(&self) -> &Self::Target {
16882 &self.inner
16883 }
16884}
16885impl<'a> ::std::ops::DerefMut for ExportFenceWin32HandleInfoKHRBuilder<'a> {
16886 fn deref_mut(&mut self) -> &mut Self::Target {
16887 &mut self.inner
16888 }
16889}
16890impl<'a> ExportFenceWin32HandleInfoKHRBuilder<'a> {
16891 pub fn attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self {
16892 self.inner.p_attributes = attributes;
16893 self
16894 }
16895 pub fn dw_access(mut self, dw_access: DWORD) -> Self {
16896 self.inner.dw_access = dw_access;
16897 self
16898 }
16899 pub fn name(mut self, name: LPCWSTR) -> Self {
16900 self.inner.name = name;
16901 self
16902 }
16903 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16904 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16905 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
16906 pub fn build(self) -> ExportFenceWin32HandleInfoKHR {
16907 self.inner
16908 }
16909}
16910#[repr(C)]
16911#[cfg_attr(feature = "debug", derive(Debug))]
16912#[derive(Copy, Clone)]
16913#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFenceGetWin32HandleInfoKHR.html>"]
16914pub struct FenceGetWin32HandleInfoKHR {
16915 pub s_type: StructureType,
16916 pub p_next: *const c_void,
16917 pub fence: Fence,
16918 pub handle_type: ExternalFenceHandleTypeFlags,
16919}
16920impl ::std::default::Default for FenceGetWin32HandleInfoKHR {
16921 fn default() -> Self {
16922 Self {
16923 s_type: StructureType::FENCE_GET_WIN32_HANDLE_INFO_KHR,
16924 p_next: ::std::ptr::null(),
16925 fence: Fence::default(),
16926 handle_type: ExternalFenceHandleTypeFlags::default(),
16927 }
16928 }
16929}
16930impl FenceGetWin32HandleInfoKHR {
16931 pub fn builder<'a>() -> FenceGetWin32HandleInfoKHRBuilder<'a> {
16932 FenceGetWin32HandleInfoKHRBuilder {
16933 inner: Self::default(),
16934 marker: ::std::marker::PhantomData,
16935 }
16936 }
16937}
16938#[repr(transparent)]
16939pub struct FenceGetWin32HandleInfoKHRBuilder<'a> {
16940 inner: FenceGetWin32HandleInfoKHR,
16941 marker: ::std::marker::PhantomData<&'a ()>,
16942}
16943impl<'a> ::std::ops::Deref for FenceGetWin32HandleInfoKHRBuilder<'a> {
16944 type Target = FenceGetWin32HandleInfoKHR;
16945 fn deref(&self) -> &Self::Target {
16946 &self.inner
16947 }
16948}
16949impl<'a> ::std::ops::DerefMut for FenceGetWin32HandleInfoKHRBuilder<'a> {
16950 fn deref_mut(&mut self) -> &mut Self::Target {
16951 &mut self.inner
16952 }
16953}
16954impl<'a> FenceGetWin32HandleInfoKHRBuilder<'a> {
16955 pub fn fence(mut self, fence: Fence) -> Self {
16956 self.inner.fence = fence;
16957 self
16958 }
16959 pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self {
16960 self.inner.handle_type = handle_type;
16961 self
16962 }
16963 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16964 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16965 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
16966 pub fn build(self) -> FenceGetWin32HandleInfoKHR {
16967 self.inner
16968 }
16969}
16970#[repr(C)]
16971#[cfg_attr(feature = "debug", derive(Debug))]
16972#[derive(Copy, Clone)]
16973#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportFenceFdInfoKHR.html>"]
16974pub struct ImportFenceFdInfoKHR {
16975 pub s_type: StructureType,
16976 pub p_next: *const c_void,
16977 pub fence: Fence,
16978 pub flags: FenceImportFlags,
16979 pub handle_type: ExternalFenceHandleTypeFlags,
16980 pub fd: c_int,
16981}
16982impl ::std::default::Default for ImportFenceFdInfoKHR {
16983 fn default() -> Self {
16984 Self {
16985 s_type: StructureType::IMPORT_FENCE_FD_INFO_KHR,
16986 p_next: ::std::ptr::null(),
16987 fence: Fence::default(),
16988 flags: FenceImportFlags::default(),
16989 handle_type: ExternalFenceHandleTypeFlags::default(),
16990 fd: c_int::default(),
16991 }
16992 }
16993}
16994impl ImportFenceFdInfoKHR {
16995 pub fn builder<'a>() -> ImportFenceFdInfoKHRBuilder<'a> {
16996 ImportFenceFdInfoKHRBuilder {
16997 inner: Self::default(),
16998 marker: ::std::marker::PhantomData,
16999 }
17000 }
17001}
17002#[repr(transparent)]
17003pub struct ImportFenceFdInfoKHRBuilder<'a> {
17004 inner: ImportFenceFdInfoKHR,
17005 marker: ::std::marker::PhantomData<&'a ()>,
17006}
17007impl<'a> ::std::ops::Deref for ImportFenceFdInfoKHRBuilder<'a> {
17008 type Target = ImportFenceFdInfoKHR;
17009 fn deref(&self) -> &Self::Target {
17010 &self.inner
17011 }
17012}
17013impl<'a> ::std::ops::DerefMut for ImportFenceFdInfoKHRBuilder<'a> {
17014 fn deref_mut(&mut self) -> &mut Self::Target {
17015 &mut self.inner
17016 }
17017}
17018impl<'a> ImportFenceFdInfoKHRBuilder<'a> {
17019 pub fn fence(mut self, fence: Fence) -> Self {
17020 self.inner.fence = fence;
17021 self
17022 }
17023 pub fn flags(mut self, flags: FenceImportFlags) -> Self {
17024 self.inner.flags = flags;
17025 self
17026 }
17027 pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self {
17028 self.inner.handle_type = handle_type;
17029 self
17030 }
17031 pub fn fd(mut self, fd: c_int) -> Self {
17032 self.inner.fd = fd;
17033 self
17034 }
17035 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17036 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17037 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17038 pub fn build(self) -> ImportFenceFdInfoKHR {
17039 self.inner
17040 }
17041}
17042#[repr(C)]
17043#[cfg_attr(feature = "debug", derive(Debug))]
17044#[derive(Copy, Clone)]
17045#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFenceGetFdInfoKHR.html>"]
17046pub struct FenceGetFdInfoKHR {
17047 pub s_type: StructureType,
17048 pub p_next: *const c_void,
17049 pub fence: Fence,
17050 pub handle_type: ExternalFenceHandleTypeFlags,
17051}
17052impl ::std::default::Default for FenceGetFdInfoKHR {
17053 fn default() -> Self {
17054 Self {
17055 s_type: StructureType::FENCE_GET_FD_INFO_KHR,
17056 p_next: ::std::ptr::null(),
17057 fence: Fence::default(),
17058 handle_type: ExternalFenceHandleTypeFlags::default(),
17059 }
17060 }
17061}
17062impl FenceGetFdInfoKHR {
17063 pub fn builder<'a>() -> FenceGetFdInfoKHRBuilder<'a> {
17064 FenceGetFdInfoKHRBuilder {
17065 inner: Self::default(),
17066 marker: ::std::marker::PhantomData,
17067 }
17068 }
17069}
17070#[repr(transparent)]
17071pub struct FenceGetFdInfoKHRBuilder<'a> {
17072 inner: FenceGetFdInfoKHR,
17073 marker: ::std::marker::PhantomData<&'a ()>,
17074}
17075impl<'a> ::std::ops::Deref for FenceGetFdInfoKHRBuilder<'a> {
17076 type Target = FenceGetFdInfoKHR;
17077 fn deref(&self) -> &Self::Target {
17078 &self.inner
17079 }
17080}
17081impl<'a> ::std::ops::DerefMut for FenceGetFdInfoKHRBuilder<'a> {
17082 fn deref_mut(&mut self) -> &mut Self::Target {
17083 &mut self.inner
17084 }
17085}
17086impl<'a> FenceGetFdInfoKHRBuilder<'a> {
17087 pub fn fence(mut self, fence: Fence) -> Self {
17088 self.inner.fence = fence;
17089 self
17090 }
17091 pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self {
17092 self.inner.handle_type = handle_type;
17093 self
17094 }
17095 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17096 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17097 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17098 pub fn build(self) -> FenceGetFdInfoKHR {
17099 self.inner
17100 }
17101}
17102#[repr(C)]
17103#[cfg_attr(feature = "debug", derive(Debug))]
17104#[derive(Copy, Clone)]
17105#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiviewFeatures.html>"]
17106pub struct PhysicalDeviceMultiviewFeatures {
17107 pub s_type: StructureType,
17108 pub p_next: *mut c_void,
17109 pub multiview: Bool32,
17110 pub multiview_geometry_shader: Bool32,
17111 pub multiview_tessellation_shader: Bool32,
17112}
17113impl ::std::default::Default for PhysicalDeviceMultiviewFeatures {
17114 fn default() -> Self {
17115 Self {
17116 s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_FEATURES,
17117 p_next: ::std::ptr::null_mut(),
17118 multiview: Bool32::default(),
17119 multiview_geometry_shader: Bool32::default(),
17120 multiview_tessellation_shader: Bool32::default(),
17121 }
17122 }
17123}
17124impl PhysicalDeviceMultiviewFeatures {
17125 pub fn builder<'a>() -> PhysicalDeviceMultiviewFeaturesBuilder<'a> {
17126 PhysicalDeviceMultiviewFeaturesBuilder {
17127 inner: Self::default(),
17128 marker: ::std::marker::PhantomData,
17129 }
17130 }
17131}
17132#[repr(transparent)]
17133pub struct PhysicalDeviceMultiviewFeaturesBuilder<'a> {
17134 inner: PhysicalDeviceMultiviewFeatures,
17135 marker: ::std::marker::PhantomData<&'a ()>,
17136}
17137unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiviewFeaturesBuilder<'_> {}
17138unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiviewFeatures {}
17139unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewFeaturesBuilder<'_> {}
17140unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewFeatures {}
17141impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewFeaturesBuilder<'a> {
17142 type Target = PhysicalDeviceMultiviewFeatures;
17143 fn deref(&self) -> &Self::Target {
17144 &self.inner
17145 }
17146}
17147impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewFeaturesBuilder<'a> {
17148 fn deref_mut(&mut self) -> &mut Self::Target {
17149 &mut self.inner
17150 }
17151}
17152impl<'a> PhysicalDeviceMultiviewFeaturesBuilder<'a> {
17153 pub fn multiview(mut self, multiview: bool) -> Self {
17154 self.inner.multiview = multiview.into();
17155 self
17156 }
17157 pub fn multiview_geometry_shader(mut self, multiview_geometry_shader: bool) -> Self {
17158 self.inner.multiview_geometry_shader = multiview_geometry_shader.into();
17159 self
17160 }
17161 pub fn multiview_tessellation_shader(mut self, multiview_tessellation_shader: bool) -> Self {
17162 self.inner.multiview_tessellation_shader = multiview_tessellation_shader.into();
17163 self
17164 }
17165 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17166 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17167 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17168 pub fn build(self) -> PhysicalDeviceMultiviewFeatures {
17169 self.inner
17170 }
17171}
17172#[repr(C)]
17173#[cfg_attr(feature = "debug", derive(Debug))]
17174#[derive(Copy, Clone)]
17175#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiviewProperties.html>"]
17176pub struct PhysicalDeviceMultiviewProperties {
17177 pub s_type: StructureType,
17178 pub p_next: *mut c_void,
17179 pub max_multiview_view_count: u32,
17180 pub max_multiview_instance_index: u32,
17181}
17182impl ::std::default::Default for PhysicalDeviceMultiviewProperties {
17183 fn default() -> Self {
17184 Self {
17185 s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES,
17186 p_next: ::std::ptr::null_mut(),
17187 max_multiview_view_count: u32::default(),
17188 max_multiview_instance_index: u32::default(),
17189 }
17190 }
17191}
17192impl PhysicalDeviceMultiviewProperties {
17193 pub fn builder<'a>() -> PhysicalDeviceMultiviewPropertiesBuilder<'a> {
17194 PhysicalDeviceMultiviewPropertiesBuilder {
17195 inner: Self::default(),
17196 marker: ::std::marker::PhantomData,
17197 }
17198 }
17199}
17200#[repr(transparent)]
17201pub struct PhysicalDeviceMultiviewPropertiesBuilder<'a> {
17202 inner: PhysicalDeviceMultiviewProperties,
17203 marker: ::std::marker::PhantomData<&'a ()>,
17204}
17205unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiviewPropertiesBuilder<'_> {}
17206unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiviewProperties {}
17207impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewPropertiesBuilder<'a> {
17208 type Target = PhysicalDeviceMultiviewProperties;
17209 fn deref(&self) -> &Self::Target {
17210 &self.inner
17211 }
17212}
17213impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewPropertiesBuilder<'a> {
17214 fn deref_mut(&mut self) -> &mut Self::Target {
17215 &mut self.inner
17216 }
17217}
17218impl<'a> PhysicalDeviceMultiviewPropertiesBuilder<'a> {
17219 pub fn max_multiview_view_count(mut self, max_multiview_view_count: u32) -> Self {
17220 self.inner.max_multiview_view_count = max_multiview_view_count;
17221 self
17222 }
17223 pub fn max_multiview_instance_index(mut self, max_multiview_instance_index: u32) -> Self {
17224 self.inner.max_multiview_instance_index = max_multiview_instance_index;
17225 self
17226 }
17227 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17228 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17229 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17230 pub fn build(self) -> PhysicalDeviceMultiviewProperties {
17231 self.inner
17232 }
17233}
17234#[repr(C)]
17235#[cfg_attr(feature = "debug", derive(Debug))]
17236#[derive(Copy, Clone)]
17237#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassMultiviewCreateInfo.html>"]
17238pub struct RenderPassMultiviewCreateInfo {
17239 pub s_type: StructureType,
17240 pub p_next: *const c_void,
17241 pub subpass_count: u32,
17242 pub p_view_masks: *const u32,
17243 pub dependency_count: u32,
17244 pub p_view_offsets: *const i32,
17245 pub correlation_mask_count: u32,
17246 pub p_correlation_masks: *const u32,
17247}
17248impl ::std::default::Default for RenderPassMultiviewCreateInfo {
17249 fn default() -> Self {
17250 Self {
17251 s_type: StructureType::RENDER_PASS_MULTIVIEW_CREATE_INFO,
17252 p_next: ::std::ptr::null(),
17253 subpass_count: u32::default(),
17254 p_view_masks: ::std::ptr::null(),
17255 dependency_count: u32::default(),
17256 p_view_offsets: ::std::ptr::null(),
17257 correlation_mask_count: u32::default(),
17258 p_correlation_masks: ::std::ptr::null(),
17259 }
17260 }
17261}
17262impl RenderPassMultiviewCreateInfo {
17263 pub fn builder<'a>() -> RenderPassMultiviewCreateInfoBuilder<'a> {
17264 RenderPassMultiviewCreateInfoBuilder {
17265 inner: Self::default(),
17266 marker: ::std::marker::PhantomData,
17267 }
17268 }
17269}
17270#[repr(transparent)]
17271pub struct RenderPassMultiviewCreateInfoBuilder<'a> {
17272 inner: RenderPassMultiviewCreateInfo,
17273 marker: ::std::marker::PhantomData<&'a ()>,
17274}
17275unsafe impl ExtendsRenderPassCreateInfo for RenderPassMultiviewCreateInfoBuilder<'_> {}
17276unsafe impl ExtendsRenderPassCreateInfo for RenderPassMultiviewCreateInfo {}
17277impl<'a> ::std::ops::Deref for RenderPassMultiviewCreateInfoBuilder<'a> {
17278 type Target = RenderPassMultiviewCreateInfo;
17279 fn deref(&self) -> &Self::Target {
17280 &self.inner
17281 }
17282}
17283impl<'a> ::std::ops::DerefMut for RenderPassMultiviewCreateInfoBuilder<'a> {
17284 fn deref_mut(&mut self) -> &mut Self::Target {
17285 &mut self.inner
17286 }
17287}
17288impl<'a> RenderPassMultiviewCreateInfoBuilder<'a> {
17289 pub fn view_masks(mut self, view_masks: &'a [u32]) -> Self {
17290 self.inner.subpass_count = view_masks.len() as _;
17291 self.inner.p_view_masks = view_masks.as_ptr();
17292 self
17293 }
17294 pub fn view_offsets(mut self, view_offsets: &'a [i32]) -> Self {
17295 self.inner.dependency_count = view_offsets.len() as _;
17296 self.inner.p_view_offsets = view_offsets.as_ptr();
17297 self
17298 }
17299 pub fn correlation_masks(mut self, correlation_masks: &'a [u32]) -> Self {
17300 self.inner.correlation_mask_count = correlation_masks.len() as _;
17301 self.inner.p_correlation_masks = correlation_masks.as_ptr();
17302 self
17303 }
17304 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17305 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17306 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17307 pub fn build(self) -> RenderPassMultiviewCreateInfo {
17308 self.inner
17309 }
17310}
17311#[repr(C)]
17312#[cfg_attr(feature = "debug", derive(Debug))]
17313#[derive(Copy, Clone)]
17314#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceCapabilities2EXT.html>"]
17315pub struct SurfaceCapabilities2EXT {
17316 pub s_type: StructureType,
17317 pub p_next: *mut c_void,
17318 pub min_image_count: u32,
17319 pub max_image_count: u32,
17320 pub current_extent: Extent2D,
17321 pub min_image_extent: Extent2D,
17322 pub max_image_extent: Extent2D,
17323 pub max_image_array_layers: u32,
17324 pub supported_transforms: SurfaceTransformFlagsKHR,
17325 pub current_transform: SurfaceTransformFlagsKHR,
17326 pub supported_composite_alpha: CompositeAlphaFlagsKHR,
17327 pub supported_usage_flags: ImageUsageFlags,
17328 pub supported_surface_counters: SurfaceCounterFlagsEXT,
17329}
17330impl ::std::default::Default for SurfaceCapabilities2EXT {
17331 fn default() -> Self {
17332 Self {
17333 s_type: StructureType::SURFACE_CAPABILITIES_2_EXT,
17334 p_next: ::std::ptr::null_mut(),
17335 min_image_count: u32::default(),
17336 max_image_count: u32::default(),
17337 current_extent: Extent2D::default(),
17338 min_image_extent: Extent2D::default(),
17339 max_image_extent: Extent2D::default(),
17340 max_image_array_layers: u32::default(),
17341 supported_transforms: SurfaceTransformFlagsKHR::default(),
17342 current_transform: SurfaceTransformFlagsKHR::default(),
17343 supported_composite_alpha: CompositeAlphaFlagsKHR::default(),
17344 supported_usage_flags: ImageUsageFlags::default(),
17345 supported_surface_counters: SurfaceCounterFlagsEXT::default(),
17346 }
17347 }
17348}
17349impl SurfaceCapabilities2EXT {
17350 pub fn builder<'a>() -> SurfaceCapabilities2EXTBuilder<'a> {
17351 SurfaceCapabilities2EXTBuilder {
17352 inner: Self::default(),
17353 marker: ::std::marker::PhantomData,
17354 }
17355 }
17356}
17357#[repr(transparent)]
17358pub struct SurfaceCapabilities2EXTBuilder<'a> {
17359 inner: SurfaceCapabilities2EXT,
17360 marker: ::std::marker::PhantomData<&'a ()>,
17361}
17362impl<'a> ::std::ops::Deref for SurfaceCapabilities2EXTBuilder<'a> {
17363 type Target = SurfaceCapabilities2EXT;
17364 fn deref(&self) -> &Self::Target {
17365 &self.inner
17366 }
17367}
17368impl<'a> ::std::ops::DerefMut for SurfaceCapabilities2EXTBuilder<'a> {
17369 fn deref_mut(&mut self) -> &mut Self::Target {
17370 &mut self.inner
17371 }
17372}
17373impl<'a> SurfaceCapabilities2EXTBuilder<'a> {
17374 pub fn min_image_count(mut self, min_image_count: u32) -> Self {
17375 self.inner.min_image_count = min_image_count;
17376 self
17377 }
17378 pub fn max_image_count(mut self, max_image_count: u32) -> Self {
17379 self.inner.max_image_count = max_image_count;
17380 self
17381 }
17382 pub fn current_extent(mut self, current_extent: Extent2D) -> Self {
17383 self.inner.current_extent = current_extent;
17384 self
17385 }
17386 pub fn min_image_extent(mut self, min_image_extent: Extent2D) -> Self {
17387 self.inner.min_image_extent = min_image_extent;
17388 self
17389 }
17390 pub fn max_image_extent(mut self, max_image_extent: Extent2D) -> Self {
17391 self.inner.max_image_extent = max_image_extent;
17392 self
17393 }
17394 pub fn max_image_array_layers(mut self, max_image_array_layers: u32) -> Self {
17395 self.inner.max_image_array_layers = max_image_array_layers;
17396 self
17397 }
17398 pub fn supported_transforms(mut self, supported_transforms: SurfaceTransformFlagsKHR) -> Self {
17399 self.inner.supported_transforms = supported_transforms;
17400 self
17401 }
17402 pub fn current_transform(mut self, current_transform: SurfaceTransformFlagsKHR) -> Self {
17403 self.inner.current_transform = current_transform;
17404 self
17405 }
17406 pub fn supported_composite_alpha(
17407 mut self,
17408 supported_composite_alpha: CompositeAlphaFlagsKHR,
17409 ) -> Self {
17410 self.inner.supported_composite_alpha = supported_composite_alpha;
17411 self
17412 }
17413 pub fn supported_usage_flags(mut self, supported_usage_flags: ImageUsageFlags) -> Self {
17414 self.inner.supported_usage_flags = supported_usage_flags;
17415 self
17416 }
17417 pub fn supported_surface_counters(
17418 mut self,
17419 supported_surface_counters: SurfaceCounterFlagsEXT,
17420 ) -> Self {
17421 self.inner.supported_surface_counters = supported_surface_counters;
17422 self
17423 }
17424 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17425 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17426 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17427 pub fn build(self) -> SurfaceCapabilities2EXT {
17428 self.inner
17429 }
17430}
17431#[repr(C)]
17432#[cfg_attr(feature = "debug", derive(Debug))]
17433#[derive(Copy, Clone)]
17434#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPowerInfoEXT.html>"]
17435pub struct DisplayPowerInfoEXT {
17436 pub s_type: StructureType,
17437 pub p_next: *const c_void,
17438 pub power_state: DisplayPowerStateEXT,
17439}
17440impl ::std::default::Default for DisplayPowerInfoEXT {
17441 fn default() -> Self {
17442 Self {
17443 s_type: StructureType::DISPLAY_POWER_INFO_EXT,
17444 p_next: ::std::ptr::null(),
17445 power_state: DisplayPowerStateEXT::default(),
17446 }
17447 }
17448}
17449impl DisplayPowerInfoEXT {
17450 pub fn builder<'a>() -> DisplayPowerInfoEXTBuilder<'a> {
17451 DisplayPowerInfoEXTBuilder {
17452 inner: Self::default(),
17453 marker: ::std::marker::PhantomData,
17454 }
17455 }
17456}
17457#[repr(transparent)]
17458pub struct DisplayPowerInfoEXTBuilder<'a> {
17459 inner: DisplayPowerInfoEXT,
17460 marker: ::std::marker::PhantomData<&'a ()>,
17461}
17462impl<'a> ::std::ops::Deref for DisplayPowerInfoEXTBuilder<'a> {
17463 type Target = DisplayPowerInfoEXT;
17464 fn deref(&self) -> &Self::Target {
17465 &self.inner
17466 }
17467}
17468impl<'a> ::std::ops::DerefMut for DisplayPowerInfoEXTBuilder<'a> {
17469 fn deref_mut(&mut self) -> &mut Self::Target {
17470 &mut self.inner
17471 }
17472}
17473impl<'a> DisplayPowerInfoEXTBuilder<'a> {
17474 pub fn power_state(mut self, power_state: DisplayPowerStateEXT) -> Self {
17475 self.inner.power_state = power_state;
17476 self
17477 }
17478 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17479 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17480 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17481 pub fn build(self) -> DisplayPowerInfoEXT {
17482 self.inner
17483 }
17484}
17485#[repr(C)]
17486#[cfg_attr(feature = "debug", derive(Debug))]
17487#[derive(Copy, Clone)]
17488#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceEventInfoEXT.html>"]
17489pub struct DeviceEventInfoEXT {
17490 pub s_type: StructureType,
17491 pub p_next: *const c_void,
17492 pub device_event: DeviceEventTypeEXT,
17493}
17494impl ::std::default::Default for DeviceEventInfoEXT {
17495 fn default() -> Self {
17496 Self {
17497 s_type: StructureType::DEVICE_EVENT_INFO_EXT,
17498 p_next: ::std::ptr::null(),
17499 device_event: DeviceEventTypeEXT::default(),
17500 }
17501 }
17502}
17503impl DeviceEventInfoEXT {
17504 pub fn builder<'a>() -> DeviceEventInfoEXTBuilder<'a> {
17505 DeviceEventInfoEXTBuilder {
17506 inner: Self::default(),
17507 marker: ::std::marker::PhantomData,
17508 }
17509 }
17510}
17511#[repr(transparent)]
17512pub struct DeviceEventInfoEXTBuilder<'a> {
17513 inner: DeviceEventInfoEXT,
17514 marker: ::std::marker::PhantomData<&'a ()>,
17515}
17516impl<'a> ::std::ops::Deref for DeviceEventInfoEXTBuilder<'a> {
17517 type Target = DeviceEventInfoEXT;
17518 fn deref(&self) -> &Self::Target {
17519 &self.inner
17520 }
17521}
17522impl<'a> ::std::ops::DerefMut for DeviceEventInfoEXTBuilder<'a> {
17523 fn deref_mut(&mut self) -> &mut Self::Target {
17524 &mut self.inner
17525 }
17526}
17527impl<'a> DeviceEventInfoEXTBuilder<'a> {
17528 pub fn device_event(mut self, device_event: DeviceEventTypeEXT) -> Self {
17529 self.inner.device_event = device_event;
17530 self
17531 }
17532 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17533 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17534 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17535 pub fn build(self) -> DeviceEventInfoEXT {
17536 self.inner
17537 }
17538}
17539#[repr(C)]
17540#[cfg_attr(feature = "debug", derive(Debug))]
17541#[derive(Copy, Clone)]
17542#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayEventInfoEXT.html>"]
17543pub struct DisplayEventInfoEXT {
17544 pub s_type: StructureType,
17545 pub p_next: *const c_void,
17546 pub display_event: DisplayEventTypeEXT,
17547}
17548impl ::std::default::Default for DisplayEventInfoEXT {
17549 fn default() -> Self {
17550 Self {
17551 s_type: StructureType::DISPLAY_EVENT_INFO_EXT,
17552 p_next: ::std::ptr::null(),
17553 display_event: DisplayEventTypeEXT::default(),
17554 }
17555 }
17556}
17557impl DisplayEventInfoEXT {
17558 pub fn builder<'a>() -> DisplayEventInfoEXTBuilder<'a> {
17559 DisplayEventInfoEXTBuilder {
17560 inner: Self::default(),
17561 marker: ::std::marker::PhantomData,
17562 }
17563 }
17564}
17565#[repr(transparent)]
17566pub struct DisplayEventInfoEXTBuilder<'a> {
17567 inner: DisplayEventInfoEXT,
17568 marker: ::std::marker::PhantomData<&'a ()>,
17569}
17570impl<'a> ::std::ops::Deref for DisplayEventInfoEXTBuilder<'a> {
17571 type Target = DisplayEventInfoEXT;
17572 fn deref(&self) -> &Self::Target {
17573 &self.inner
17574 }
17575}
17576impl<'a> ::std::ops::DerefMut for DisplayEventInfoEXTBuilder<'a> {
17577 fn deref_mut(&mut self) -> &mut Self::Target {
17578 &mut self.inner
17579 }
17580}
17581impl<'a> DisplayEventInfoEXTBuilder<'a> {
17582 pub fn display_event(mut self, display_event: DisplayEventTypeEXT) -> Self {
17583 self.inner.display_event = display_event;
17584 self
17585 }
17586 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17587 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17588 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17589 pub fn build(self) -> DisplayEventInfoEXT {
17590 self.inner
17591 }
17592}
17593#[repr(C)]
17594#[cfg_attr(feature = "debug", derive(Debug))]
17595#[derive(Copy, Clone)]
17596#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainCounterCreateInfoEXT.html>"]
17597pub struct SwapchainCounterCreateInfoEXT {
17598 pub s_type: StructureType,
17599 pub p_next: *const c_void,
17600 pub surface_counters: SurfaceCounterFlagsEXT,
17601}
17602impl ::std::default::Default for SwapchainCounterCreateInfoEXT {
17603 fn default() -> Self {
17604 Self {
17605 s_type: StructureType::SWAPCHAIN_COUNTER_CREATE_INFO_EXT,
17606 p_next: ::std::ptr::null(),
17607 surface_counters: SurfaceCounterFlagsEXT::default(),
17608 }
17609 }
17610}
17611impl SwapchainCounterCreateInfoEXT {
17612 pub fn builder<'a>() -> SwapchainCounterCreateInfoEXTBuilder<'a> {
17613 SwapchainCounterCreateInfoEXTBuilder {
17614 inner: Self::default(),
17615 marker: ::std::marker::PhantomData,
17616 }
17617 }
17618}
17619#[repr(transparent)]
17620pub struct SwapchainCounterCreateInfoEXTBuilder<'a> {
17621 inner: SwapchainCounterCreateInfoEXT,
17622 marker: ::std::marker::PhantomData<&'a ()>,
17623}
17624unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainCounterCreateInfoEXTBuilder<'_> {}
17625unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainCounterCreateInfoEXT {}
17626impl<'a> ::std::ops::Deref for SwapchainCounterCreateInfoEXTBuilder<'a> {
17627 type Target = SwapchainCounterCreateInfoEXT;
17628 fn deref(&self) -> &Self::Target {
17629 &self.inner
17630 }
17631}
17632impl<'a> ::std::ops::DerefMut for SwapchainCounterCreateInfoEXTBuilder<'a> {
17633 fn deref_mut(&mut self) -> &mut Self::Target {
17634 &mut self.inner
17635 }
17636}
17637impl<'a> SwapchainCounterCreateInfoEXTBuilder<'a> {
17638 pub fn surface_counters(mut self, surface_counters: SurfaceCounterFlagsEXT) -> Self {
17639 self.inner.surface_counters = surface_counters;
17640 self
17641 }
17642 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17643 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17644 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17645 pub fn build(self) -> SwapchainCounterCreateInfoEXT {
17646 self.inner
17647 }
17648}
17649#[repr(C)]
17650#[cfg_attr(feature = "debug", derive(Debug))]
17651#[derive(Copy, Clone)]
17652#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceGroupProperties.html>"]
17653pub struct PhysicalDeviceGroupProperties {
17654 pub s_type: StructureType,
17655 pub p_next: *mut c_void,
17656 pub physical_device_count: u32,
17657 pub physical_devices: [PhysicalDevice; MAX_DEVICE_GROUP_SIZE],
17658 pub subset_allocation: Bool32,
17659}
17660impl ::std::default::Default for PhysicalDeviceGroupProperties {
17661 fn default() -> Self {
17662 Self {
17663 s_type: StructureType::PHYSICAL_DEVICE_GROUP_PROPERTIES,
17664 p_next: ::std::ptr::null_mut(),
17665 physical_device_count: u32::default(),
17666 physical_devices: unsafe { ::std::mem::zeroed() },
17667 subset_allocation: Bool32::default(),
17668 }
17669 }
17670}
17671impl PhysicalDeviceGroupProperties {
17672 pub fn builder<'a>() -> PhysicalDeviceGroupPropertiesBuilder<'a> {
17673 PhysicalDeviceGroupPropertiesBuilder {
17674 inner: Self::default(),
17675 marker: ::std::marker::PhantomData,
17676 }
17677 }
17678}
17679#[repr(transparent)]
17680pub struct PhysicalDeviceGroupPropertiesBuilder<'a> {
17681 inner: PhysicalDeviceGroupProperties,
17682 marker: ::std::marker::PhantomData<&'a ()>,
17683}
17684impl<'a> ::std::ops::Deref for PhysicalDeviceGroupPropertiesBuilder<'a> {
17685 type Target = PhysicalDeviceGroupProperties;
17686 fn deref(&self) -> &Self::Target {
17687 &self.inner
17688 }
17689}
17690impl<'a> ::std::ops::DerefMut for PhysicalDeviceGroupPropertiesBuilder<'a> {
17691 fn deref_mut(&mut self) -> &mut Self::Target {
17692 &mut self.inner
17693 }
17694}
17695impl<'a> PhysicalDeviceGroupPropertiesBuilder<'a> {
17696 pub fn physical_device_count(mut self, physical_device_count: u32) -> Self {
17697 self.inner.physical_device_count = physical_device_count;
17698 self
17699 }
17700 pub fn physical_devices(
17701 mut self,
17702 physical_devices: [PhysicalDevice; MAX_DEVICE_GROUP_SIZE],
17703 ) -> Self {
17704 self.inner.physical_devices = physical_devices;
17705 self
17706 }
17707 pub fn subset_allocation(mut self, subset_allocation: bool) -> Self {
17708 self.inner.subset_allocation = subset_allocation.into();
17709 self
17710 }
17711 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17712 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17713 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17714 pub fn build(self) -> PhysicalDeviceGroupProperties {
17715 self.inner
17716 }
17717}
17718#[repr(C)]
17719#[cfg_attr(feature = "debug", derive(Debug))]
17720#[derive(Copy, Clone)]
17721#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryAllocateFlagsInfo.html>"]
17722pub struct MemoryAllocateFlagsInfo {
17723 pub s_type: StructureType,
17724 pub p_next: *const c_void,
17725 pub flags: MemoryAllocateFlags,
17726 pub device_mask: u32,
17727}
17728impl ::std::default::Default for MemoryAllocateFlagsInfo {
17729 fn default() -> Self {
17730 Self {
17731 s_type: StructureType::MEMORY_ALLOCATE_FLAGS_INFO,
17732 p_next: ::std::ptr::null(),
17733 flags: MemoryAllocateFlags::default(),
17734 device_mask: u32::default(),
17735 }
17736 }
17737}
17738impl MemoryAllocateFlagsInfo {
17739 pub fn builder<'a>() -> MemoryAllocateFlagsInfoBuilder<'a> {
17740 MemoryAllocateFlagsInfoBuilder {
17741 inner: Self::default(),
17742 marker: ::std::marker::PhantomData,
17743 }
17744 }
17745}
17746#[repr(transparent)]
17747pub struct MemoryAllocateFlagsInfoBuilder<'a> {
17748 inner: MemoryAllocateFlagsInfo,
17749 marker: ::std::marker::PhantomData<&'a ()>,
17750}
17751unsafe impl ExtendsMemoryAllocateInfo for MemoryAllocateFlagsInfoBuilder<'_> {}
17752unsafe impl ExtendsMemoryAllocateInfo for MemoryAllocateFlagsInfo {}
17753impl<'a> ::std::ops::Deref for MemoryAllocateFlagsInfoBuilder<'a> {
17754 type Target = MemoryAllocateFlagsInfo;
17755 fn deref(&self) -> &Self::Target {
17756 &self.inner
17757 }
17758}
17759impl<'a> ::std::ops::DerefMut for MemoryAllocateFlagsInfoBuilder<'a> {
17760 fn deref_mut(&mut self) -> &mut Self::Target {
17761 &mut self.inner
17762 }
17763}
17764impl<'a> MemoryAllocateFlagsInfoBuilder<'a> {
17765 pub fn flags(mut self, flags: MemoryAllocateFlags) -> Self {
17766 self.inner.flags = flags;
17767 self
17768 }
17769 pub fn device_mask(mut self, device_mask: u32) -> Self {
17770 self.inner.device_mask = device_mask;
17771 self
17772 }
17773 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17774 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17775 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17776 pub fn build(self) -> MemoryAllocateFlagsInfo {
17777 self.inner
17778 }
17779}
17780#[repr(C)]
17781#[cfg_attr(feature = "debug", derive(Debug))]
17782#[derive(Copy, Clone)]
17783#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindBufferMemoryInfo.html>"]
17784pub struct BindBufferMemoryInfo {
17785 pub s_type: StructureType,
17786 pub p_next: *const c_void,
17787 pub buffer: Buffer,
17788 pub memory: DeviceMemory,
17789 pub memory_offset: DeviceSize,
17790}
17791impl ::std::default::Default for BindBufferMemoryInfo {
17792 fn default() -> Self {
17793 Self {
17794 s_type: StructureType::BIND_BUFFER_MEMORY_INFO,
17795 p_next: ::std::ptr::null(),
17796 buffer: Buffer::default(),
17797 memory: DeviceMemory::default(),
17798 memory_offset: DeviceSize::default(),
17799 }
17800 }
17801}
17802impl BindBufferMemoryInfo {
17803 pub fn builder<'a>() -> BindBufferMemoryInfoBuilder<'a> {
17804 BindBufferMemoryInfoBuilder {
17805 inner: Self::default(),
17806 marker: ::std::marker::PhantomData,
17807 }
17808 }
17809}
17810#[repr(transparent)]
17811pub struct BindBufferMemoryInfoBuilder<'a> {
17812 inner: BindBufferMemoryInfo,
17813 marker: ::std::marker::PhantomData<&'a ()>,
17814}
17815pub unsafe trait ExtendsBindBufferMemoryInfo {}
17816impl<'a> ::std::ops::Deref for BindBufferMemoryInfoBuilder<'a> {
17817 type Target = BindBufferMemoryInfo;
17818 fn deref(&self) -> &Self::Target {
17819 &self.inner
17820 }
17821}
17822impl<'a> ::std::ops::DerefMut for BindBufferMemoryInfoBuilder<'a> {
17823 fn deref_mut(&mut self) -> &mut Self::Target {
17824 &mut self.inner
17825 }
17826}
17827impl<'a> BindBufferMemoryInfoBuilder<'a> {
17828 pub fn buffer(mut self, buffer: Buffer) -> Self {
17829 self.inner.buffer = buffer;
17830 self
17831 }
17832 pub fn memory(mut self, memory: DeviceMemory) -> Self {
17833 self.inner.memory = memory;
17834 self
17835 }
17836 pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self {
17837 self.inner.memory_offset = memory_offset;
17838 self
17839 }
17840 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
17841 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
17842 #[doc = r" valid extension structs can be pushed into the chain."]
17843 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
17844 #[doc = r" chain will look like `A -> D -> B -> C`."]
17845 pub fn push_next<T: ExtendsBindBufferMemoryInfo>(mut self, next: &'a mut T) -> Self {
17846 unsafe {
17847 let next_ptr = <*const T>::cast(next);
17848 let last_next = ptr_chain_iter(next).last().unwrap();
17849 (*last_next).p_next = self.inner.p_next as _;
17850 self.inner.p_next = next_ptr;
17851 }
17852 self
17853 }
17854 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17855 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17856 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17857 pub fn build(self) -> BindBufferMemoryInfo {
17858 self.inner
17859 }
17860}
17861#[repr(C)]
17862#[cfg_attr(feature = "debug", derive(Debug))]
17863#[derive(Copy, Clone)]
17864#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindBufferMemoryDeviceGroupInfo.html>"]
17865pub struct BindBufferMemoryDeviceGroupInfo {
17866 pub s_type: StructureType,
17867 pub p_next: *const c_void,
17868 pub device_index_count: u32,
17869 pub p_device_indices: *const u32,
17870}
17871impl ::std::default::Default for BindBufferMemoryDeviceGroupInfo {
17872 fn default() -> Self {
17873 Self {
17874 s_type: StructureType::BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO,
17875 p_next: ::std::ptr::null(),
17876 device_index_count: u32::default(),
17877 p_device_indices: ::std::ptr::null(),
17878 }
17879 }
17880}
17881impl BindBufferMemoryDeviceGroupInfo {
17882 pub fn builder<'a>() -> BindBufferMemoryDeviceGroupInfoBuilder<'a> {
17883 BindBufferMemoryDeviceGroupInfoBuilder {
17884 inner: Self::default(),
17885 marker: ::std::marker::PhantomData,
17886 }
17887 }
17888}
17889#[repr(transparent)]
17890pub struct BindBufferMemoryDeviceGroupInfoBuilder<'a> {
17891 inner: BindBufferMemoryDeviceGroupInfo,
17892 marker: ::std::marker::PhantomData<&'a ()>,
17893}
17894unsafe impl ExtendsBindBufferMemoryInfo for BindBufferMemoryDeviceGroupInfoBuilder<'_> {}
17895unsafe impl ExtendsBindBufferMemoryInfo for BindBufferMemoryDeviceGroupInfo {}
17896impl<'a> ::std::ops::Deref for BindBufferMemoryDeviceGroupInfoBuilder<'a> {
17897 type Target = BindBufferMemoryDeviceGroupInfo;
17898 fn deref(&self) -> &Self::Target {
17899 &self.inner
17900 }
17901}
17902impl<'a> ::std::ops::DerefMut for BindBufferMemoryDeviceGroupInfoBuilder<'a> {
17903 fn deref_mut(&mut self) -> &mut Self::Target {
17904 &mut self.inner
17905 }
17906}
17907impl<'a> BindBufferMemoryDeviceGroupInfoBuilder<'a> {
17908 pub fn device_indices(mut self, device_indices: &'a [u32]) -> Self {
17909 self.inner.device_index_count = device_indices.len() as _;
17910 self.inner.p_device_indices = device_indices.as_ptr();
17911 self
17912 }
17913 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17914 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17915 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17916 pub fn build(self) -> BindBufferMemoryDeviceGroupInfo {
17917 self.inner
17918 }
17919}
17920#[repr(C)]
17921#[cfg_attr(feature = "debug", derive(Debug))]
17922#[derive(Copy, Clone)]
17923#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindImageMemoryInfo.html>"]
17924pub struct BindImageMemoryInfo {
17925 pub s_type: StructureType,
17926 pub p_next: *const c_void,
17927 pub image: Image,
17928 pub memory: DeviceMemory,
17929 pub memory_offset: DeviceSize,
17930}
17931impl ::std::default::Default for BindImageMemoryInfo {
17932 fn default() -> Self {
17933 Self {
17934 s_type: StructureType::BIND_IMAGE_MEMORY_INFO,
17935 p_next: ::std::ptr::null(),
17936 image: Image::default(),
17937 memory: DeviceMemory::default(),
17938 memory_offset: DeviceSize::default(),
17939 }
17940 }
17941}
17942impl BindImageMemoryInfo {
17943 pub fn builder<'a>() -> BindImageMemoryInfoBuilder<'a> {
17944 BindImageMemoryInfoBuilder {
17945 inner: Self::default(),
17946 marker: ::std::marker::PhantomData,
17947 }
17948 }
17949}
17950#[repr(transparent)]
17951pub struct BindImageMemoryInfoBuilder<'a> {
17952 inner: BindImageMemoryInfo,
17953 marker: ::std::marker::PhantomData<&'a ()>,
17954}
17955pub unsafe trait ExtendsBindImageMemoryInfo {}
17956impl<'a> ::std::ops::Deref for BindImageMemoryInfoBuilder<'a> {
17957 type Target = BindImageMemoryInfo;
17958 fn deref(&self) -> &Self::Target {
17959 &self.inner
17960 }
17961}
17962impl<'a> ::std::ops::DerefMut for BindImageMemoryInfoBuilder<'a> {
17963 fn deref_mut(&mut self) -> &mut Self::Target {
17964 &mut self.inner
17965 }
17966}
17967impl<'a> BindImageMemoryInfoBuilder<'a> {
17968 pub fn image(mut self, image: Image) -> Self {
17969 self.inner.image = image;
17970 self
17971 }
17972 pub fn memory(mut self, memory: DeviceMemory) -> Self {
17973 self.inner.memory = memory;
17974 self
17975 }
17976 pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self {
17977 self.inner.memory_offset = memory_offset;
17978 self
17979 }
17980 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
17981 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
17982 #[doc = r" valid extension structs can be pushed into the chain."]
17983 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
17984 #[doc = r" chain will look like `A -> D -> B -> C`."]
17985 pub fn push_next<T: ExtendsBindImageMemoryInfo>(mut self, next: &'a mut T) -> Self {
17986 unsafe {
17987 let next_ptr = <*const T>::cast(next);
17988 let last_next = ptr_chain_iter(next).last().unwrap();
17989 (*last_next).p_next = self.inner.p_next as _;
17990 self.inner.p_next = next_ptr;
17991 }
17992 self
17993 }
17994 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17995 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17996 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17997 pub fn build(self) -> BindImageMemoryInfo {
17998 self.inner
17999 }
18000}
18001#[repr(C)]
18002#[cfg_attr(feature = "debug", derive(Debug))]
18003#[derive(Copy, Clone)]
18004#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindImageMemoryDeviceGroupInfo.html>"]
18005pub struct BindImageMemoryDeviceGroupInfo {
18006 pub s_type: StructureType,
18007 pub p_next: *const c_void,
18008 pub device_index_count: u32,
18009 pub p_device_indices: *const u32,
18010 pub split_instance_bind_region_count: u32,
18011 pub p_split_instance_bind_regions: *const Rect2D,
18012}
18013impl ::std::default::Default for BindImageMemoryDeviceGroupInfo {
18014 fn default() -> Self {
18015 Self {
18016 s_type: StructureType::BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO,
18017 p_next: ::std::ptr::null(),
18018 device_index_count: u32::default(),
18019 p_device_indices: ::std::ptr::null(),
18020 split_instance_bind_region_count: u32::default(),
18021 p_split_instance_bind_regions: ::std::ptr::null(),
18022 }
18023 }
18024}
18025impl BindImageMemoryDeviceGroupInfo {
18026 pub fn builder<'a>() -> BindImageMemoryDeviceGroupInfoBuilder<'a> {
18027 BindImageMemoryDeviceGroupInfoBuilder {
18028 inner: Self::default(),
18029 marker: ::std::marker::PhantomData,
18030 }
18031 }
18032}
18033#[repr(transparent)]
18034pub struct BindImageMemoryDeviceGroupInfoBuilder<'a> {
18035 inner: BindImageMemoryDeviceGroupInfo,
18036 marker: ::std::marker::PhantomData<&'a ()>,
18037}
18038unsafe impl ExtendsBindImageMemoryInfo for BindImageMemoryDeviceGroupInfoBuilder<'_> {}
18039unsafe impl ExtendsBindImageMemoryInfo for BindImageMemoryDeviceGroupInfo {}
18040impl<'a> ::std::ops::Deref for BindImageMemoryDeviceGroupInfoBuilder<'a> {
18041 type Target = BindImageMemoryDeviceGroupInfo;
18042 fn deref(&self) -> &Self::Target {
18043 &self.inner
18044 }
18045}
18046impl<'a> ::std::ops::DerefMut for BindImageMemoryDeviceGroupInfoBuilder<'a> {
18047 fn deref_mut(&mut self) -> &mut Self::Target {
18048 &mut self.inner
18049 }
18050}
18051impl<'a> BindImageMemoryDeviceGroupInfoBuilder<'a> {
18052 pub fn device_indices(mut self, device_indices: &'a [u32]) -> Self {
18053 self.inner.device_index_count = device_indices.len() as _;
18054 self.inner.p_device_indices = device_indices.as_ptr();
18055 self
18056 }
18057 pub fn split_instance_bind_regions(
18058 mut self,
18059 split_instance_bind_regions: &'a [Rect2D],
18060 ) -> Self {
18061 self.inner.split_instance_bind_region_count = split_instance_bind_regions.len() as _;
18062 self.inner.p_split_instance_bind_regions = split_instance_bind_regions.as_ptr();
18063 self
18064 }
18065 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18066 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18067 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18068 pub fn build(self) -> BindImageMemoryDeviceGroupInfo {
18069 self.inner
18070 }
18071}
18072#[repr(C)]
18073#[cfg_attr(feature = "debug", derive(Debug))]
18074#[derive(Copy, Clone)]
18075#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupRenderPassBeginInfo.html>"]
18076pub struct DeviceGroupRenderPassBeginInfo {
18077 pub s_type: StructureType,
18078 pub p_next: *const c_void,
18079 pub device_mask: u32,
18080 pub device_render_area_count: u32,
18081 pub p_device_render_areas: *const Rect2D,
18082}
18083impl ::std::default::Default for DeviceGroupRenderPassBeginInfo {
18084 fn default() -> Self {
18085 Self {
18086 s_type: StructureType::DEVICE_GROUP_RENDER_PASS_BEGIN_INFO,
18087 p_next: ::std::ptr::null(),
18088 device_mask: u32::default(),
18089 device_render_area_count: u32::default(),
18090 p_device_render_areas: ::std::ptr::null(),
18091 }
18092 }
18093}
18094impl DeviceGroupRenderPassBeginInfo {
18095 pub fn builder<'a>() -> DeviceGroupRenderPassBeginInfoBuilder<'a> {
18096 DeviceGroupRenderPassBeginInfoBuilder {
18097 inner: Self::default(),
18098 marker: ::std::marker::PhantomData,
18099 }
18100 }
18101}
18102#[repr(transparent)]
18103pub struct DeviceGroupRenderPassBeginInfoBuilder<'a> {
18104 inner: DeviceGroupRenderPassBeginInfo,
18105 marker: ::std::marker::PhantomData<&'a ()>,
18106}
18107unsafe impl ExtendsRenderPassBeginInfo for DeviceGroupRenderPassBeginInfoBuilder<'_> {}
18108unsafe impl ExtendsRenderPassBeginInfo for DeviceGroupRenderPassBeginInfo {}
18109unsafe impl ExtendsRenderingInfo for DeviceGroupRenderPassBeginInfoBuilder<'_> {}
18110unsafe impl ExtendsRenderingInfo for DeviceGroupRenderPassBeginInfo {}
18111impl<'a> ::std::ops::Deref for DeviceGroupRenderPassBeginInfoBuilder<'a> {
18112 type Target = DeviceGroupRenderPassBeginInfo;
18113 fn deref(&self) -> &Self::Target {
18114 &self.inner
18115 }
18116}
18117impl<'a> ::std::ops::DerefMut for DeviceGroupRenderPassBeginInfoBuilder<'a> {
18118 fn deref_mut(&mut self) -> &mut Self::Target {
18119 &mut self.inner
18120 }
18121}
18122impl<'a> DeviceGroupRenderPassBeginInfoBuilder<'a> {
18123 pub fn device_mask(mut self, device_mask: u32) -> Self {
18124 self.inner.device_mask = device_mask;
18125 self
18126 }
18127 pub fn device_render_areas(mut self, device_render_areas: &'a [Rect2D]) -> Self {
18128 self.inner.device_render_area_count = device_render_areas.len() as _;
18129 self.inner.p_device_render_areas = device_render_areas.as_ptr();
18130 self
18131 }
18132 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18133 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18134 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18135 pub fn build(self) -> DeviceGroupRenderPassBeginInfo {
18136 self.inner
18137 }
18138}
18139#[repr(C)]
18140#[cfg_attr(feature = "debug", derive(Debug))]
18141#[derive(Copy, Clone)]
18142#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupCommandBufferBeginInfo.html>"]
18143pub struct DeviceGroupCommandBufferBeginInfo {
18144 pub s_type: StructureType,
18145 pub p_next: *const c_void,
18146 pub device_mask: u32,
18147}
18148impl ::std::default::Default for DeviceGroupCommandBufferBeginInfo {
18149 fn default() -> Self {
18150 Self {
18151 s_type: StructureType::DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO,
18152 p_next: ::std::ptr::null(),
18153 device_mask: u32::default(),
18154 }
18155 }
18156}
18157impl DeviceGroupCommandBufferBeginInfo {
18158 pub fn builder<'a>() -> DeviceGroupCommandBufferBeginInfoBuilder<'a> {
18159 DeviceGroupCommandBufferBeginInfoBuilder {
18160 inner: Self::default(),
18161 marker: ::std::marker::PhantomData,
18162 }
18163 }
18164}
18165#[repr(transparent)]
18166pub struct DeviceGroupCommandBufferBeginInfoBuilder<'a> {
18167 inner: DeviceGroupCommandBufferBeginInfo,
18168 marker: ::std::marker::PhantomData<&'a ()>,
18169}
18170unsafe impl ExtendsCommandBufferBeginInfo for DeviceGroupCommandBufferBeginInfoBuilder<'_> {}
18171unsafe impl ExtendsCommandBufferBeginInfo for DeviceGroupCommandBufferBeginInfo {}
18172impl<'a> ::std::ops::Deref for DeviceGroupCommandBufferBeginInfoBuilder<'a> {
18173 type Target = DeviceGroupCommandBufferBeginInfo;
18174 fn deref(&self) -> &Self::Target {
18175 &self.inner
18176 }
18177}
18178impl<'a> ::std::ops::DerefMut for DeviceGroupCommandBufferBeginInfoBuilder<'a> {
18179 fn deref_mut(&mut self) -> &mut Self::Target {
18180 &mut self.inner
18181 }
18182}
18183impl<'a> DeviceGroupCommandBufferBeginInfoBuilder<'a> {
18184 pub fn device_mask(mut self, device_mask: u32) -> Self {
18185 self.inner.device_mask = device_mask;
18186 self
18187 }
18188 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18189 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18190 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18191 pub fn build(self) -> DeviceGroupCommandBufferBeginInfo {
18192 self.inner
18193 }
18194}
18195#[repr(C)]
18196#[cfg_attr(feature = "debug", derive(Debug))]
18197#[derive(Copy, Clone)]
18198#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupSubmitInfo.html>"]
18199pub struct DeviceGroupSubmitInfo {
18200 pub s_type: StructureType,
18201 pub p_next: *const c_void,
18202 pub wait_semaphore_count: u32,
18203 pub p_wait_semaphore_device_indices: *const u32,
18204 pub command_buffer_count: u32,
18205 pub p_command_buffer_device_masks: *const u32,
18206 pub signal_semaphore_count: u32,
18207 pub p_signal_semaphore_device_indices: *const u32,
18208}
18209impl ::std::default::Default for DeviceGroupSubmitInfo {
18210 fn default() -> Self {
18211 Self {
18212 s_type: StructureType::DEVICE_GROUP_SUBMIT_INFO,
18213 p_next: ::std::ptr::null(),
18214 wait_semaphore_count: u32::default(),
18215 p_wait_semaphore_device_indices: ::std::ptr::null(),
18216 command_buffer_count: u32::default(),
18217 p_command_buffer_device_masks: ::std::ptr::null(),
18218 signal_semaphore_count: u32::default(),
18219 p_signal_semaphore_device_indices: ::std::ptr::null(),
18220 }
18221 }
18222}
18223impl DeviceGroupSubmitInfo {
18224 pub fn builder<'a>() -> DeviceGroupSubmitInfoBuilder<'a> {
18225 DeviceGroupSubmitInfoBuilder {
18226 inner: Self::default(),
18227 marker: ::std::marker::PhantomData,
18228 }
18229 }
18230}
18231#[repr(transparent)]
18232pub struct DeviceGroupSubmitInfoBuilder<'a> {
18233 inner: DeviceGroupSubmitInfo,
18234 marker: ::std::marker::PhantomData<&'a ()>,
18235}
18236unsafe impl ExtendsSubmitInfo for DeviceGroupSubmitInfoBuilder<'_> {}
18237unsafe impl ExtendsSubmitInfo for DeviceGroupSubmitInfo {}
18238impl<'a> ::std::ops::Deref for DeviceGroupSubmitInfoBuilder<'a> {
18239 type Target = DeviceGroupSubmitInfo;
18240 fn deref(&self) -> &Self::Target {
18241 &self.inner
18242 }
18243}
18244impl<'a> ::std::ops::DerefMut for DeviceGroupSubmitInfoBuilder<'a> {
18245 fn deref_mut(&mut self) -> &mut Self::Target {
18246 &mut self.inner
18247 }
18248}
18249impl<'a> DeviceGroupSubmitInfoBuilder<'a> {
18250 pub fn wait_semaphore_device_indices(
18251 mut self,
18252 wait_semaphore_device_indices: &'a [u32],
18253 ) -> Self {
18254 self.inner.wait_semaphore_count = wait_semaphore_device_indices.len() as _;
18255 self.inner.p_wait_semaphore_device_indices = wait_semaphore_device_indices.as_ptr();
18256 self
18257 }
18258 pub fn command_buffer_device_masks(mut self, command_buffer_device_masks: &'a [u32]) -> Self {
18259 self.inner.command_buffer_count = command_buffer_device_masks.len() as _;
18260 self.inner.p_command_buffer_device_masks = command_buffer_device_masks.as_ptr();
18261 self
18262 }
18263 pub fn signal_semaphore_device_indices(
18264 mut self,
18265 signal_semaphore_device_indices: &'a [u32],
18266 ) -> Self {
18267 self.inner.signal_semaphore_count = signal_semaphore_device_indices.len() as _;
18268 self.inner.p_signal_semaphore_device_indices = signal_semaphore_device_indices.as_ptr();
18269 self
18270 }
18271 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18272 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18273 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18274 pub fn build(self) -> DeviceGroupSubmitInfo {
18275 self.inner
18276 }
18277}
18278#[repr(C)]
18279#[cfg_attr(feature = "debug", derive(Debug))]
18280#[derive(Copy, Clone)]
18281#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupBindSparseInfo.html>"]
18282pub struct DeviceGroupBindSparseInfo {
18283 pub s_type: StructureType,
18284 pub p_next: *const c_void,
18285 pub resource_device_index: u32,
18286 pub memory_device_index: u32,
18287}
18288impl ::std::default::Default for DeviceGroupBindSparseInfo {
18289 fn default() -> Self {
18290 Self {
18291 s_type: StructureType::DEVICE_GROUP_BIND_SPARSE_INFO,
18292 p_next: ::std::ptr::null(),
18293 resource_device_index: u32::default(),
18294 memory_device_index: u32::default(),
18295 }
18296 }
18297}
18298impl DeviceGroupBindSparseInfo {
18299 pub fn builder<'a>() -> DeviceGroupBindSparseInfoBuilder<'a> {
18300 DeviceGroupBindSparseInfoBuilder {
18301 inner: Self::default(),
18302 marker: ::std::marker::PhantomData,
18303 }
18304 }
18305}
18306#[repr(transparent)]
18307pub struct DeviceGroupBindSparseInfoBuilder<'a> {
18308 inner: DeviceGroupBindSparseInfo,
18309 marker: ::std::marker::PhantomData<&'a ()>,
18310}
18311unsafe impl ExtendsBindSparseInfo for DeviceGroupBindSparseInfoBuilder<'_> {}
18312unsafe impl ExtendsBindSparseInfo for DeviceGroupBindSparseInfo {}
18313impl<'a> ::std::ops::Deref for DeviceGroupBindSparseInfoBuilder<'a> {
18314 type Target = DeviceGroupBindSparseInfo;
18315 fn deref(&self) -> &Self::Target {
18316 &self.inner
18317 }
18318}
18319impl<'a> ::std::ops::DerefMut for DeviceGroupBindSparseInfoBuilder<'a> {
18320 fn deref_mut(&mut self) -> &mut Self::Target {
18321 &mut self.inner
18322 }
18323}
18324impl<'a> DeviceGroupBindSparseInfoBuilder<'a> {
18325 pub fn resource_device_index(mut self, resource_device_index: u32) -> Self {
18326 self.inner.resource_device_index = resource_device_index;
18327 self
18328 }
18329 pub fn memory_device_index(mut self, memory_device_index: u32) -> Self {
18330 self.inner.memory_device_index = memory_device_index;
18331 self
18332 }
18333 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18334 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18335 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18336 pub fn build(self) -> DeviceGroupBindSparseInfo {
18337 self.inner
18338 }
18339}
18340#[repr(C)]
18341#[cfg_attr(feature = "debug", derive(Debug))]
18342#[derive(Copy, Clone)]
18343#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupPresentCapabilitiesKHR.html>"]
18344pub struct DeviceGroupPresentCapabilitiesKHR {
18345 pub s_type: StructureType,
18346 pub p_next: *mut c_void,
18347 pub present_mask: [u32; MAX_DEVICE_GROUP_SIZE],
18348 pub modes: DeviceGroupPresentModeFlagsKHR,
18349}
18350impl ::std::default::Default for DeviceGroupPresentCapabilitiesKHR {
18351 fn default() -> Self {
18352 Self {
18353 s_type: StructureType::DEVICE_GROUP_PRESENT_CAPABILITIES_KHR,
18354 p_next: ::std::ptr::null_mut(),
18355 present_mask: unsafe { ::std::mem::zeroed() },
18356 modes: DeviceGroupPresentModeFlagsKHR::default(),
18357 }
18358 }
18359}
18360impl DeviceGroupPresentCapabilitiesKHR {
18361 pub fn builder<'a>() -> DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
18362 DeviceGroupPresentCapabilitiesKHRBuilder {
18363 inner: Self::default(),
18364 marker: ::std::marker::PhantomData,
18365 }
18366 }
18367}
18368#[repr(transparent)]
18369pub struct DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
18370 inner: DeviceGroupPresentCapabilitiesKHR,
18371 marker: ::std::marker::PhantomData<&'a ()>,
18372}
18373impl<'a> ::std::ops::Deref for DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
18374 type Target = DeviceGroupPresentCapabilitiesKHR;
18375 fn deref(&self) -> &Self::Target {
18376 &self.inner
18377 }
18378}
18379impl<'a> ::std::ops::DerefMut for DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
18380 fn deref_mut(&mut self) -> &mut Self::Target {
18381 &mut self.inner
18382 }
18383}
18384impl<'a> DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
18385 pub fn present_mask(mut self, present_mask: [u32; MAX_DEVICE_GROUP_SIZE]) -> Self {
18386 self.inner.present_mask = present_mask;
18387 self
18388 }
18389 pub fn modes(mut self, modes: DeviceGroupPresentModeFlagsKHR) -> Self {
18390 self.inner.modes = modes;
18391 self
18392 }
18393 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18394 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18395 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18396 pub fn build(self) -> DeviceGroupPresentCapabilitiesKHR {
18397 self.inner
18398 }
18399}
18400#[repr(C)]
18401#[cfg_attr(feature = "debug", derive(Debug))]
18402#[derive(Copy, Clone)]
18403#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSwapchainCreateInfoKHR.html>"]
18404pub struct ImageSwapchainCreateInfoKHR {
18405 pub s_type: StructureType,
18406 pub p_next: *const c_void,
18407 pub swapchain: SwapchainKHR,
18408}
18409impl ::std::default::Default for ImageSwapchainCreateInfoKHR {
18410 fn default() -> Self {
18411 Self {
18412 s_type: StructureType::IMAGE_SWAPCHAIN_CREATE_INFO_KHR,
18413 p_next: ::std::ptr::null(),
18414 swapchain: SwapchainKHR::default(),
18415 }
18416 }
18417}
18418impl ImageSwapchainCreateInfoKHR {
18419 pub fn builder<'a>() -> ImageSwapchainCreateInfoKHRBuilder<'a> {
18420 ImageSwapchainCreateInfoKHRBuilder {
18421 inner: Self::default(),
18422 marker: ::std::marker::PhantomData,
18423 }
18424 }
18425}
18426#[repr(transparent)]
18427pub struct ImageSwapchainCreateInfoKHRBuilder<'a> {
18428 inner: ImageSwapchainCreateInfoKHR,
18429 marker: ::std::marker::PhantomData<&'a ()>,
18430}
18431unsafe impl ExtendsImageCreateInfo for ImageSwapchainCreateInfoKHRBuilder<'_> {}
18432unsafe impl ExtendsImageCreateInfo for ImageSwapchainCreateInfoKHR {}
18433impl<'a> ::std::ops::Deref for ImageSwapchainCreateInfoKHRBuilder<'a> {
18434 type Target = ImageSwapchainCreateInfoKHR;
18435 fn deref(&self) -> &Self::Target {
18436 &self.inner
18437 }
18438}
18439impl<'a> ::std::ops::DerefMut for ImageSwapchainCreateInfoKHRBuilder<'a> {
18440 fn deref_mut(&mut self) -> &mut Self::Target {
18441 &mut self.inner
18442 }
18443}
18444impl<'a> ImageSwapchainCreateInfoKHRBuilder<'a> {
18445 pub fn swapchain(mut self, swapchain: SwapchainKHR) -> Self {
18446 self.inner.swapchain = swapchain;
18447 self
18448 }
18449 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18450 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18451 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18452 pub fn build(self) -> ImageSwapchainCreateInfoKHR {
18453 self.inner
18454 }
18455}
18456#[repr(C)]
18457#[cfg_attr(feature = "debug", derive(Debug))]
18458#[derive(Copy, Clone)]
18459#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindImageMemorySwapchainInfoKHR.html>"]
18460pub struct BindImageMemorySwapchainInfoKHR {
18461 pub s_type: StructureType,
18462 pub p_next: *const c_void,
18463 pub swapchain: SwapchainKHR,
18464 pub image_index: u32,
18465}
18466impl ::std::default::Default for BindImageMemorySwapchainInfoKHR {
18467 fn default() -> Self {
18468 Self {
18469 s_type: StructureType::BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR,
18470 p_next: ::std::ptr::null(),
18471 swapchain: SwapchainKHR::default(),
18472 image_index: u32::default(),
18473 }
18474 }
18475}
18476impl BindImageMemorySwapchainInfoKHR {
18477 pub fn builder<'a>() -> BindImageMemorySwapchainInfoKHRBuilder<'a> {
18478 BindImageMemorySwapchainInfoKHRBuilder {
18479 inner: Self::default(),
18480 marker: ::std::marker::PhantomData,
18481 }
18482 }
18483}
18484#[repr(transparent)]
18485pub struct BindImageMemorySwapchainInfoKHRBuilder<'a> {
18486 inner: BindImageMemorySwapchainInfoKHR,
18487 marker: ::std::marker::PhantomData<&'a ()>,
18488}
18489unsafe impl ExtendsBindImageMemoryInfo for BindImageMemorySwapchainInfoKHRBuilder<'_> {}
18490unsafe impl ExtendsBindImageMemoryInfo for BindImageMemorySwapchainInfoKHR {}
18491impl<'a> ::std::ops::Deref for BindImageMemorySwapchainInfoKHRBuilder<'a> {
18492 type Target = BindImageMemorySwapchainInfoKHR;
18493 fn deref(&self) -> &Self::Target {
18494 &self.inner
18495 }
18496}
18497impl<'a> ::std::ops::DerefMut for BindImageMemorySwapchainInfoKHRBuilder<'a> {
18498 fn deref_mut(&mut self) -> &mut Self::Target {
18499 &mut self.inner
18500 }
18501}
18502impl<'a> BindImageMemorySwapchainInfoKHRBuilder<'a> {
18503 pub fn swapchain(mut self, swapchain: SwapchainKHR) -> Self {
18504 self.inner.swapchain = swapchain;
18505 self
18506 }
18507 pub fn image_index(mut self, image_index: u32) -> Self {
18508 self.inner.image_index = image_index;
18509 self
18510 }
18511 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18512 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18513 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18514 pub fn build(self) -> BindImageMemorySwapchainInfoKHR {
18515 self.inner
18516 }
18517}
18518#[repr(C)]
18519#[cfg_attr(feature = "debug", derive(Debug))]
18520#[derive(Copy, Clone)]
18521#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAcquireNextImageInfoKHR.html>"]
18522pub struct AcquireNextImageInfoKHR {
18523 pub s_type: StructureType,
18524 pub p_next: *const c_void,
18525 pub swapchain: SwapchainKHR,
18526 pub timeout: u64,
18527 pub semaphore: Semaphore,
18528 pub fence: Fence,
18529 pub device_mask: u32,
18530}
18531impl ::std::default::Default for AcquireNextImageInfoKHR {
18532 fn default() -> Self {
18533 Self {
18534 s_type: StructureType::ACQUIRE_NEXT_IMAGE_INFO_KHR,
18535 p_next: ::std::ptr::null(),
18536 swapchain: SwapchainKHR::default(),
18537 timeout: u64::default(),
18538 semaphore: Semaphore::default(),
18539 fence: Fence::default(),
18540 device_mask: u32::default(),
18541 }
18542 }
18543}
18544impl AcquireNextImageInfoKHR {
18545 pub fn builder<'a>() -> AcquireNextImageInfoKHRBuilder<'a> {
18546 AcquireNextImageInfoKHRBuilder {
18547 inner: Self::default(),
18548 marker: ::std::marker::PhantomData,
18549 }
18550 }
18551}
18552#[repr(transparent)]
18553pub struct AcquireNextImageInfoKHRBuilder<'a> {
18554 inner: AcquireNextImageInfoKHR,
18555 marker: ::std::marker::PhantomData<&'a ()>,
18556}
18557impl<'a> ::std::ops::Deref for AcquireNextImageInfoKHRBuilder<'a> {
18558 type Target = AcquireNextImageInfoKHR;
18559 fn deref(&self) -> &Self::Target {
18560 &self.inner
18561 }
18562}
18563impl<'a> ::std::ops::DerefMut for AcquireNextImageInfoKHRBuilder<'a> {
18564 fn deref_mut(&mut self) -> &mut Self::Target {
18565 &mut self.inner
18566 }
18567}
18568impl<'a> AcquireNextImageInfoKHRBuilder<'a> {
18569 pub fn swapchain(mut self, swapchain: SwapchainKHR) -> Self {
18570 self.inner.swapchain = swapchain;
18571 self
18572 }
18573 pub fn timeout(mut self, timeout: u64) -> Self {
18574 self.inner.timeout = timeout;
18575 self
18576 }
18577 pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
18578 self.inner.semaphore = semaphore;
18579 self
18580 }
18581 pub fn fence(mut self, fence: Fence) -> Self {
18582 self.inner.fence = fence;
18583 self
18584 }
18585 pub fn device_mask(mut self, device_mask: u32) -> Self {
18586 self.inner.device_mask = device_mask;
18587 self
18588 }
18589 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18590 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18591 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18592 pub fn build(self) -> AcquireNextImageInfoKHR {
18593 self.inner
18594 }
18595}
18596#[repr(C)]
18597#[cfg_attr(feature = "debug", derive(Debug))]
18598#[derive(Copy, Clone)]
18599#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupPresentInfoKHR.html>"]
18600pub struct DeviceGroupPresentInfoKHR {
18601 pub s_type: StructureType,
18602 pub p_next: *const c_void,
18603 pub swapchain_count: u32,
18604 pub p_device_masks: *const u32,
18605 pub mode: DeviceGroupPresentModeFlagsKHR,
18606}
18607impl ::std::default::Default for DeviceGroupPresentInfoKHR {
18608 fn default() -> Self {
18609 Self {
18610 s_type: StructureType::DEVICE_GROUP_PRESENT_INFO_KHR,
18611 p_next: ::std::ptr::null(),
18612 swapchain_count: u32::default(),
18613 p_device_masks: ::std::ptr::null(),
18614 mode: DeviceGroupPresentModeFlagsKHR::default(),
18615 }
18616 }
18617}
18618impl DeviceGroupPresentInfoKHR {
18619 pub fn builder<'a>() -> DeviceGroupPresentInfoKHRBuilder<'a> {
18620 DeviceGroupPresentInfoKHRBuilder {
18621 inner: Self::default(),
18622 marker: ::std::marker::PhantomData,
18623 }
18624 }
18625}
18626#[repr(transparent)]
18627pub struct DeviceGroupPresentInfoKHRBuilder<'a> {
18628 inner: DeviceGroupPresentInfoKHR,
18629 marker: ::std::marker::PhantomData<&'a ()>,
18630}
18631unsafe impl ExtendsPresentInfoKHR for DeviceGroupPresentInfoKHRBuilder<'_> {}
18632unsafe impl ExtendsPresentInfoKHR for DeviceGroupPresentInfoKHR {}
18633impl<'a> ::std::ops::Deref for DeviceGroupPresentInfoKHRBuilder<'a> {
18634 type Target = DeviceGroupPresentInfoKHR;
18635 fn deref(&self) -> &Self::Target {
18636 &self.inner
18637 }
18638}
18639impl<'a> ::std::ops::DerefMut for DeviceGroupPresentInfoKHRBuilder<'a> {
18640 fn deref_mut(&mut self) -> &mut Self::Target {
18641 &mut self.inner
18642 }
18643}
18644impl<'a> DeviceGroupPresentInfoKHRBuilder<'a> {
18645 pub fn device_masks(mut self, device_masks: &'a [u32]) -> Self {
18646 self.inner.swapchain_count = device_masks.len() as _;
18647 self.inner.p_device_masks = device_masks.as_ptr();
18648 self
18649 }
18650 pub fn mode(mut self, mode: DeviceGroupPresentModeFlagsKHR) -> Self {
18651 self.inner.mode = mode;
18652 self
18653 }
18654 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18655 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18656 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18657 pub fn build(self) -> DeviceGroupPresentInfoKHR {
18658 self.inner
18659 }
18660}
18661#[repr(C)]
18662#[cfg_attr(feature = "debug", derive(Debug))]
18663#[derive(Copy, Clone)]
18664#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupDeviceCreateInfo.html>"]
18665pub struct DeviceGroupDeviceCreateInfo {
18666 pub s_type: StructureType,
18667 pub p_next: *const c_void,
18668 pub physical_device_count: u32,
18669 pub p_physical_devices: *const PhysicalDevice,
18670}
18671impl ::std::default::Default for DeviceGroupDeviceCreateInfo {
18672 fn default() -> Self {
18673 Self {
18674 s_type: StructureType::DEVICE_GROUP_DEVICE_CREATE_INFO,
18675 p_next: ::std::ptr::null(),
18676 physical_device_count: u32::default(),
18677 p_physical_devices: ::std::ptr::null(),
18678 }
18679 }
18680}
18681impl DeviceGroupDeviceCreateInfo {
18682 pub fn builder<'a>() -> DeviceGroupDeviceCreateInfoBuilder<'a> {
18683 DeviceGroupDeviceCreateInfoBuilder {
18684 inner: Self::default(),
18685 marker: ::std::marker::PhantomData,
18686 }
18687 }
18688}
18689#[repr(transparent)]
18690pub struct DeviceGroupDeviceCreateInfoBuilder<'a> {
18691 inner: DeviceGroupDeviceCreateInfo,
18692 marker: ::std::marker::PhantomData<&'a ()>,
18693}
18694unsafe impl ExtendsDeviceCreateInfo for DeviceGroupDeviceCreateInfoBuilder<'_> {}
18695unsafe impl ExtendsDeviceCreateInfo for DeviceGroupDeviceCreateInfo {}
18696impl<'a> ::std::ops::Deref for DeviceGroupDeviceCreateInfoBuilder<'a> {
18697 type Target = DeviceGroupDeviceCreateInfo;
18698 fn deref(&self) -> &Self::Target {
18699 &self.inner
18700 }
18701}
18702impl<'a> ::std::ops::DerefMut for DeviceGroupDeviceCreateInfoBuilder<'a> {
18703 fn deref_mut(&mut self) -> &mut Self::Target {
18704 &mut self.inner
18705 }
18706}
18707impl<'a> DeviceGroupDeviceCreateInfoBuilder<'a> {
18708 pub fn physical_devices(mut self, physical_devices: &'a [PhysicalDevice]) -> Self {
18709 self.inner.physical_device_count = physical_devices.len() as _;
18710 self.inner.p_physical_devices = physical_devices.as_ptr();
18711 self
18712 }
18713 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18714 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18715 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18716 pub fn build(self) -> DeviceGroupDeviceCreateInfo {
18717 self.inner
18718 }
18719}
18720#[repr(C)]
18721#[cfg_attr(feature = "debug", derive(Debug))]
18722#[derive(Copy, Clone)]
18723#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupSwapchainCreateInfoKHR.html>"]
18724pub struct DeviceGroupSwapchainCreateInfoKHR {
18725 pub s_type: StructureType,
18726 pub p_next: *const c_void,
18727 pub modes: DeviceGroupPresentModeFlagsKHR,
18728}
18729impl ::std::default::Default for DeviceGroupSwapchainCreateInfoKHR {
18730 fn default() -> Self {
18731 Self {
18732 s_type: StructureType::DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR,
18733 p_next: ::std::ptr::null(),
18734 modes: DeviceGroupPresentModeFlagsKHR::default(),
18735 }
18736 }
18737}
18738impl DeviceGroupSwapchainCreateInfoKHR {
18739 pub fn builder<'a>() -> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
18740 DeviceGroupSwapchainCreateInfoKHRBuilder {
18741 inner: Self::default(),
18742 marker: ::std::marker::PhantomData,
18743 }
18744 }
18745}
18746#[repr(transparent)]
18747pub struct DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
18748 inner: DeviceGroupSwapchainCreateInfoKHR,
18749 marker: ::std::marker::PhantomData<&'a ()>,
18750}
18751unsafe impl ExtendsSwapchainCreateInfoKHR for DeviceGroupSwapchainCreateInfoKHRBuilder<'_> {}
18752unsafe impl ExtendsSwapchainCreateInfoKHR for DeviceGroupSwapchainCreateInfoKHR {}
18753impl<'a> ::std::ops::Deref for DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
18754 type Target = DeviceGroupSwapchainCreateInfoKHR;
18755 fn deref(&self) -> &Self::Target {
18756 &self.inner
18757 }
18758}
18759impl<'a> ::std::ops::DerefMut for DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
18760 fn deref_mut(&mut self) -> &mut Self::Target {
18761 &mut self.inner
18762 }
18763}
18764impl<'a> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
18765 pub fn modes(mut self, modes: DeviceGroupPresentModeFlagsKHR) -> Self {
18766 self.inner.modes = modes;
18767 self
18768 }
18769 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18770 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18771 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18772 pub fn build(self) -> DeviceGroupSwapchainCreateInfoKHR {
18773 self.inner
18774 }
18775}
18776#[repr(C)]
18777#[cfg_attr(feature = "debug", derive(Debug))]
18778#[derive(Copy, Clone, Default)]
18779#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorUpdateTemplateEntry.html>"]
18780pub struct DescriptorUpdateTemplateEntry {
18781 pub dst_binding: u32,
18782 pub dst_array_element: u32,
18783 pub descriptor_count: u32,
18784 pub descriptor_type: DescriptorType,
18785 pub offset: usize,
18786 pub stride: usize,
18787}
18788impl DescriptorUpdateTemplateEntry {
18789 pub fn builder<'a>() -> DescriptorUpdateTemplateEntryBuilder<'a> {
18790 DescriptorUpdateTemplateEntryBuilder {
18791 inner: Self::default(),
18792 marker: ::std::marker::PhantomData,
18793 }
18794 }
18795}
18796#[repr(transparent)]
18797pub struct DescriptorUpdateTemplateEntryBuilder<'a> {
18798 inner: DescriptorUpdateTemplateEntry,
18799 marker: ::std::marker::PhantomData<&'a ()>,
18800}
18801impl<'a> ::std::ops::Deref for DescriptorUpdateTemplateEntryBuilder<'a> {
18802 type Target = DescriptorUpdateTemplateEntry;
18803 fn deref(&self) -> &Self::Target {
18804 &self.inner
18805 }
18806}
18807impl<'a> ::std::ops::DerefMut for DescriptorUpdateTemplateEntryBuilder<'a> {
18808 fn deref_mut(&mut self) -> &mut Self::Target {
18809 &mut self.inner
18810 }
18811}
18812impl<'a> DescriptorUpdateTemplateEntryBuilder<'a> {
18813 pub fn dst_binding(mut self, dst_binding: u32) -> Self {
18814 self.inner.dst_binding = dst_binding;
18815 self
18816 }
18817 pub fn dst_array_element(mut self, dst_array_element: u32) -> Self {
18818 self.inner.dst_array_element = dst_array_element;
18819 self
18820 }
18821 pub fn descriptor_count(mut self, descriptor_count: u32) -> Self {
18822 self.inner.descriptor_count = descriptor_count;
18823 self
18824 }
18825 pub fn descriptor_type(mut self, descriptor_type: DescriptorType) -> Self {
18826 self.inner.descriptor_type = descriptor_type;
18827 self
18828 }
18829 pub fn offset(mut self, offset: usize) -> Self {
18830 self.inner.offset = offset;
18831 self
18832 }
18833 pub fn stride(mut self, stride: usize) -> Self {
18834 self.inner.stride = stride;
18835 self
18836 }
18837 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18838 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18839 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18840 pub fn build(self) -> DescriptorUpdateTemplateEntry {
18841 self.inner
18842 }
18843}
18844#[repr(C)]
18845#[cfg_attr(feature = "debug", derive(Debug))]
18846#[derive(Copy, Clone)]
18847#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorUpdateTemplateCreateInfo.html>"]
18848pub struct DescriptorUpdateTemplateCreateInfo {
18849 pub s_type: StructureType,
18850 pub p_next: *const c_void,
18851 pub flags: DescriptorUpdateTemplateCreateFlags,
18852 pub descriptor_update_entry_count: u32,
18853 pub p_descriptor_update_entries: *const DescriptorUpdateTemplateEntry,
18854 pub template_type: DescriptorUpdateTemplateType,
18855 pub descriptor_set_layout: DescriptorSetLayout,
18856 pub pipeline_bind_point: PipelineBindPoint,
18857 pub pipeline_layout: PipelineLayout,
18858 pub set: u32,
18859}
18860impl ::std::default::Default for DescriptorUpdateTemplateCreateInfo {
18861 fn default() -> Self {
18862 Self {
18863 s_type: StructureType::DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,
18864 p_next: ::std::ptr::null(),
18865 flags: DescriptorUpdateTemplateCreateFlags::default(),
18866 descriptor_update_entry_count: u32::default(),
18867 p_descriptor_update_entries: ::std::ptr::null(),
18868 template_type: DescriptorUpdateTemplateType::default(),
18869 descriptor_set_layout: DescriptorSetLayout::default(),
18870 pipeline_bind_point: PipelineBindPoint::default(),
18871 pipeline_layout: PipelineLayout::default(),
18872 set: u32::default(),
18873 }
18874 }
18875}
18876impl DescriptorUpdateTemplateCreateInfo {
18877 pub fn builder<'a>() -> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
18878 DescriptorUpdateTemplateCreateInfoBuilder {
18879 inner: Self::default(),
18880 marker: ::std::marker::PhantomData,
18881 }
18882 }
18883}
18884#[repr(transparent)]
18885pub struct DescriptorUpdateTemplateCreateInfoBuilder<'a> {
18886 inner: DescriptorUpdateTemplateCreateInfo,
18887 marker: ::std::marker::PhantomData<&'a ()>,
18888}
18889impl<'a> ::std::ops::Deref for DescriptorUpdateTemplateCreateInfoBuilder<'a> {
18890 type Target = DescriptorUpdateTemplateCreateInfo;
18891 fn deref(&self) -> &Self::Target {
18892 &self.inner
18893 }
18894}
18895impl<'a> ::std::ops::DerefMut for DescriptorUpdateTemplateCreateInfoBuilder<'a> {
18896 fn deref_mut(&mut self) -> &mut Self::Target {
18897 &mut self.inner
18898 }
18899}
18900impl<'a> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
18901 pub fn flags(mut self, flags: DescriptorUpdateTemplateCreateFlags) -> Self {
18902 self.inner.flags = flags;
18903 self
18904 }
18905 pub fn descriptor_update_entries(
18906 mut self,
18907 descriptor_update_entries: &'a [DescriptorUpdateTemplateEntry],
18908 ) -> Self {
18909 self.inner.descriptor_update_entry_count = descriptor_update_entries.len() as _;
18910 self.inner.p_descriptor_update_entries = descriptor_update_entries.as_ptr();
18911 self
18912 }
18913 pub fn template_type(mut self, template_type: DescriptorUpdateTemplateType) -> Self {
18914 self.inner.template_type = template_type;
18915 self
18916 }
18917 pub fn descriptor_set_layout(mut self, descriptor_set_layout: DescriptorSetLayout) -> Self {
18918 self.inner.descriptor_set_layout = descriptor_set_layout;
18919 self
18920 }
18921 pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self {
18922 self.inner.pipeline_bind_point = pipeline_bind_point;
18923 self
18924 }
18925 pub fn pipeline_layout(mut self, pipeline_layout: PipelineLayout) -> Self {
18926 self.inner.pipeline_layout = pipeline_layout;
18927 self
18928 }
18929 pub fn set(mut self, set: u32) -> Self {
18930 self.inner.set = set;
18931 self
18932 }
18933 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18934 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18935 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18936 pub fn build(self) -> DescriptorUpdateTemplateCreateInfo {
18937 self.inner
18938 }
18939}
18940#[repr(C)]
18941#[cfg_attr(feature = "debug", derive(Debug))]
18942#[derive(Copy, Clone, Default)]
18943#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkXYColorEXT.html>"]
18944pub struct XYColorEXT {
18945 pub x: f32,
18946 pub y: f32,
18947}
18948impl XYColorEXT {
18949 pub fn builder<'a>() -> XYColorEXTBuilder<'a> {
18950 XYColorEXTBuilder {
18951 inner: Self::default(),
18952 marker: ::std::marker::PhantomData,
18953 }
18954 }
18955}
18956#[repr(transparent)]
18957pub struct XYColorEXTBuilder<'a> {
18958 inner: XYColorEXT,
18959 marker: ::std::marker::PhantomData<&'a ()>,
18960}
18961impl<'a> ::std::ops::Deref for XYColorEXTBuilder<'a> {
18962 type Target = XYColorEXT;
18963 fn deref(&self) -> &Self::Target {
18964 &self.inner
18965 }
18966}
18967impl<'a> ::std::ops::DerefMut for XYColorEXTBuilder<'a> {
18968 fn deref_mut(&mut self) -> &mut Self::Target {
18969 &mut self.inner
18970 }
18971}
18972impl<'a> XYColorEXTBuilder<'a> {
18973 pub fn x(mut self, x: f32) -> Self {
18974 self.inner.x = x;
18975 self
18976 }
18977 pub fn y(mut self, y: f32) -> Self {
18978 self.inner.y = y;
18979 self
18980 }
18981 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18982 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18983 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18984 pub fn build(self) -> XYColorEXT {
18985 self.inner
18986 }
18987}
18988#[repr(C)]
18989#[cfg_attr(feature = "debug", derive(Debug))]
18990#[derive(Copy, Clone)]
18991#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePresentIdFeaturesKHR.html>"]
18992pub struct PhysicalDevicePresentIdFeaturesKHR {
18993 pub s_type: StructureType,
18994 pub p_next: *mut c_void,
18995 pub present_id: Bool32,
18996}
18997impl ::std::default::Default for PhysicalDevicePresentIdFeaturesKHR {
18998 fn default() -> Self {
18999 Self {
19000 s_type: StructureType::PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR,
19001 p_next: ::std::ptr::null_mut(),
19002 present_id: Bool32::default(),
19003 }
19004 }
19005}
19006impl PhysicalDevicePresentIdFeaturesKHR {
19007 pub fn builder<'a>() -> PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
19008 PhysicalDevicePresentIdFeaturesKHRBuilder {
19009 inner: Self::default(),
19010 marker: ::std::marker::PhantomData,
19011 }
19012 }
19013}
19014#[repr(transparent)]
19015pub struct PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
19016 inner: PhysicalDevicePresentIdFeaturesKHR,
19017 marker: ::std::marker::PhantomData<&'a ()>,
19018}
19019unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentIdFeaturesKHRBuilder<'_> {}
19020unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentIdFeaturesKHR {}
19021unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentIdFeaturesKHRBuilder<'_> {}
19022unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentIdFeaturesKHR {}
19023impl<'a> ::std::ops::Deref for PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
19024 type Target = PhysicalDevicePresentIdFeaturesKHR;
19025 fn deref(&self) -> &Self::Target {
19026 &self.inner
19027 }
19028}
19029impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
19030 fn deref_mut(&mut self) -> &mut Self::Target {
19031 &mut self.inner
19032 }
19033}
19034impl<'a> PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
19035 pub fn present_id(mut self, present_id: bool) -> Self {
19036 self.inner.present_id = present_id.into();
19037 self
19038 }
19039 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19040 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19041 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19042 pub fn build(self) -> PhysicalDevicePresentIdFeaturesKHR {
19043 self.inner
19044 }
19045}
19046#[repr(C)]
19047#[cfg_attr(feature = "debug", derive(Debug))]
19048#[derive(Copy, Clone)]
19049#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentIdKHR.html>"]
19050pub struct PresentIdKHR {
19051 pub s_type: StructureType,
19052 pub p_next: *const c_void,
19053 pub swapchain_count: u32,
19054 pub p_present_ids: *const u64,
19055}
19056impl ::std::default::Default for PresentIdKHR {
19057 fn default() -> Self {
19058 Self {
19059 s_type: StructureType::PRESENT_ID_KHR,
19060 p_next: ::std::ptr::null(),
19061 swapchain_count: u32::default(),
19062 p_present_ids: ::std::ptr::null(),
19063 }
19064 }
19065}
19066impl PresentIdKHR {
19067 pub fn builder<'a>() -> PresentIdKHRBuilder<'a> {
19068 PresentIdKHRBuilder {
19069 inner: Self::default(),
19070 marker: ::std::marker::PhantomData,
19071 }
19072 }
19073}
19074#[repr(transparent)]
19075pub struct PresentIdKHRBuilder<'a> {
19076 inner: PresentIdKHR,
19077 marker: ::std::marker::PhantomData<&'a ()>,
19078}
19079unsafe impl ExtendsPresentInfoKHR for PresentIdKHRBuilder<'_> {}
19080unsafe impl ExtendsPresentInfoKHR for PresentIdKHR {}
19081impl<'a> ::std::ops::Deref for PresentIdKHRBuilder<'a> {
19082 type Target = PresentIdKHR;
19083 fn deref(&self) -> &Self::Target {
19084 &self.inner
19085 }
19086}
19087impl<'a> ::std::ops::DerefMut for PresentIdKHRBuilder<'a> {
19088 fn deref_mut(&mut self) -> &mut Self::Target {
19089 &mut self.inner
19090 }
19091}
19092impl<'a> PresentIdKHRBuilder<'a> {
19093 pub fn present_ids(mut self, present_ids: &'a [u64]) -> Self {
19094 self.inner.swapchain_count = present_ids.len() as _;
19095 self.inner.p_present_ids = present_ids.as_ptr();
19096 self
19097 }
19098 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19099 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19100 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19101 pub fn build(self) -> PresentIdKHR {
19102 self.inner
19103 }
19104}
19105#[repr(C)]
19106#[cfg_attr(feature = "debug", derive(Debug))]
19107#[derive(Copy, Clone)]
19108#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePresentWaitFeaturesKHR.html>"]
19109pub struct PhysicalDevicePresentWaitFeaturesKHR {
19110 pub s_type: StructureType,
19111 pub p_next: *mut c_void,
19112 pub present_wait: Bool32,
19113}
19114impl ::std::default::Default for PhysicalDevicePresentWaitFeaturesKHR {
19115 fn default() -> Self {
19116 Self {
19117 s_type: StructureType::PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR,
19118 p_next: ::std::ptr::null_mut(),
19119 present_wait: Bool32::default(),
19120 }
19121 }
19122}
19123impl PhysicalDevicePresentWaitFeaturesKHR {
19124 pub fn builder<'a>() -> PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
19125 PhysicalDevicePresentWaitFeaturesKHRBuilder {
19126 inner: Self::default(),
19127 marker: ::std::marker::PhantomData,
19128 }
19129 }
19130}
19131#[repr(transparent)]
19132pub struct PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
19133 inner: PhysicalDevicePresentWaitFeaturesKHR,
19134 marker: ::std::marker::PhantomData<&'a ()>,
19135}
19136unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentWaitFeaturesKHRBuilder<'_> {}
19137unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentWaitFeaturesKHR {}
19138unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentWaitFeaturesKHRBuilder<'_> {}
19139unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentWaitFeaturesKHR {}
19140impl<'a> ::std::ops::Deref for PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
19141 type Target = PhysicalDevicePresentWaitFeaturesKHR;
19142 fn deref(&self) -> &Self::Target {
19143 &self.inner
19144 }
19145}
19146impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
19147 fn deref_mut(&mut self) -> &mut Self::Target {
19148 &mut self.inner
19149 }
19150}
19151impl<'a> PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
19152 pub fn present_wait(mut self, present_wait: bool) -> Self {
19153 self.inner.present_wait = present_wait.into();
19154 self
19155 }
19156 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19157 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19158 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19159 pub fn build(self) -> PhysicalDevicePresentWaitFeaturesKHR {
19160 self.inner
19161 }
19162}
19163#[repr(C)]
19164#[cfg_attr(feature = "debug", derive(Debug))]
19165#[derive(Copy, Clone)]
19166#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkHdrMetadataEXT.html>"]
19167pub struct HdrMetadataEXT {
19168 pub s_type: StructureType,
19169 pub p_next: *const c_void,
19170 pub display_primary_red: XYColorEXT,
19171 pub display_primary_green: XYColorEXT,
19172 pub display_primary_blue: XYColorEXT,
19173 pub white_point: XYColorEXT,
19174 pub max_luminance: f32,
19175 pub min_luminance: f32,
19176 pub max_content_light_level: f32,
19177 pub max_frame_average_light_level: f32,
19178}
19179impl ::std::default::Default for HdrMetadataEXT {
19180 fn default() -> Self {
19181 Self {
19182 s_type: StructureType::HDR_METADATA_EXT,
19183 p_next: ::std::ptr::null(),
19184 display_primary_red: XYColorEXT::default(),
19185 display_primary_green: XYColorEXT::default(),
19186 display_primary_blue: XYColorEXT::default(),
19187 white_point: XYColorEXT::default(),
19188 max_luminance: f32::default(),
19189 min_luminance: f32::default(),
19190 max_content_light_level: f32::default(),
19191 max_frame_average_light_level: f32::default(),
19192 }
19193 }
19194}
19195impl HdrMetadataEXT {
19196 pub fn builder<'a>() -> HdrMetadataEXTBuilder<'a> {
19197 HdrMetadataEXTBuilder {
19198 inner: Self::default(),
19199 marker: ::std::marker::PhantomData,
19200 }
19201 }
19202}
19203#[repr(transparent)]
19204pub struct HdrMetadataEXTBuilder<'a> {
19205 inner: HdrMetadataEXT,
19206 marker: ::std::marker::PhantomData<&'a ()>,
19207}
19208impl<'a> ::std::ops::Deref for HdrMetadataEXTBuilder<'a> {
19209 type Target = HdrMetadataEXT;
19210 fn deref(&self) -> &Self::Target {
19211 &self.inner
19212 }
19213}
19214impl<'a> ::std::ops::DerefMut for HdrMetadataEXTBuilder<'a> {
19215 fn deref_mut(&mut self) -> &mut Self::Target {
19216 &mut self.inner
19217 }
19218}
19219impl<'a> HdrMetadataEXTBuilder<'a> {
19220 pub fn display_primary_red(mut self, display_primary_red: XYColorEXT) -> Self {
19221 self.inner.display_primary_red = display_primary_red;
19222 self
19223 }
19224 pub fn display_primary_green(mut self, display_primary_green: XYColorEXT) -> Self {
19225 self.inner.display_primary_green = display_primary_green;
19226 self
19227 }
19228 pub fn display_primary_blue(mut self, display_primary_blue: XYColorEXT) -> Self {
19229 self.inner.display_primary_blue = display_primary_blue;
19230 self
19231 }
19232 pub fn white_point(mut self, white_point: XYColorEXT) -> Self {
19233 self.inner.white_point = white_point;
19234 self
19235 }
19236 pub fn max_luminance(mut self, max_luminance: f32) -> Self {
19237 self.inner.max_luminance = max_luminance;
19238 self
19239 }
19240 pub fn min_luminance(mut self, min_luminance: f32) -> Self {
19241 self.inner.min_luminance = min_luminance;
19242 self
19243 }
19244 pub fn max_content_light_level(mut self, max_content_light_level: f32) -> Self {
19245 self.inner.max_content_light_level = max_content_light_level;
19246 self
19247 }
19248 pub fn max_frame_average_light_level(mut self, max_frame_average_light_level: f32) -> Self {
19249 self.inner.max_frame_average_light_level = max_frame_average_light_level;
19250 self
19251 }
19252 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19253 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19254 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19255 pub fn build(self) -> HdrMetadataEXT {
19256 self.inner
19257 }
19258}
19259#[repr(C)]
19260#[cfg_attr(feature = "debug", derive(Debug))]
19261#[derive(Copy, Clone)]
19262#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayNativeHdrSurfaceCapabilitiesAMD.html>"]
19263pub struct DisplayNativeHdrSurfaceCapabilitiesAMD {
19264 pub s_type: StructureType,
19265 pub p_next: *mut c_void,
19266 pub local_dimming_support: Bool32,
19267}
19268impl ::std::default::Default for DisplayNativeHdrSurfaceCapabilitiesAMD {
19269 fn default() -> Self {
19270 Self {
19271 s_type: StructureType::DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD,
19272 p_next: ::std::ptr::null_mut(),
19273 local_dimming_support: Bool32::default(),
19274 }
19275 }
19276}
19277impl DisplayNativeHdrSurfaceCapabilitiesAMD {
19278 pub fn builder<'a>() -> DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
19279 DisplayNativeHdrSurfaceCapabilitiesAMDBuilder {
19280 inner: Self::default(),
19281 marker: ::std::marker::PhantomData,
19282 }
19283 }
19284}
19285#[repr(transparent)]
19286pub struct DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
19287 inner: DisplayNativeHdrSurfaceCapabilitiesAMD,
19288 marker: ::std::marker::PhantomData<&'a ()>,
19289}
19290unsafe impl ExtendsSurfaceCapabilities2KHR for DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'_> {}
19291unsafe impl ExtendsSurfaceCapabilities2KHR for DisplayNativeHdrSurfaceCapabilitiesAMD {}
19292impl<'a> ::std::ops::Deref for DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
19293 type Target = DisplayNativeHdrSurfaceCapabilitiesAMD;
19294 fn deref(&self) -> &Self::Target {
19295 &self.inner
19296 }
19297}
19298impl<'a> ::std::ops::DerefMut for DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
19299 fn deref_mut(&mut self) -> &mut Self::Target {
19300 &mut self.inner
19301 }
19302}
19303impl<'a> DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
19304 pub fn local_dimming_support(mut self, local_dimming_support: bool) -> Self {
19305 self.inner.local_dimming_support = local_dimming_support.into();
19306 self
19307 }
19308 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19309 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19310 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19311 pub fn build(self) -> DisplayNativeHdrSurfaceCapabilitiesAMD {
19312 self.inner
19313 }
19314}
19315#[repr(C)]
19316#[cfg_attr(feature = "debug", derive(Debug))]
19317#[derive(Copy, Clone)]
19318#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainDisplayNativeHdrCreateInfoAMD.html>"]
19319pub struct SwapchainDisplayNativeHdrCreateInfoAMD {
19320 pub s_type: StructureType,
19321 pub p_next: *const c_void,
19322 pub local_dimming_enable: Bool32,
19323}
19324impl ::std::default::Default for SwapchainDisplayNativeHdrCreateInfoAMD {
19325 fn default() -> Self {
19326 Self {
19327 s_type: StructureType::SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD,
19328 p_next: ::std::ptr::null(),
19329 local_dimming_enable: Bool32::default(),
19330 }
19331 }
19332}
19333impl SwapchainDisplayNativeHdrCreateInfoAMD {
19334 pub fn builder<'a>() -> SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
19335 SwapchainDisplayNativeHdrCreateInfoAMDBuilder {
19336 inner: Self::default(),
19337 marker: ::std::marker::PhantomData,
19338 }
19339 }
19340}
19341#[repr(transparent)]
19342pub struct SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
19343 inner: SwapchainDisplayNativeHdrCreateInfoAMD,
19344 marker: ::std::marker::PhantomData<&'a ()>,
19345}
19346unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'_> {}
19347unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainDisplayNativeHdrCreateInfoAMD {}
19348impl<'a> ::std::ops::Deref for SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
19349 type Target = SwapchainDisplayNativeHdrCreateInfoAMD;
19350 fn deref(&self) -> &Self::Target {
19351 &self.inner
19352 }
19353}
19354impl<'a> ::std::ops::DerefMut for SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
19355 fn deref_mut(&mut self) -> &mut Self::Target {
19356 &mut self.inner
19357 }
19358}
19359impl<'a> SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
19360 pub fn local_dimming_enable(mut self, local_dimming_enable: bool) -> Self {
19361 self.inner.local_dimming_enable = local_dimming_enable.into();
19362 self
19363 }
19364 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19365 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19366 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19367 pub fn build(self) -> SwapchainDisplayNativeHdrCreateInfoAMD {
19368 self.inner
19369 }
19370}
19371#[repr(C)]
19372#[cfg_attr(feature = "debug", derive(Debug))]
19373#[derive(Copy, Clone, Default)]
19374#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRefreshCycleDurationGOOGLE.html>"]
19375pub struct RefreshCycleDurationGOOGLE {
19376 pub refresh_duration: u64,
19377}
19378impl RefreshCycleDurationGOOGLE {
19379 pub fn builder<'a>() -> RefreshCycleDurationGOOGLEBuilder<'a> {
19380 RefreshCycleDurationGOOGLEBuilder {
19381 inner: Self::default(),
19382 marker: ::std::marker::PhantomData,
19383 }
19384 }
19385}
19386#[repr(transparent)]
19387pub struct RefreshCycleDurationGOOGLEBuilder<'a> {
19388 inner: RefreshCycleDurationGOOGLE,
19389 marker: ::std::marker::PhantomData<&'a ()>,
19390}
19391impl<'a> ::std::ops::Deref for RefreshCycleDurationGOOGLEBuilder<'a> {
19392 type Target = RefreshCycleDurationGOOGLE;
19393 fn deref(&self) -> &Self::Target {
19394 &self.inner
19395 }
19396}
19397impl<'a> ::std::ops::DerefMut for RefreshCycleDurationGOOGLEBuilder<'a> {
19398 fn deref_mut(&mut self) -> &mut Self::Target {
19399 &mut self.inner
19400 }
19401}
19402impl<'a> RefreshCycleDurationGOOGLEBuilder<'a> {
19403 pub fn refresh_duration(mut self, refresh_duration: u64) -> Self {
19404 self.inner.refresh_duration = refresh_duration;
19405 self
19406 }
19407 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19408 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19409 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19410 pub fn build(self) -> RefreshCycleDurationGOOGLE {
19411 self.inner
19412 }
19413}
19414#[repr(C)]
19415#[cfg_attr(feature = "debug", derive(Debug))]
19416#[derive(Copy, Clone, Default)]
19417#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPastPresentationTimingGOOGLE.html>"]
19418pub struct PastPresentationTimingGOOGLE {
19419 pub present_id: u32,
19420 pub desired_present_time: u64,
19421 pub actual_present_time: u64,
19422 pub earliest_present_time: u64,
19423 pub present_margin: u64,
19424}
19425impl PastPresentationTimingGOOGLE {
19426 pub fn builder<'a>() -> PastPresentationTimingGOOGLEBuilder<'a> {
19427 PastPresentationTimingGOOGLEBuilder {
19428 inner: Self::default(),
19429 marker: ::std::marker::PhantomData,
19430 }
19431 }
19432}
19433#[repr(transparent)]
19434pub struct PastPresentationTimingGOOGLEBuilder<'a> {
19435 inner: PastPresentationTimingGOOGLE,
19436 marker: ::std::marker::PhantomData<&'a ()>,
19437}
19438impl<'a> ::std::ops::Deref for PastPresentationTimingGOOGLEBuilder<'a> {
19439 type Target = PastPresentationTimingGOOGLE;
19440 fn deref(&self) -> &Self::Target {
19441 &self.inner
19442 }
19443}
19444impl<'a> ::std::ops::DerefMut for PastPresentationTimingGOOGLEBuilder<'a> {
19445 fn deref_mut(&mut self) -> &mut Self::Target {
19446 &mut self.inner
19447 }
19448}
19449impl<'a> PastPresentationTimingGOOGLEBuilder<'a> {
19450 pub fn present_id(mut self, present_id: u32) -> Self {
19451 self.inner.present_id = present_id;
19452 self
19453 }
19454 pub fn desired_present_time(mut self, desired_present_time: u64) -> Self {
19455 self.inner.desired_present_time = desired_present_time;
19456 self
19457 }
19458 pub fn actual_present_time(mut self, actual_present_time: u64) -> Self {
19459 self.inner.actual_present_time = actual_present_time;
19460 self
19461 }
19462 pub fn earliest_present_time(mut self, earliest_present_time: u64) -> Self {
19463 self.inner.earliest_present_time = earliest_present_time;
19464 self
19465 }
19466 pub fn present_margin(mut self, present_margin: u64) -> Self {
19467 self.inner.present_margin = present_margin;
19468 self
19469 }
19470 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19471 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19472 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19473 pub fn build(self) -> PastPresentationTimingGOOGLE {
19474 self.inner
19475 }
19476}
19477#[repr(C)]
19478#[cfg_attr(feature = "debug", derive(Debug))]
19479#[derive(Copy, Clone)]
19480#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentTimesInfoGOOGLE.html>"]
19481pub struct PresentTimesInfoGOOGLE {
19482 pub s_type: StructureType,
19483 pub p_next: *const c_void,
19484 pub swapchain_count: u32,
19485 pub p_times: *const PresentTimeGOOGLE,
19486}
19487impl ::std::default::Default for PresentTimesInfoGOOGLE {
19488 fn default() -> Self {
19489 Self {
19490 s_type: StructureType::PRESENT_TIMES_INFO_GOOGLE,
19491 p_next: ::std::ptr::null(),
19492 swapchain_count: u32::default(),
19493 p_times: ::std::ptr::null(),
19494 }
19495 }
19496}
19497impl PresentTimesInfoGOOGLE {
19498 pub fn builder<'a>() -> PresentTimesInfoGOOGLEBuilder<'a> {
19499 PresentTimesInfoGOOGLEBuilder {
19500 inner: Self::default(),
19501 marker: ::std::marker::PhantomData,
19502 }
19503 }
19504}
19505#[repr(transparent)]
19506pub struct PresentTimesInfoGOOGLEBuilder<'a> {
19507 inner: PresentTimesInfoGOOGLE,
19508 marker: ::std::marker::PhantomData<&'a ()>,
19509}
19510unsafe impl ExtendsPresentInfoKHR for PresentTimesInfoGOOGLEBuilder<'_> {}
19511unsafe impl ExtendsPresentInfoKHR for PresentTimesInfoGOOGLE {}
19512impl<'a> ::std::ops::Deref for PresentTimesInfoGOOGLEBuilder<'a> {
19513 type Target = PresentTimesInfoGOOGLE;
19514 fn deref(&self) -> &Self::Target {
19515 &self.inner
19516 }
19517}
19518impl<'a> ::std::ops::DerefMut for PresentTimesInfoGOOGLEBuilder<'a> {
19519 fn deref_mut(&mut self) -> &mut Self::Target {
19520 &mut self.inner
19521 }
19522}
19523impl<'a> PresentTimesInfoGOOGLEBuilder<'a> {
19524 pub fn times(mut self, times: &'a [PresentTimeGOOGLE]) -> Self {
19525 self.inner.swapchain_count = times.len() as _;
19526 self.inner.p_times = times.as_ptr();
19527 self
19528 }
19529 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19530 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19531 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19532 pub fn build(self) -> PresentTimesInfoGOOGLE {
19533 self.inner
19534 }
19535}
19536#[repr(C)]
19537#[cfg_attr(feature = "debug", derive(Debug))]
19538#[derive(Copy, Clone, Default)]
19539#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentTimeGOOGLE.html>"]
19540pub struct PresentTimeGOOGLE {
19541 pub present_id: u32,
19542 pub desired_present_time: u64,
19543}
19544impl PresentTimeGOOGLE {
19545 pub fn builder<'a>() -> PresentTimeGOOGLEBuilder<'a> {
19546 PresentTimeGOOGLEBuilder {
19547 inner: Self::default(),
19548 marker: ::std::marker::PhantomData,
19549 }
19550 }
19551}
19552#[repr(transparent)]
19553pub struct PresentTimeGOOGLEBuilder<'a> {
19554 inner: PresentTimeGOOGLE,
19555 marker: ::std::marker::PhantomData<&'a ()>,
19556}
19557impl<'a> ::std::ops::Deref for PresentTimeGOOGLEBuilder<'a> {
19558 type Target = PresentTimeGOOGLE;
19559 fn deref(&self) -> &Self::Target {
19560 &self.inner
19561 }
19562}
19563impl<'a> ::std::ops::DerefMut for PresentTimeGOOGLEBuilder<'a> {
19564 fn deref_mut(&mut self) -> &mut Self::Target {
19565 &mut self.inner
19566 }
19567}
19568impl<'a> PresentTimeGOOGLEBuilder<'a> {
19569 pub fn present_id(mut self, present_id: u32) -> Self {
19570 self.inner.present_id = present_id;
19571 self
19572 }
19573 pub fn desired_present_time(mut self, desired_present_time: u64) -> Self {
19574 self.inner.desired_present_time = desired_present_time;
19575 self
19576 }
19577 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19578 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19579 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19580 pub fn build(self) -> PresentTimeGOOGLE {
19581 self.inner
19582 }
19583}
19584#[repr(C)]
19585#[cfg_attr(feature = "debug", derive(Debug))]
19586#[derive(Copy, Clone)]
19587#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIOSSurfaceCreateInfoMVK.html>"]
19588pub struct IOSSurfaceCreateInfoMVK {
19589 pub s_type: StructureType,
19590 pub p_next: *const c_void,
19591 pub flags: IOSSurfaceCreateFlagsMVK,
19592 pub p_view: *const c_void,
19593}
19594impl ::std::default::Default for IOSSurfaceCreateInfoMVK {
19595 fn default() -> Self {
19596 Self {
19597 s_type: StructureType::IOS_SURFACE_CREATE_INFO_MVK,
19598 p_next: ::std::ptr::null(),
19599 flags: IOSSurfaceCreateFlagsMVK::default(),
19600 p_view: ::std::ptr::null(),
19601 }
19602 }
19603}
19604impl IOSSurfaceCreateInfoMVK {
19605 pub fn builder<'a>() -> IOSSurfaceCreateInfoMVKBuilder<'a> {
19606 IOSSurfaceCreateInfoMVKBuilder {
19607 inner: Self::default(),
19608 marker: ::std::marker::PhantomData,
19609 }
19610 }
19611}
19612#[repr(transparent)]
19613pub struct IOSSurfaceCreateInfoMVKBuilder<'a> {
19614 inner: IOSSurfaceCreateInfoMVK,
19615 marker: ::std::marker::PhantomData<&'a ()>,
19616}
19617impl<'a> ::std::ops::Deref for IOSSurfaceCreateInfoMVKBuilder<'a> {
19618 type Target = IOSSurfaceCreateInfoMVK;
19619 fn deref(&self) -> &Self::Target {
19620 &self.inner
19621 }
19622}
19623impl<'a> ::std::ops::DerefMut for IOSSurfaceCreateInfoMVKBuilder<'a> {
19624 fn deref_mut(&mut self) -> &mut Self::Target {
19625 &mut self.inner
19626 }
19627}
19628impl<'a> IOSSurfaceCreateInfoMVKBuilder<'a> {
19629 pub fn flags(mut self, flags: IOSSurfaceCreateFlagsMVK) -> Self {
19630 self.inner.flags = flags;
19631 self
19632 }
19633 pub fn view(mut self, view: *const c_void) -> Self {
19634 self.inner.p_view = view;
19635 self
19636 }
19637 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19638 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19639 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19640 pub fn build(self) -> IOSSurfaceCreateInfoMVK {
19641 self.inner
19642 }
19643}
19644#[repr(C)]
19645#[cfg_attr(feature = "debug", derive(Debug))]
19646#[derive(Copy, Clone)]
19647#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMacOSSurfaceCreateInfoMVK.html>"]
19648pub struct MacOSSurfaceCreateInfoMVK {
19649 pub s_type: StructureType,
19650 pub p_next: *const c_void,
19651 pub flags: MacOSSurfaceCreateFlagsMVK,
19652 pub p_view: *const c_void,
19653}
19654impl ::std::default::Default for MacOSSurfaceCreateInfoMVK {
19655 fn default() -> Self {
19656 Self {
19657 s_type: StructureType::MACOS_SURFACE_CREATE_INFO_MVK,
19658 p_next: ::std::ptr::null(),
19659 flags: MacOSSurfaceCreateFlagsMVK::default(),
19660 p_view: ::std::ptr::null(),
19661 }
19662 }
19663}
19664impl MacOSSurfaceCreateInfoMVK {
19665 pub fn builder<'a>() -> MacOSSurfaceCreateInfoMVKBuilder<'a> {
19666 MacOSSurfaceCreateInfoMVKBuilder {
19667 inner: Self::default(),
19668 marker: ::std::marker::PhantomData,
19669 }
19670 }
19671}
19672#[repr(transparent)]
19673pub struct MacOSSurfaceCreateInfoMVKBuilder<'a> {
19674 inner: MacOSSurfaceCreateInfoMVK,
19675 marker: ::std::marker::PhantomData<&'a ()>,
19676}
19677impl<'a> ::std::ops::Deref for MacOSSurfaceCreateInfoMVKBuilder<'a> {
19678 type Target = MacOSSurfaceCreateInfoMVK;
19679 fn deref(&self) -> &Self::Target {
19680 &self.inner
19681 }
19682}
19683impl<'a> ::std::ops::DerefMut for MacOSSurfaceCreateInfoMVKBuilder<'a> {
19684 fn deref_mut(&mut self) -> &mut Self::Target {
19685 &mut self.inner
19686 }
19687}
19688impl<'a> MacOSSurfaceCreateInfoMVKBuilder<'a> {
19689 pub fn flags(mut self, flags: MacOSSurfaceCreateFlagsMVK) -> Self {
19690 self.inner.flags = flags;
19691 self
19692 }
19693 pub fn view(mut self, view: *const c_void) -> Self {
19694 self.inner.p_view = view;
19695 self
19696 }
19697 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19698 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19699 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19700 pub fn build(self) -> MacOSSurfaceCreateInfoMVK {
19701 self.inner
19702 }
19703}
19704#[repr(C)]
19705#[cfg_attr(feature = "debug", derive(Debug))]
19706#[derive(Copy, Clone)]
19707#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMetalSurfaceCreateInfoEXT.html>"]
19708pub struct MetalSurfaceCreateInfoEXT {
19709 pub s_type: StructureType,
19710 pub p_next: *const c_void,
19711 pub flags: MetalSurfaceCreateFlagsEXT,
19712 pub p_layer: *const CAMetalLayer,
19713}
19714impl ::std::default::Default for MetalSurfaceCreateInfoEXT {
19715 fn default() -> Self {
19716 Self {
19717 s_type: StructureType::METAL_SURFACE_CREATE_INFO_EXT,
19718 p_next: ::std::ptr::null(),
19719 flags: MetalSurfaceCreateFlagsEXT::default(),
19720 p_layer: ::std::ptr::null(),
19721 }
19722 }
19723}
19724impl MetalSurfaceCreateInfoEXT {
19725 pub fn builder<'a>() -> MetalSurfaceCreateInfoEXTBuilder<'a> {
19726 MetalSurfaceCreateInfoEXTBuilder {
19727 inner: Self::default(),
19728 marker: ::std::marker::PhantomData,
19729 }
19730 }
19731}
19732#[repr(transparent)]
19733pub struct MetalSurfaceCreateInfoEXTBuilder<'a> {
19734 inner: MetalSurfaceCreateInfoEXT,
19735 marker: ::std::marker::PhantomData<&'a ()>,
19736}
19737impl<'a> ::std::ops::Deref for MetalSurfaceCreateInfoEXTBuilder<'a> {
19738 type Target = MetalSurfaceCreateInfoEXT;
19739 fn deref(&self) -> &Self::Target {
19740 &self.inner
19741 }
19742}
19743impl<'a> ::std::ops::DerefMut for MetalSurfaceCreateInfoEXTBuilder<'a> {
19744 fn deref_mut(&mut self) -> &mut Self::Target {
19745 &mut self.inner
19746 }
19747}
19748impl<'a> MetalSurfaceCreateInfoEXTBuilder<'a> {
19749 pub fn flags(mut self, flags: MetalSurfaceCreateFlagsEXT) -> Self {
19750 self.inner.flags = flags;
19751 self
19752 }
19753 pub fn layer(mut self, layer: *const CAMetalLayer) -> Self {
19754 self.inner.p_layer = layer;
19755 self
19756 }
19757 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19758 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19759 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19760 pub fn build(self) -> MetalSurfaceCreateInfoEXT {
19761 self.inner
19762 }
19763}
19764#[repr(C)]
19765#[cfg_attr(feature = "debug", derive(Debug))]
19766#[derive(Copy, Clone, Default)]
19767#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkViewportWScalingNV.html>"]
19768pub struct ViewportWScalingNV {
19769 pub xcoeff: f32,
19770 pub ycoeff: f32,
19771}
19772impl ViewportWScalingNV {
19773 pub fn builder<'a>() -> ViewportWScalingNVBuilder<'a> {
19774 ViewportWScalingNVBuilder {
19775 inner: Self::default(),
19776 marker: ::std::marker::PhantomData,
19777 }
19778 }
19779}
19780#[repr(transparent)]
19781pub struct ViewportWScalingNVBuilder<'a> {
19782 inner: ViewportWScalingNV,
19783 marker: ::std::marker::PhantomData<&'a ()>,
19784}
19785impl<'a> ::std::ops::Deref for ViewportWScalingNVBuilder<'a> {
19786 type Target = ViewportWScalingNV;
19787 fn deref(&self) -> &Self::Target {
19788 &self.inner
19789 }
19790}
19791impl<'a> ::std::ops::DerefMut for ViewportWScalingNVBuilder<'a> {
19792 fn deref_mut(&mut self) -> &mut Self::Target {
19793 &mut self.inner
19794 }
19795}
19796impl<'a> ViewportWScalingNVBuilder<'a> {
19797 pub fn xcoeff(mut self, xcoeff: f32) -> Self {
19798 self.inner.xcoeff = xcoeff;
19799 self
19800 }
19801 pub fn ycoeff(mut self, ycoeff: f32) -> Self {
19802 self.inner.ycoeff = ycoeff;
19803 self
19804 }
19805 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19806 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19807 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19808 pub fn build(self) -> ViewportWScalingNV {
19809 self.inner
19810 }
19811}
19812#[repr(C)]
19813#[cfg_attr(feature = "debug", derive(Debug))]
19814#[derive(Copy, Clone)]
19815#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportWScalingStateCreateInfoNV.html>"]
19816pub struct PipelineViewportWScalingStateCreateInfoNV {
19817 pub s_type: StructureType,
19818 pub p_next: *const c_void,
19819 pub viewport_w_scaling_enable: Bool32,
19820 pub viewport_count: u32,
19821 pub p_viewport_w_scalings: *const ViewportWScalingNV,
19822}
19823impl ::std::default::Default for PipelineViewportWScalingStateCreateInfoNV {
19824 fn default() -> Self {
19825 Self {
19826 s_type: StructureType::PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV,
19827 p_next: ::std::ptr::null(),
19828 viewport_w_scaling_enable: Bool32::default(),
19829 viewport_count: u32::default(),
19830 p_viewport_w_scalings: ::std::ptr::null(),
19831 }
19832 }
19833}
19834impl PipelineViewportWScalingStateCreateInfoNV {
19835 pub fn builder<'a>() -> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
19836 PipelineViewportWScalingStateCreateInfoNVBuilder {
19837 inner: Self::default(),
19838 marker: ::std::marker::PhantomData,
19839 }
19840 }
19841}
19842#[repr(transparent)]
19843pub struct PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
19844 inner: PipelineViewportWScalingStateCreateInfoNV,
19845 marker: ::std::marker::PhantomData<&'a ()>,
19846}
19847unsafe impl ExtendsPipelineViewportStateCreateInfo
19848 for PipelineViewportWScalingStateCreateInfoNVBuilder<'_>
19849{
19850}
19851unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportWScalingStateCreateInfoNV {}
19852impl<'a> ::std::ops::Deref for PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
19853 type Target = PipelineViewportWScalingStateCreateInfoNV;
19854 fn deref(&self) -> &Self::Target {
19855 &self.inner
19856 }
19857}
19858impl<'a> ::std::ops::DerefMut for PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
19859 fn deref_mut(&mut self) -> &mut Self::Target {
19860 &mut self.inner
19861 }
19862}
19863impl<'a> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
19864 pub fn viewport_w_scaling_enable(mut self, viewport_w_scaling_enable: bool) -> Self {
19865 self.inner.viewport_w_scaling_enable = viewport_w_scaling_enable.into();
19866 self
19867 }
19868 pub fn viewport_w_scalings(mut self, viewport_w_scalings: &'a [ViewportWScalingNV]) -> Self {
19869 self.inner.viewport_count = viewport_w_scalings.len() as _;
19870 self.inner.p_viewport_w_scalings = viewport_w_scalings.as_ptr();
19871 self
19872 }
19873 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19874 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19875 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19876 pub fn build(self) -> PipelineViewportWScalingStateCreateInfoNV {
19877 self.inner
19878 }
19879}
19880#[repr(C)]
19881#[cfg_attr(feature = "debug", derive(Debug))]
19882#[derive(Copy, Clone, Default)]
19883#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkViewportSwizzleNV.html>"]
19884pub struct ViewportSwizzleNV {
19885 pub x: ViewportCoordinateSwizzleNV,
19886 pub y: ViewportCoordinateSwizzleNV,
19887 pub z: ViewportCoordinateSwizzleNV,
19888 pub w: ViewportCoordinateSwizzleNV,
19889}
19890impl ViewportSwizzleNV {
19891 pub fn builder<'a>() -> ViewportSwizzleNVBuilder<'a> {
19892 ViewportSwizzleNVBuilder {
19893 inner: Self::default(),
19894 marker: ::std::marker::PhantomData,
19895 }
19896 }
19897}
19898#[repr(transparent)]
19899pub struct ViewportSwizzleNVBuilder<'a> {
19900 inner: ViewportSwizzleNV,
19901 marker: ::std::marker::PhantomData<&'a ()>,
19902}
19903impl<'a> ::std::ops::Deref for ViewportSwizzleNVBuilder<'a> {
19904 type Target = ViewportSwizzleNV;
19905 fn deref(&self) -> &Self::Target {
19906 &self.inner
19907 }
19908}
19909impl<'a> ::std::ops::DerefMut for ViewportSwizzleNVBuilder<'a> {
19910 fn deref_mut(&mut self) -> &mut Self::Target {
19911 &mut self.inner
19912 }
19913}
19914impl<'a> ViewportSwizzleNVBuilder<'a> {
19915 pub fn x(mut self, x: ViewportCoordinateSwizzleNV) -> Self {
19916 self.inner.x = x;
19917 self
19918 }
19919 pub fn y(mut self, y: ViewportCoordinateSwizzleNV) -> Self {
19920 self.inner.y = y;
19921 self
19922 }
19923 pub fn z(mut self, z: ViewportCoordinateSwizzleNV) -> Self {
19924 self.inner.z = z;
19925 self
19926 }
19927 pub fn w(mut self, w: ViewportCoordinateSwizzleNV) -> Self {
19928 self.inner.w = w;
19929 self
19930 }
19931 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19932 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19933 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19934 pub fn build(self) -> ViewportSwizzleNV {
19935 self.inner
19936 }
19937}
19938#[repr(C)]
19939#[cfg_attr(feature = "debug", derive(Debug))]
19940#[derive(Copy, Clone)]
19941#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportSwizzleStateCreateInfoNV.html>"]
19942pub struct PipelineViewportSwizzleStateCreateInfoNV {
19943 pub s_type: StructureType,
19944 pub p_next: *const c_void,
19945 pub flags: PipelineViewportSwizzleStateCreateFlagsNV,
19946 pub viewport_count: u32,
19947 pub p_viewport_swizzles: *const ViewportSwizzleNV,
19948}
19949impl ::std::default::Default for PipelineViewportSwizzleStateCreateInfoNV {
19950 fn default() -> Self {
19951 Self {
19952 s_type: StructureType::PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV,
19953 p_next: ::std::ptr::null(),
19954 flags: PipelineViewportSwizzleStateCreateFlagsNV::default(),
19955 viewport_count: u32::default(),
19956 p_viewport_swizzles: ::std::ptr::null(),
19957 }
19958 }
19959}
19960impl PipelineViewportSwizzleStateCreateInfoNV {
19961 pub fn builder<'a>() -> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
19962 PipelineViewportSwizzleStateCreateInfoNVBuilder {
19963 inner: Self::default(),
19964 marker: ::std::marker::PhantomData,
19965 }
19966 }
19967}
19968#[repr(transparent)]
19969pub struct PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
19970 inner: PipelineViewportSwizzleStateCreateInfoNV,
19971 marker: ::std::marker::PhantomData<&'a ()>,
19972}
19973unsafe impl ExtendsPipelineViewportStateCreateInfo
19974 for PipelineViewportSwizzleStateCreateInfoNVBuilder<'_>
19975{
19976}
19977unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportSwizzleStateCreateInfoNV {}
19978impl<'a> ::std::ops::Deref for PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
19979 type Target = PipelineViewportSwizzleStateCreateInfoNV;
19980 fn deref(&self) -> &Self::Target {
19981 &self.inner
19982 }
19983}
19984impl<'a> ::std::ops::DerefMut for PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
19985 fn deref_mut(&mut self) -> &mut Self::Target {
19986 &mut self.inner
19987 }
19988}
19989impl<'a> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
19990 pub fn flags(mut self, flags: PipelineViewportSwizzleStateCreateFlagsNV) -> Self {
19991 self.inner.flags = flags;
19992 self
19993 }
19994 pub fn viewport_swizzles(mut self, viewport_swizzles: &'a [ViewportSwizzleNV]) -> Self {
19995 self.inner.viewport_count = viewport_swizzles.len() as _;
19996 self.inner.p_viewport_swizzles = viewport_swizzles.as_ptr();
19997 self
19998 }
19999 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20000 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20001 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20002 pub fn build(self) -> PipelineViewportSwizzleStateCreateInfoNV {
20003 self.inner
20004 }
20005}
20006#[repr(C)]
20007#[cfg_attr(feature = "debug", derive(Debug))]
20008#[derive(Copy, Clone)]
20009#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDiscardRectanglePropertiesEXT.html>"]
20010pub struct PhysicalDeviceDiscardRectanglePropertiesEXT {
20011 pub s_type: StructureType,
20012 pub p_next: *mut c_void,
20013 pub max_discard_rectangles: u32,
20014}
20015impl ::std::default::Default for PhysicalDeviceDiscardRectanglePropertiesEXT {
20016 fn default() -> Self {
20017 Self {
20018 s_type: StructureType::PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT,
20019 p_next: ::std::ptr::null_mut(),
20020 max_discard_rectangles: u32::default(),
20021 }
20022 }
20023}
20024impl PhysicalDeviceDiscardRectanglePropertiesEXT {
20025 pub fn builder<'a>() -> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
20026 PhysicalDeviceDiscardRectanglePropertiesEXTBuilder {
20027 inner: Self::default(),
20028 marker: ::std::marker::PhantomData,
20029 }
20030 }
20031}
20032#[repr(transparent)]
20033pub struct PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
20034 inner: PhysicalDeviceDiscardRectanglePropertiesEXT,
20035 marker: ::std::marker::PhantomData<&'a ()>,
20036}
20037unsafe impl ExtendsPhysicalDeviceProperties2
20038 for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'_>
20039{
20040}
20041unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDiscardRectanglePropertiesEXT {}
20042impl<'a> ::std::ops::Deref for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
20043 type Target = PhysicalDeviceDiscardRectanglePropertiesEXT;
20044 fn deref(&self) -> &Self::Target {
20045 &self.inner
20046 }
20047}
20048impl<'a> ::std::ops::DerefMut for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
20049 fn deref_mut(&mut self) -> &mut Self::Target {
20050 &mut self.inner
20051 }
20052}
20053impl<'a> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
20054 pub fn max_discard_rectangles(mut self, max_discard_rectangles: u32) -> Self {
20055 self.inner.max_discard_rectangles = max_discard_rectangles;
20056 self
20057 }
20058 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20059 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20060 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20061 pub fn build(self) -> PhysicalDeviceDiscardRectanglePropertiesEXT {
20062 self.inner
20063 }
20064}
20065#[repr(C)]
20066#[cfg_attr(feature = "debug", derive(Debug))]
20067#[derive(Copy, Clone)]
20068#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDiscardRectangleStateCreateInfoEXT.html>"]
20069pub struct PipelineDiscardRectangleStateCreateInfoEXT {
20070 pub s_type: StructureType,
20071 pub p_next: *const c_void,
20072 pub flags: PipelineDiscardRectangleStateCreateFlagsEXT,
20073 pub discard_rectangle_mode: DiscardRectangleModeEXT,
20074 pub discard_rectangle_count: u32,
20075 pub p_discard_rectangles: *const Rect2D,
20076}
20077impl ::std::default::Default for PipelineDiscardRectangleStateCreateInfoEXT {
20078 fn default() -> Self {
20079 Self {
20080 s_type: StructureType::PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT,
20081 p_next: ::std::ptr::null(),
20082 flags: PipelineDiscardRectangleStateCreateFlagsEXT::default(),
20083 discard_rectangle_mode: DiscardRectangleModeEXT::default(),
20084 discard_rectangle_count: u32::default(),
20085 p_discard_rectangles: ::std::ptr::null(),
20086 }
20087 }
20088}
20089impl PipelineDiscardRectangleStateCreateInfoEXT {
20090 pub fn builder<'a>() -> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
20091 PipelineDiscardRectangleStateCreateInfoEXTBuilder {
20092 inner: Self::default(),
20093 marker: ::std::marker::PhantomData,
20094 }
20095 }
20096}
20097#[repr(transparent)]
20098pub struct PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
20099 inner: PipelineDiscardRectangleStateCreateInfoEXT,
20100 marker: ::std::marker::PhantomData<&'a ()>,
20101}
20102unsafe impl ExtendsGraphicsPipelineCreateInfo
20103 for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'_>
20104{
20105}
20106unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineDiscardRectangleStateCreateInfoEXT {}
20107impl<'a> ::std::ops::Deref for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
20108 type Target = PipelineDiscardRectangleStateCreateInfoEXT;
20109 fn deref(&self) -> &Self::Target {
20110 &self.inner
20111 }
20112}
20113impl<'a> ::std::ops::DerefMut for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
20114 fn deref_mut(&mut self) -> &mut Self::Target {
20115 &mut self.inner
20116 }
20117}
20118impl<'a> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
20119 pub fn flags(mut self, flags: PipelineDiscardRectangleStateCreateFlagsEXT) -> Self {
20120 self.inner.flags = flags;
20121 self
20122 }
20123 pub fn discard_rectangle_mode(
20124 mut self,
20125 discard_rectangle_mode: DiscardRectangleModeEXT,
20126 ) -> Self {
20127 self.inner.discard_rectangle_mode = discard_rectangle_mode;
20128 self
20129 }
20130 pub fn discard_rectangles(mut self, discard_rectangles: &'a [Rect2D]) -> Self {
20131 self.inner.discard_rectangle_count = discard_rectangles.len() as _;
20132 self.inner.p_discard_rectangles = discard_rectangles.as_ptr();
20133 self
20134 }
20135 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20136 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20137 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20138 pub fn build(self) -> PipelineDiscardRectangleStateCreateInfoEXT {
20139 self.inner
20140 }
20141}
20142#[repr(C)]
20143#[cfg_attr(feature = "debug", derive(Debug))]
20144#[derive(Copy, Clone)]
20145#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX.html>"]
20146pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
20147 pub s_type: StructureType,
20148 pub p_next: *mut c_void,
20149 pub per_view_position_all_components: Bool32,
20150}
20151impl ::std::default::Default for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
20152 fn default() -> Self {
20153 Self {
20154 s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX,
20155 p_next: ::std::ptr::null_mut(),
20156 per_view_position_all_components: Bool32::default(),
20157 }
20158 }
20159}
20160impl PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
20161 pub fn builder<'a>() -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
20162 PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder {
20163 inner: Self::default(),
20164 marker: ::std::marker::PhantomData,
20165 }
20166 }
20167}
20168#[repr(transparent)]
20169pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
20170 inner: PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX,
20171 marker: ::std::marker::PhantomData<&'a ()>,
20172}
20173unsafe impl ExtendsPhysicalDeviceProperties2
20174 for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'_>
20175{
20176}
20177unsafe impl ExtendsPhysicalDeviceProperties2
20178 for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
20179{
20180}
20181impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
20182 type Target = PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
20183 fn deref(&self) -> &Self::Target {
20184 &self.inner
20185 }
20186}
20187impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
20188 fn deref_mut(&mut self) -> &mut Self::Target {
20189 &mut self.inner
20190 }
20191}
20192impl<'a> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
20193 pub fn per_view_position_all_components(
20194 mut self,
20195 per_view_position_all_components: bool,
20196 ) -> Self {
20197 self.inner.per_view_position_all_components = per_view_position_all_components.into();
20198 self
20199 }
20200 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20201 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20202 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20203 pub fn build(self) -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
20204 self.inner
20205 }
20206}
20207#[repr(C)]
20208#[cfg_attr(feature = "debug", derive(Debug))]
20209#[derive(Copy, Clone, Default)]
20210#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkInputAttachmentAspectReference.html>"]
20211pub struct InputAttachmentAspectReference {
20212 pub subpass: u32,
20213 pub input_attachment_index: u32,
20214 pub aspect_mask: ImageAspectFlags,
20215}
20216impl InputAttachmentAspectReference {
20217 pub fn builder<'a>() -> InputAttachmentAspectReferenceBuilder<'a> {
20218 InputAttachmentAspectReferenceBuilder {
20219 inner: Self::default(),
20220 marker: ::std::marker::PhantomData,
20221 }
20222 }
20223}
20224#[repr(transparent)]
20225pub struct InputAttachmentAspectReferenceBuilder<'a> {
20226 inner: InputAttachmentAspectReference,
20227 marker: ::std::marker::PhantomData<&'a ()>,
20228}
20229impl<'a> ::std::ops::Deref for InputAttachmentAspectReferenceBuilder<'a> {
20230 type Target = InputAttachmentAspectReference;
20231 fn deref(&self) -> &Self::Target {
20232 &self.inner
20233 }
20234}
20235impl<'a> ::std::ops::DerefMut for InputAttachmentAspectReferenceBuilder<'a> {
20236 fn deref_mut(&mut self) -> &mut Self::Target {
20237 &mut self.inner
20238 }
20239}
20240impl<'a> InputAttachmentAspectReferenceBuilder<'a> {
20241 pub fn subpass(mut self, subpass: u32) -> Self {
20242 self.inner.subpass = subpass;
20243 self
20244 }
20245 pub fn input_attachment_index(mut self, input_attachment_index: u32) -> Self {
20246 self.inner.input_attachment_index = input_attachment_index;
20247 self
20248 }
20249 pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self {
20250 self.inner.aspect_mask = aspect_mask;
20251 self
20252 }
20253 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20254 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20255 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20256 pub fn build(self) -> InputAttachmentAspectReference {
20257 self.inner
20258 }
20259}
20260#[repr(C)]
20261#[cfg_attr(feature = "debug", derive(Debug))]
20262#[derive(Copy, Clone)]
20263#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassInputAttachmentAspectCreateInfo.html>"]
20264pub struct RenderPassInputAttachmentAspectCreateInfo {
20265 pub s_type: StructureType,
20266 pub p_next: *const c_void,
20267 pub aspect_reference_count: u32,
20268 pub p_aspect_references: *const InputAttachmentAspectReference,
20269}
20270impl ::std::default::Default for RenderPassInputAttachmentAspectCreateInfo {
20271 fn default() -> Self {
20272 Self {
20273 s_type: StructureType::RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO,
20274 p_next: ::std::ptr::null(),
20275 aspect_reference_count: u32::default(),
20276 p_aspect_references: ::std::ptr::null(),
20277 }
20278 }
20279}
20280impl RenderPassInputAttachmentAspectCreateInfo {
20281 pub fn builder<'a>() -> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
20282 RenderPassInputAttachmentAspectCreateInfoBuilder {
20283 inner: Self::default(),
20284 marker: ::std::marker::PhantomData,
20285 }
20286 }
20287}
20288#[repr(transparent)]
20289pub struct RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
20290 inner: RenderPassInputAttachmentAspectCreateInfo,
20291 marker: ::std::marker::PhantomData<&'a ()>,
20292}
20293unsafe impl ExtendsRenderPassCreateInfo for RenderPassInputAttachmentAspectCreateInfoBuilder<'_> {}
20294unsafe impl ExtendsRenderPassCreateInfo for RenderPassInputAttachmentAspectCreateInfo {}
20295impl<'a> ::std::ops::Deref for RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
20296 type Target = RenderPassInputAttachmentAspectCreateInfo;
20297 fn deref(&self) -> &Self::Target {
20298 &self.inner
20299 }
20300}
20301impl<'a> ::std::ops::DerefMut for RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
20302 fn deref_mut(&mut self) -> &mut Self::Target {
20303 &mut self.inner
20304 }
20305}
20306impl<'a> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
20307 pub fn aspect_references(
20308 mut self,
20309 aspect_references: &'a [InputAttachmentAspectReference],
20310 ) -> Self {
20311 self.inner.aspect_reference_count = aspect_references.len() as _;
20312 self.inner.p_aspect_references = aspect_references.as_ptr();
20313 self
20314 }
20315 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20316 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20317 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20318 pub fn build(self) -> RenderPassInputAttachmentAspectCreateInfo {
20319 self.inner
20320 }
20321}
20322#[repr(C)]
20323#[cfg_attr(feature = "debug", derive(Debug))]
20324#[derive(Copy, Clone)]
20325#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSurfaceInfo2KHR.html>"]
20326pub struct PhysicalDeviceSurfaceInfo2KHR {
20327 pub s_type: StructureType,
20328 pub p_next: *const c_void,
20329 pub surface: SurfaceKHR,
20330}
20331impl ::std::default::Default for PhysicalDeviceSurfaceInfo2KHR {
20332 fn default() -> Self {
20333 Self {
20334 s_type: StructureType::PHYSICAL_DEVICE_SURFACE_INFO_2_KHR,
20335 p_next: ::std::ptr::null(),
20336 surface: SurfaceKHR::default(),
20337 }
20338 }
20339}
20340impl PhysicalDeviceSurfaceInfo2KHR {
20341 pub fn builder<'a>() -> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
20342 PhysicalDeviceSurfaceInfo2KHRBuilder {
20343 inner: Self::default(),
20344 marker: ::std::marker::PhantomData,
20345 }
20346 }
20347}
20348#[repr(transparent)]
20349pub struct PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
20350 inner: PhysicalDeviceSurfaceInfo2KHR,
20351 marker: ::std::marker::PhantomData<&'a ()>,
20352}
20353pub unsafe trait ExtendsPhysicalDeviceSurfaceInfo2KHR {}
20354impl<'a> ::std::ops::Deref for PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
20355 type Target = PhysicalDeviceSurfaceInfo2KHR;
20356 fn deref(&self) -> &Self::Target {
20357 &self.inner
20358 }
20359}
20360impl<'a> ::std::ops::DerefMut for PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
20361 fn deref_mut(&mut self) -> &mut Self::Target {
20362 &mut self.inner
20363 }
20364}
20365impl<'a> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
20366 pub fn surface(mut self, surface: SurfaceKHR) -> Self {
20367 self.inner.surface = surface;
20368 self
20369 }
20370 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
20371 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
20372 #[doc = r" valid extension structs can be pushed into the chain."]
20373 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
20374 #[doc = r" chain will look like `A -> D -> B -> C`."]
20375 pub fn push_next<T: ExtendsPhysicalDeviceSurfaceInfo2KHR>(mut self, next: &'a mut T) -> Self {
20376 unsafe {
20377 let next_ptr = <*const T>::cast(next);
20378 let last_next = ptr_chain_iter(next).last().unwrap();
20379 (*last_next).p_next = self.inner.p_next as _;
20380 self.inner.p_next = next_ptr;
20381 }
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."]
20387 pub fn build(self) -> PhysicalDeviceSurfaceInfo2KHR {
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/VkSurfaceCapabilities2KHR.html>"]
20395pub struct SurfaceCapabilities2KHR {
20396 pub s_type: StructureType,
20397 pub p_next: *mut c_void,
20398 pub surface_capabilities: SurfaceCapabilitiesKHR,
20399}
20400impl ::std::default::Default for SurfaceCapabilities2KHR {
20401 fn default() -> Self {
20402 Self {
20403 s_type: StructureType::SURFACE_CAPABILITIES_2_KHR,
20404 p_next: ::std::ptr::null_mut(),
20405 surface_capabilities: SurfaceCapabilitiesKHR::default(),
20406 }
20407 }
20408}
20409impl SurfaceCapabilities2KHR {
20410 pub fn builder<'a>() -> SurfaceCapabilities2KHRBuilder<'a> {
20411 SurfaceCapabilities2KHRBuilder {
20412 inner: Self::default(),
20413 marker: ::std::marker::PhantomData,
20414 }
20415 }
20416}
20417#[repr(transparent)]
20418pub struct SurfaceCapabilities2KHRBuilder<'a> {
20419 inner: SurfaceCapabilities2KHR,
20420 marker: ::std::marker::PhantomData<&'a ()>,
20421}
20422pub unsafe trait ExtendsSurfaceCapabilities2KHR {}
20423impl<'a> ::std::ops::Deref for SurfaceCapabilities2KHRBuilder<'a> {
20424 type Target = SurfaceCapabilities2KHR;
20425 fn deref(&self) -> &Self::Target {
20426 &self.inner
20427 }
20428}
20429impl<'a> ::std::ops::DerefMut for SurfaceCapabilities2KHRBuilder<'a> {
20430 fn deref_mut(&mut self) -> &mut Self::Target {
20431 &mut self.inner
20432 }
20433}
20434impl<'a> SurfaceCapabilities2KHRBuilder<'a> {
20435 pub fn surface_capabilities(mut self, surface_capabilities: SurfaceCapabilitiesKHR) -> Self {
20436 self.inner.surface_capabilities = surface_capabilities;
20437 self
20438 }
20439 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
20440 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
20441 #[doc = r" valid extension structs can be pushed into the chain."]
20442 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
20443 #[doc = r" chain will look like `A -> D -> B -> C`."]
20444 pub fn push_next<T: ExtendsSurfaceCapabilities2KHR>(mut self, next: &'a mut T) -> Self {
20445 unsafe {
20446 let next_ptr = <*mut T>::cast(next);
20447 let last_next = ptr_chain_iter(next).last().unwrap();
20448 (*last_next).p_next = self.inner.p_next as _;
20449 self.inner.p_next = next_ptr;
20450 }
20451 self
20452 }
20453 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20454 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20455 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20456 pub fn build(self) -> SurfaceCapabilities2KHR {
20457 self.inner
20458 }
20459}
20460#[repr(C)]
20461#[cfg_attr(feature = "debug", derive(Debug))]
20462#[derive(Copy, Clone)]
20463#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceFormat2KHR.html>"]
20464pub struct SurfaceFormat2KHR {
20465 pub s_type: StructureType,
20466 pub p_next: *mut c_void,
20467 pub surface_format: SurfaceFormatKHR,
20468}
20469impl ::std::default::Default for SurfaceFormat2KHR {
20470 fn default() -> Self {
20471 Self {
20472 s_type: StructureType::SURFACE_FORMAT_2_KHR,
20473 p_next: ::std::ptr::null_mut(),
20474 surface_format: SurfaceFormatKHR::default(),
20475 }
20476 }
20477}
20478impl SurfaceFormat2KHR {
20479 pub fn builder<'a>() -> SurfaceFormat2KHRBuilder<'a> {
20480 SurfaceFormat2KHRBuilder {
20481 inner: Self::default(),
20482 marker: ::std::marker::PhantomData,
20483 }
20484 }
20485}
20486#[repr(transparent)]
20487pub struct SurfaceFormat2KHRBuilder<'a> {
20488 inner: SurfaceFormat2KHR,
20489 marker: ::std::marker::PhantomData<&'a ()>,
20490}
20491impl<'a> ::std::ops::Deref for SurfaceFormat2KHRBuilder<'a> {
20492 type Target = SurfaceFormat2KHR;
20493 fn deref(&self) -> &Self::Target {
20494 &self.inner
20495 }
20496}
20497impl<'a> ::std::ops::DerefMut for SurfaceFormat2KHRBuilder<'a> {
20498 fn deref_mut(&mut self) -> &mut Self::Target {
20499 &mut self.inner
20500 }
20501}
20502impl<'a> SurfaceFormat2KHRBuilder<'a> {
20503 pub fn surface_format(mut self, surface_format: SurfaceFormatKHR) -> Self {
20504 self.inner.surface_format = surface_format;
20505 self
20506 }
20507 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20508 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20509 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20510 pub fn build(self) -> SurfaceFormat2KHR {
20511 self.inner
20512 }
20513}
20514#[repr(C)]
20515#[cfg_attr(feature = "debug", derive(Debug))]
20516#[derive(Copy, Clone)]
20517#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayProperties2KHR.html>"]
20518pub struct DisplayProperties2KHR {
20519 pub s_type: StructureType,
20520 pub p_next: *mut c_void,
20521 pub display_properties: DisplayPropertiesKHR,
20522}
20523impl ::std::default::Default for DisplayProperties2KHR {
20524 fn default() -> Self {
20525 Self {
20526 s_type: StructureType::DISPLAY_PROPERTIES_2_KHR,
20527 p_next: ::std::ptr::null_mut(),
20528 display_properties: DisplayPropertiesKHR::default(),
20529 }
20530 }
20531}
20532impl DisplayProperties2KHR {
20533 pub fn builder<'a>() -> DisplayProperties2KHRBuilder<'a> {
20534 DisplayProperties2KHRBuilder {
20535 inner: Self::default(),
20536 marker: ::std::marker::PhantomData,
20537 }
20538 }
20539}
20540#[repr(transparent)]
20541pub struct DisplayProperties2KHRBuilder<'a> {
20542 inner: DisplayProperties2KHR,
20543 marker: ::std::marker::PhantomData<&'a ()>,
20544}
20545impl<'a> ::std::ops::Deref for DisplayProperties2KHRBuilder<'a> {
20546 type Target = DisplayProperties2KHR;
20547 fn deref(&self) -> &Self::Target {
20548 &self.inner
20549 }
20550}
20551impl<'a> ::std::ops::DerefMut for DisplayProperties2KHRBuilder<'a> {
20552 fn deref_mut(&mut self) -> &mut Self::Target {
20553 &mut self.inner
20554 }
20555}
20556impl<'a> DisplayProperties2KHRBuilder<'a> {
20557 pub fn display_properties(mut self, display_properties: DisplayPropertiesKHR) -> Self {
20558 self.inner.display_properties = display_properties;
20559 self
20560 }
20561 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20562 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20563 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20564 pub fn build(self) -> DisplayProperties2KHR {
20565 self.inner
20566 }
20567}
20568#[repr(C)]
20569#[cfg_attr(feature = "debug", derive(Debug))]
20570#[derive(Copy, Clone)]
20571#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPlaneProperties2KHR.html>"]
20572pub struct DisplayPlaneProperties2KHR {
20573 pub s_type: StructureType,
20574 pub p_next: *mut c_void,
20575 pub display_plane_properties: DisplayPlanePropertiesKHR,
20576}
20577impl ::std::default::Default for DisplayPlaneProperties2KHR {
20578 fn default() -> Self {
20579 Self {
20580 s_type: StructureType::DISPLAY_PLANE_PROPERTIES_2_KHR,
20581 p_next: ::std::ptr::null_mut(),
20582 display_plane_properties: DisplayPlanePropertiesKHR::default(),
20583 }
20584 }
20585}
20586impl DisplayPlaneProperties2KHR {
20587 pub fn builder<'a>() -> DisplayPlaneProperties2KHRBuilder<'a> {
20588 DisplayPlaneProperties2KHRBuilder {
20589 inner: Self::default(),
20590 marker: ::std::marker::PhantomData,
20591 }
20592 }
20593}
20594#[repr(transparent)]
20595pub struct DisplayPlaneProperties2KHRBuilder<'a> {
20596 inner: DisplayPlaneProperties2KHR,
20597 marker: ::std::marker::PhantomData<&'a ()>,
20598}
20599impl<'a> ::std::ops::Deref for DisplayPlaneProperties2KHRBuilder<'a> {
20600 type Target = DisplayPlaneProperties2KHR;
20601 fn deref(&self) -> &Self::Target {
20602 &self.inner
20603 }
20604}
20605impl<'a> ::std::ops::DerefMut for DisplayPlaneProperties2KHRBuilder<'a> {
20606 fn deref_mut(&mut self) -> &mut Self::Target {
20607 &mut self.inner
20608 }
20609}
20610impl<'a> DisplayPlaneProperties2KHRBuilder<'a> {
20611 pub fn display_plane_properties(
20612 mut self,
20613 display_plane_properties: DisplayPlanePropertiesKHR,
20614 ) -> Self {
20615 self.inner.display_plane_properties = display_plane_properties;
20616 self
20617 }
20618 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20619 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20620 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20621 pub fn build(self) -> DisplayPlaneProperties2KHR {
20622 self.inner
20623 }
20624}
20625#[repr(C)]
20626#[cfg_attr(feature = "debug", derive(Debug))]
20627#[derive(Copy, Clone)]
20628#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModeProperties2KHR.html>"]
20629pub struct DisplayModeProperties2KHR {
20630 pub s_type: StructureType,
20631 pub p_next: *mut c_void,
20632 pub display_mode_properties: DisplayModePropertiesKHR,
20633}
20634impl ::std::default::Default for DisplayModeProperties2KHR {
20635 fn default() -> Self {
20636 Self {
20637 s_type: StructureType::DISPLAY_MODE_PROPERTIES_2_KHR,
20638 p_next: ::std::ptr::null_mut(),
20639 display_mode_properties: DisplayModePropertiesKHR::default(),
20640 }
20641 }
20642}
20643impl DisplayModeProperties2KHR {
20644 pub fn builder<'a>() -> DisplayModeProperties2KHRBuilder<'a> {
20645 DisplayModeProperties2KHRBuilder {
20646 inner: Self::default(),
20647 marker: ::std::marker::PhantomData,
20648 }
20649 }
20650}
20651#[repr(transparent)]
20652pub struct DisplayModeProperties2KHRBuilder<'a> {
20653 inner: DisplayModeProperties2KHR,
20654 marker: ::std::marker::PhantomData<&'a ()>,
20655}
20656impl<'a> ::std::ops::Deref for DisplayModeProperties2KHRBuilder<'a> {
20657 type Target = DisplayModeProperties2KHR;
20658 fn deref(&self) -> &Self::Target {
20659 &self.inner
20660 }
20661}
20662impl<'a> ::std::ops::DerefMut for DisplayModeProperties2KHRBuilder<'a> {
20663 fn deref_mut(&mut self) -> &mut Self::Target {
20664 &mut self.inner
20665 }
20666}
20667impl<'a> DisplayModeProperties2KHRBuilder<'a> {
20668 pub fn display_mode_properties(
20669 mut self,
20670 display_mode_properties: DisplayModePropertiesKHR,
20671 ) -> Self {
20672 self.inner.display_mode_properties = display_mode_properties;
20673 self
20674 }
20675 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20676 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20677 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20678 pub fn build(self) -> DisplayModeProperties2KHR {
20679 self.inner
20680 }
20681}
20682#[repr(C)]
20683#[cfg_attr(feature = "debug", derive(Debug))]
20684#[derive(Copy, Clone)]
20685#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPlaneInfo2KHR.html>"]
20686pub struct DisplayPlaneInfo2KHR {
20687 pub s_type: StructureType,
20688 pub p_next: *const c_void,
20689 pub mode: DisplayModeKHR,
20690 pub plane_index: u32,
20691}
20692impl ::std::default::Default for DisplayPlaneInfo2KHR {
20693 fn default() -> Self {
20694 Self {
20695 s_type: StructureType::DISPLAY_PLANE_INFO_2_KHR,
20696 p_next: ::std::ptr::null(),
20697 mode: DisplayModeKHR::default(),
20698 plane_index: u32::default(),
20699 }
20700 }
20701}
20702impl DisplayPlaneInfo2KHR {
20703 pub fn builder<'a>() -> DisplayPlaneInfo2KHRBuilder<'a> {
20704 DisplayPlaneInfo2KHRBuilder {
20705 inner: Self::default(),
20706 marker: ::std::marker::PhantomData,
20707 }
20708 }
20709}
20710#[repr(transparent)]
20711pub struct DisplayPlaneInfo2KHRBuilder<'a> {
20712 inner: DisplayPlaneInfo2KHR,
20713 marker: ::std::marker::PhantomData<&'a ()>,
20714}
20715impl<'a> ::std::ops::Deref for DisplayPlaneInfo2KHRBuilder<'a> {
20716 type Target = DisplayPlaneInfo2KHR;
20717 fn deref(&self) -> &Self::Target {
20718 &self.inner
20719 }
20720}
20721impl<'a> ::std::ops::DerefMut for DisplayPlaneInfo2KHRBuilder<'a> {
20722 fn deref_mut(&mut self) -> &mut Self::Target {
20723 &mut self.inner
20724 }
20725}
20726impl<'a> DisplayPlaneInfo2KHRBuilder<'a> {
20727 pub fn mode(mut self, mode: DisplayModeKHR) -> Self {
20728 self.inner.mode = mode;
20729 self
20730 }
20731 pub fn plane_index(mut self, plane_index: u32) -> Self {
20732 self.inner.plane_index = plane_index;
20733 self
20734 }
20735 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20736 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20737 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20738 pub fn build(self) -> DisplayPlaneInfo2KHR {
20739 self.inner
20740 }
20741}
20742#[repr(C)]
20743#[cfg_attr(feature = "debug", derive(Debug))]
20744#[derive(Copy, Clone)]
20745#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPlaneCapabilities2KHR.html>"]
20746pub struct DisplayPlaneCapabilities2KHR {
20747 pub s_type: StructureType,
20748 pub p_next: *mut c_void,
20749 pub capabilities: DisplayPlaneCapabilitiesKHR,
20750}
20751impl ::std::default::Default for DisplayPlaneCapabilities2KHR {
20752 fn default() -> Self {
20753 Self {
20754 s_type: StructureType::DISPLAY_PLANE_CAPABILITIES_2_KHR,
20755 p_next: ::std::ptr::null_mut(),
20756 capabilities: DisplayPlaneCapabilitiesKHR::default(),
20757 }
20758 }
20759}
20760impl DisplayPlaneCapabilities2KHR {
20761 pub fn builder<'a>() -> DisplayPlaneCapabilities2KHRBuilder<'a> {
20762 DisplayPlaneCapabilities2KHRBuilder {
20763 inner: Self::default(),
20764 marker: ::std::marker::PhantomData,
20765 }
20766 }
20767}
20768#[repr(transparent)]
20769pub struct DisplayPlaneCapabilities2KHRBuilder<'a> {
20770 inner: DisplayPlaneCapabilities2KHR,
20771 marker: ::std::marker::PhantomData<&'a ()>,
20772}
20773impl<'a> ::std::ops::Deref for DisplayPlaneCapabilities2KHRBuilder<'a> {
20774 type Target = DisplayPlaneCapabilities2KHR;
20775 fn deref(&self) -> &Self::Target {
20776 &self.inner
20777 }
20778}
20779impl<'a> ::std::ops::DerefMut for DisplayPlaneCapabilities2KHRBuilder<'a> {
20780 fn deref_mut(&mut self) -> &mut Self::Target {
20781 &mut self.inner
20782 }
20783}
20784impl<'a> DisplayPlaneCapabilities2KHRBuilder<'a> {
20785 pub fn capabilities(mut self, capabilities: DisplayPlaneCapabilitiesKHR) -> Self {
20786 self.inner.capabilities = capabilities;
20787 self
20788 }
20789 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20790 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20791 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20792 pub fn build(self) -> DisplayPlaneCapabilities2KHR {
20793 self.inner
20794 }
20795}
20796#[repr(C)]
20797#[cfg_attr(feature = "debug", derive(Debug))]
20798#[derive(Copy, Clone)]
20799#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSharedPresentSurfaceCapabilitiesKHR.html>"]
20800pub struct SharedPresentSurfaceCapabilitiesKHR {
20801 pub s_type: StructureType,
20802 pub p_next: *mut c_void,
20803 pub shared_present_supported_usage_flags: ImageUsageFlags,
20804}
20805impl ::std::default::Default for SharedPresentSurfaceCapabilitiesKHR {
20806 fn default() -> Self {
20807 Self {
20808 s_type: StructureType::SHARED_PRESENT_SURFACE_CAPABILITIES_KHR,
20809 p_next: ::std::ptr::null_mut(),
20810 shared_present_supported_usage_flags: ImageUsageFlags::default(),
20811 }
20812 }
20813}
20814impl SharedPresentSurfaceCapabilitiesKHR {
20815 pub fn builder<'a>() -> SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
20816 SharedPresentSurfaceCapabilitiesKHRBuilder {
20817 inner: Self::default(),
20818 marker: ::std::marker::PhantomData,
20819 }
20820 }
20821}
20822#[repr(transparent)]
20823pub struct SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
20824 inner: SharedPresentSurfaceCapabilitiesKHR,
20825 marker: ::std::marker::PhantomData<&'a ()>,
20826}
20827unsafe impl ExtendsSurfaceCapabilities2KHR for SharedPresentSurfaceCapabilitiesKHRBuilder<'_> {}
20828unsafe impl ExtendsSurfaceCapabilities2KHR for SharedPresentSurfaceCapabilitiesKHR {}
20829impl<'a> ::std::ops::Deref for SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
20830 type Target = SharedPresentSurfaceCapabilitiesKHR;
20831 fn deref(&self) -> &Self::Target {
20832 &self.inner
20833 }
20834}
20835impl<'a> ::std::ops::DerefMut for SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
20836 fn deref_mut(&mut self) -> &mut Self::Target {
20837 &mut self.inner
20838 }
20839}
20840impl<'a> SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
20841 pub fn shared_present_supported_usage_flags(
20842 mut self,
20843 shared_present_supported_usage_flags: ImageUsageFlags,
20844 ) -> Self {
20845 self.inner.shared_present_supported_usage_flags = shared_present_supported_usage_flags;
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."]
20851 pub fn build(self) -> SharedPresentSurfaceCapabilitiesKHR {
20852 self.inner
20853 }
20854}
20855#[repr(C)]
20856#[cfg_attr(feature = "debug", derive(Debug))]
20857#[derive(Copy, Clone)]
20858#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevice16BitStorageFeatures.html>"]
20859pub struct PhysicalDevice16BitStorageFeatures {
20860 pub s_type: StructureType,
20861 pub p_next: *mut c_void,
20862 pub storage_buffer16_bit_access: Bool32,
20863 pub uniform_and_storage_buffer16_bit_access: Bool32,
20864 pub storage_push_constant16: Bool32,
20865 pub storage_input_output16: Bool32,
20866}
20867impl ::std::default::Default for PhysicalDevice16BitStorageFeatures {
20868 fn default() -> Self {
20869 Self {
20870 s_type: StructureType::PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES,
20871 p_next: ::std::ptr::null_mut(),
20872 storage_buffer16_bit_access: Bool32::default(),
20873 uniform_and_storage_buffer16_bit_access: Bool32::default(),
20874 storage_push_constant16: Bool32::default(),
20875 storage_input_output16: Bool32::default(),
20876 }
20877 }
20878}
20879impl PhysicalDevice16BitStorageFeatures {
20880 pub fn builder<'a>() -> PhysicalDevice16BitStorageFeaturesBuilder<'a> {
20881 PhysicalDevice16BitStorageFeaturesBuilder {
20882 inner: Self::default(),
20883 marker: ::std::marker::PhantomData,
20884 }
20885 }
20886}
20887#[repr(transparent)]
20888pub struct PhysicalDevice16BitStorageFeaturesBuilder<'a> {
20889 inner: PhysicalDevice16BitStorageFeatures,
20890 marker: ::std::marker::PhantomData<&'a ()>,
20891}
20892unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice16BitStorageFeaturesBuilder<'_> {}
20893unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice16BitStorageFeatures {}
20894unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice16BitStorageFeaturesBuilder<'_> {}
20895unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice16BitStorageFeatures {}
20896impl<'a> ::std::ops::Deref for PhysicalDevice16BitStorageFeaturesBuilder<'a> {
20897 type Target = PhysicalDevice16BitStorageFeatures;
20898 fn deref(&self) -> &Self::Target {
20899 &self.inner
20900 }
20901}
20902impl<'a> ::std::ops::DerefMut for PhysicalDevice16BitStorageFeaturesBuilder<'a> {
20903 fn deref_mut(&mut self) -> &mut Self::Target {
20904 &mut self.inner
20905 }
20906}
20907impl<'a> PhysicalDevice16BitStorageFeaturesBuilder<'a> {
20908 pub fn storage_buffer16_bit_access(mut self, storage_buffer16_bit_access: bool) -> Self {
20909 self.inner.storage_buffer16_bit_access = storage_buffer16_bit_access.into();
20910 self
20911 }
20912 pub fn uniform_and_storage_buffer16_bit_access(
20913 mut self,
20914 uniform_and_storage_buffer16_bit_access: bool,
20915 ) -> Self {
20916 self.inner.uniform_and_storage_buffer16_bit_access =
20917 uniform_and_storage_buffer16_bit_access.into();
20918 self
20919 }
20920 pub fn storage_push_constant16(mut self, storage_push_constant16: bool) -> Self {
20921 self.inner.storage_push_constant16 = storage_push_constant16.into();
20922 self
20923 }
20924 pub fn storage_input_output16(mut self, storage_input_output16: bool) -> Self {
20925 self.inner.storage_input_output16 = storage_input_output16.into();
20926 self
20927 }
20928 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20929 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20930 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20931 pub fn build(self) -> PhysicalDevice16BitStorageFeatures {
20932 self.inner
20933 }
20934}
20935#[repr(C)]
20936#[cfg_attr(feature = "debug", derive(Debug))]
20937#[derive(Copy, Clone)]
20938#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSubgroupProperties.html>"]
20939pub struct PhysicalDeviceSubgroupProperties {
20940 pub s_type: StructureType,
20941 pub p_next: *mut c_void,
20942 pub subgroup_size: u32,
20943 pub supported_stages: ShaderStageFlags,
20944 pub supported_operations: SubgroupFeatureFlags,
20945 pub quad_operations_in_all_stages: Bool32,
20946}
20947impl ::std::default::Default for PhysicalDeviceSubgroupProperties {
20948 fn default() -> Self {
20949 Self {
20950 s_type: StructureType::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES,
20951 p_next: ::std::ptr::null_mut(),
20952 subgroup_size: u32::default(),
20953 supported_stages: ShaderStageFlags::default(),
20954 supported_operations: SubgroupFeatureFlags::default(),
20955 quad_operations_in_all_stages: Bool32::default(),
20956 }
20957 }
20958}
20959impl PhysicalDeviceSubgroupProperties {
20960 pub fn builder<'a>() -> PhysicalDeviceSubgroupPropertiesBuilder<'a> {
20961 PhysicalDeviceSubgroupPropertiesBuilder {
20962 inner: Self::default(),
20963 marker: ::std::marker::PhantomData,
20964 }
20965 }
20966}
20967#[repr(transparent)]
20968pub struct PhysicalDeviceSubgroupPropertiesBuilder<'a> {
20969 inner: PhysicalDeviceSubgroupProperties,
20970 marker: ::std::marker::PhantomData<&'a ()>,
20971}
20972unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupPropertiesBuilder<'_> {}
20973unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupProperties {}
20974impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupPropertiesBuilder<'a> {
20975 type Target = PhysicalDeviceSubgroupProperties;
20976 fn deref(&self) -> &Self::Target {
20977 &self.inner
20978 }
20979}
20980impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupPropertiesBuilder<'a> {
20981 fn deref_mut(&mut self) -> &mut Self::Target {
20982 &mut self.inner
20983 }
20984}
20985impl<'a> PhysicalDeviceSubgroupPropertiesBuilder<'a> {
20986 pub fn subgroup_size(mut self, subgroup_size: u32) -> Self {
20987 self.inner.subgroup_size = subgroup_size;
20988 self
20989 }
20990 pub fn supported_stages(mut self, supported_stages: ShaderStageFlags) -> Self {
20991 self.inner.supported_stages = supported_stages;
20992 self
20993 }
20994 pub fn supported_operations(mut self, supported_operations: SubgroupFeatureFlags) -> Self {
20995 self.inner.supported_operations = supported_operations;
20996 self
20997 }
20998 pub fn quad_operations_in_all_stages(mut self, quad_operations_in_all_stages: bool) -> Self {
20999 self.inner.quad_operations_in_all_stages = quad_operations_in_all_stages.into();
21000 self
21001 }
21002 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21003 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21004 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21005 pub fn build(self) -> PhysicalDeviceSubgroupProperties {
21006 self.inner
21007 }
21008}
21009#[repr(C)]
21010#[cfg_attr(feature = "debug", derive(Debug))]
21011#[derive(Copy, Clone)]
21012#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures.html>"]
21013pub struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
21014 pub s_type: StructureType,
21015 pub p_next: *mut c_void,
21016 pub shader_subgroup_extended_types: Bool32,
21017}
21018impl ::std::default::Default for PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
21019 fn default() -> Self {
21020 Self {
21021 s_type: StructureType::PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES,
21022 p_next: ::std::ptr::null_mut(),
21023 shader_subgroup_extended_types: Bool32::default(),
21024 }
21025 }
21026}
21027impl PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
21028 pub fn builder<'a>() -> PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
21029 PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder {
21030 inner: Self::default(),
21031 marker: ::std::marker::PhantomData,
21032 }
21033 }
21034}
21035#[repr(transparent)]
21036pub struct PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
21037 inner: PhysicalDeviceShaderSubgroupExtendedTypesFeatures,
21038 marker: ::std::marker::PhantomData<&'a ()>,
21039}
21040unsafe impl ExtendsPhysicalDeviceFeatures2
21041 for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'_>
21042{
21043}
21044unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderSubgroupExtendedTypesFeatures {}
21045unsafe impl ExtendsDeviceCreateInfo
21046 for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'_>
21047{
21048}
21049unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSubgroupExtendedTypesFeatures {}
21050impl<'a> ::std::ops::Deref for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
21051 type Target = PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
21052 fn deref(&self) -> &Self::Target {
21053 &self.inner
21054 }
21055}
21056impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
21057 fn deref_mut(&mut self) -> &mut Self::Target {
21058 &mut self.inner
21059 }
21060}
21061impl<'a> PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
21062 pub fn shader_subgroup_extended_types(mut self, shader_subgroup_extended_types: bool) -> Self {
21063 self.inner.shader_subgroup_extended_types = shader_subgroup_extended_types.into();
21064 self
21065 }
21066 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21067 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21068 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21069 pub fn build(self) -> PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
21070 self.inner
21071 }
21072}
21073#[repr(C)]
21074#[cfg_attr(feature = "debug", derive(Debug))]
21075#[derive(Copy, Clone)]
21076#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferMemoryRequirementsInfo2.html>"]
21077pub struct BufferMemoryRequirementsInfo2 {
21078 pub s_type: StructureType,
21079 pub p_next: *const c_void,
21080 pub buffer: Buffer,
21081}
21082impl ::std::default::Default for BufferMemoryRequirementsInfo2 {
21083 fn default() -> Self {
21084 Self {
21085 s_type: StructureType::BUFFER_MEMORY_REQUIREMENTS_INFO_2,
21086 p_next: ::std::ptr::null(),
21087 buffer: Buffer::default(),
21088 }
21089 }
21090}
21091impl BufferMemoryRequirementsInfo2 {
21092 pub fn builder<'a>() -> BufferMemoryRequirementsInfo2Builder<'a> {
21093 BufferMemoryRequirementsInfo2Builder {
21094 inner: Self::default(),
21095 marker: ::std::marker::PhantomData,
21096 }
21097 }
21098}
21099#[repr(transparent)]
21100pub struct BufferMemoryRequirementsInfo2Builder<'a> {
21101 inner: BufferMemoryRequirementsInfo2,
21102 marker: ::std::marker::PhantomData<&'a ()>,
21103}
21104impl<'a> ::std::ops::Deref for BufferMemoryRequirementsInfo2Builder<'a> {
21105 type Target = BufferMemoryRequirementsInfo2;
21106 fn deref(&self) -> &Self::Target {
21107 &self.inner
21108 }
21109}
21110impl<'a> ::std::ops::DerefMut for BufferMemoryRequirementsInfo2Builder<'a> {
21111 fn deref_mut(&mut self) -> &mut Self::Target {
21112 &mut self.inner
21113 }
21114}
21115impl<'a> BufferMemoryRequirementsInfo2Builder<'a> {
21116 pub fn buffer(mut self, buffer: Buffer) -> Self {
21117 self.inner.buffer = buffer;
21118 self
21119 }
21120 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21121 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21122 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21123 pub fn build(self) -> BufferMemoryRequirementsInfo2 {
21124 self.inner
21125 }
21126}
21127#[repr(C)]
21128#[cfg_attr(feature = "debug", derive(Debug))]
21129#[derive(Copy, Clone)]
21130#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceBufferMemoryRequirements.html>"]
21131pub struct DeviceBufferMemoryRequirements {
21132 pub s_type: StructureType,
21133 pub p_next: *const c_void,
21134 pub p_create_info: *const BufferCreateInfo,
21135}
21136impl ::std::default::Default for DeviceBufferMemoryRequirements {
21137 fn default() -> Self {
21138 Self {
21139 s_type: StructureType::DEVICE_BUFFER_MEMORY_REQUIREMENTS,
21140 p_next: ::std::ptr::null(),
21141 p_create_info: ::std::ptr::null(),
21142 }
21143 }
21144}
21145impl DeviceBufferMemoryRequirements {
21146 pub fn builder<'a>() -> DeviceBufferMemoryRequirementsBuilder<'a> {
21147 DeviceBufferMemoryRequirementsBuilder {
21148 inner: Self::default(),
21149 marker: ::std::marker::PhantomData,
21150 }
21151 }
21152}
21153#[repr(transparent)]
21154pub struct DeviceBufferMemoryRequirementsBuilder<'a> {
21155 inner: DeviceBufferMemoryRequirements,
21156 marker: ::std::marker::PhantomData<&'a ()>,
21157}
21158impl<'a> ::std::ops::Deref for DeviceBufferMemoryRequirementsBuilder<'a> {
21159 type Target = DeviceBufferMemoryRequirements;
21160 fn deref(&self) -> &Self::Target {
21161 &self.inner
21162 }
21163}
21164impl<'a> ::std::ops::DerefMut for DeviceBufferMemoryRequirementsBuilder<'a> {
21165 fn deref_mut(&mut self) -> &mut Self::Target {
21166 &mut self.inner
21167 }
21168}
21169impl<'a> DeviceBufferMemoryRequirementsBuilder<'a> {
21170 pub fn create_info(mut self, create_info: &'a BufferCreateInfo) -> Self {
21171 self.inner.p_create_info = create_info;
21172 self
21173 }
21174 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21175 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21176 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21177 pub fn build(self) -> DeviceBufferMemoryRequirements {
21178 self.inner
21179 }
21180}
21181#[repr(C)]
21182#[cfg_attr(feature = "debug", derive(Debug))]
21183#[derive(Copy, Clone)]
21184#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageMemoryRequirementsInfo2.html>"]
21185pub struct ImageMemoryRequirementsInfo2 {
21186 pub s_type: StructureType,
21187 pub p_next: *const c_void,
21188 pub image: Image,
21189}
21190impl ::std::default::Default for ImageMemoryRequirementsInfo2 {
21191 fn default() -> Self {
21192 Self {
21193 s_type: StructureType::IMAGE_MEMORY_REQUIREMENTS_INFO_2,
21194 p_next: ::std::ptr::null(),
21195 image: Image::default(),
21196 }
21197 }
21198}
21199impl ImageMemoryRequirementsInfo2 {
21200 pub fn builder<'a>() -> ImageMemoryRequirementsInfo2Builder<'a> {
21201 ImageMemoryRequirementsInfo2Builder {
21202 inner: Self::default(),
21203 marker: ::std::marker::PhantomData,
21204 }
21205 }
21206}
21207#[repr(transparent)]
21208pub struct ImageMemoryRequirementsInfo2Builder<'a> {
21209 inner: ImageMemoryRequirementsInfo2,
21210 marker: ::std::marker::PhantomData<&'a ()>,
21211}
21212pub unsafe trait ExtendsImageMemoryRequirementsInfo2 {}
21213impl<'a> ::std::ops::Deref for ImageMemoryRequirementsInfo2Builder<'a> {
21214 type Target = ImageMemoryRequirementsInfo2;
21215 fn deref(&self) -> &Self::Target {
21216 &self.inner
21217 }
21218}
21219impl<'a> ::std::ops::DerefMut for ImageMemoryRequirementsInfo2Builder<'a> {
21220 fn deref_mut(&mut self) -> &mut Self::Target {
21221 &mut self.inner
21222 }
21223}
21224impl<'a> ImageMemoryRequirementsInfo2Builder<'a> {
21225 pub fn image(mut self, image: Image) -> Self {
21226 self.inner.image = image;
21227 self
21228 }
21229 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
21230 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
21231 #[doc = r" valid extension structs can be pushed into the chain."]
21232 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
21233 #[doc = r" chain will look like `A -> D -> B -> C`."]
21234 pub fn push_next<T: ExtendsImageMemoryRequirementsInfo2>(mut self, next: &'a mut T) -> Self {
21235 unsafe {
21236 let next_ptr = <*const T>::cast(next);
21237 let last_next = ptr_chain_iter(next).last().unwrap();
21238 (*last_next).p_next = self.inner.p_next as _;
21239 self.inner.p_next = next_ptr;
21240 }
21241 self
21242 }
21243 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21244 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21245 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21246 pub fn build(self) -> ImageMemoryRequirementsInfo2 {
21247 self.inner
21248 }
21249}
21250#[repr(C)]
21251#[cfg_attr(feature = "debug", derive(Debug))]
21252#[derive(Copy, Clone)]
21253#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSparseMemoryRequirementsInfo2.html>"]
21254pub struct ImageSparseMemoryRequirementsInfo2 {
21255 pub s_type: StructureType,
21256 pub p_next: *const c_void,
21257 pub image: Image,
21258}
21259impl ::std::default::Default for ImageSparseMemoryRequirementsInfo2 {
21260 fn default() -> Self {
21261 Self {
21262 s_type: StructureType::IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2,
21263 p_next: ::std::ptr::null(),
21264 image: Image::default(),
21265 }
21266 }
21267}
21268impl ImageSparseMemoryRequirementsInfo2 {
21269 pub fn builder<'a>() -> ImageSparseMemoryRequirementsInfo2Builder<'a> {
21270 ImageSparseMemoryRequirementsInfo2Builder {
21271 inner: Self::default(),
21272 marker: ::std::marker::PhantomData,
21273 }
21274 }
21275}
21276#[repr(transparent)]
21277pub struct ImageSparseMemoryRequirementsInfo2Builder<'a> {
21278 inner: ImageSparseMemoryRequirementsInfo2,
21279 marker: ::std::marker::PhantomData<&'a ()>,
21280}
21281impl<'a> ::std::ops::Deref for ImageSparseMemoryRequirementsInfo2Builder<'a> {
21282 type Target = ImageSparseMemoryRequirementsInfo2;
21283 fn deref(&self) -> &Self::Target {
21284 &self.inner
21285 }
21286}
21287impl<'a> ::std::ops::DerefMut for ImageSparseMemoryRequirementsInfo2Builder<'a> {
21288 fn deref_mut(&mut self) -> &mut Self::Target {
21289 &mut self.inner
21290 }
21291}
21292impl<'a> ImageSparseMemoryRequirementsInfo2Builder<'a> {
21293 pub fn image(mut self, image: Image) -> Self {
21294 self.inner.image = image;
21295 self
21296 }
21297 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21298 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21299 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21300 pub fn build(self) -> ImageSparseMemoryRequirementsInfo2 {
21301 self.inner
21302 }
21303}
21304#[repr(C)]
21305#[cfg_attr(feature = "debug", derive(Debug))]
21306#[derive(Copy, Clone)]
21307#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceImageMemoryRequirements.html>"]
21308pub struct DeviceImageMemoryRequirements {
21309 pub s_type: StructureType,
21310 pub p_next: *const c_void,
21311 pub p_create_info: *const ImageCreateInfo,
21312 pub plane_aspect: ImageAspectFlags,
21313}
21314impl ::std::default::Default for DeviceImageMemoryRequirements {
21315 fn default() -> Self {
21316 Self {
21317 s_type: StructureType::DEVICE_IMAGE_MEMORY_REQUIREMENTS,
21318 p_next: ::std::ptr::null(),
21319 p_create_info: ::std::ptr::null(),
21320 plane_aspect: ImageAspectFlags::default(),
21321 }
21322 }
21323}
21324impl DeviceImageMemoryRequirements {
21325 pub fn builder<'a>() -> DeviceImageMemoryRequirementsBuilder<'a> {
21326 DeviceImageMemoryRequirementsBuilder {
21327 inner: Self::default(),
21328 marker: ::std::marker::PhantomData,
21329 }
21330 }
21331}
21332#[repr(transparent)]
21333pub struct DeviceImageMemoryRequirementsBuilder<'a> {
21334 inner: DeviceImageMemoryRequirements,
21335 marker: ::std::marker::PhantomData<&'a ()>,
21336}
21337impl<'a> ::std::ops::Deref for DeviceImageMemoryRequirementsBuilder<'a> {
21338 type Target = DeviceImageMemoryRequirements;
21339 fn deref(&self) -> &Self::Target {
21340 &self.inner
21341 }
21342}
21343impl<'a> ::std::ops::DerefMut for DeviceImageMemoryRequirementsBuilder<'a> {
21344 fn deref_mut(&mut self) -> &mut Self::Target {
21345 &mut self.inner
21346 }
21347}
21348impl<'a> DeviceImageMemoryRequirementsBuilder<'a> {
21349 pub fn create_info(mut self, create_info: &'a ImageCreateInfo) -> Self {
21350 self.inner.p_create_info = create_info;
21351 self
21352 }
21353 pub fn plane_aspect(mut self, plane_aspect: ImageAspectFlags) -> Self {
21354 self.inner.plane_aspect = plane_aspect;
21355 self
21356 }
21357 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21358 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21359 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21360 pub fn build(self) -> DeviceImageMemoryRequirements {
21361 self.inner
21362 }
21363}
21364#[repr(C)]
21365#[cfg_attr(feature = "debug", derive(Debug))]
21366#[derive(Copy, Clone)]
21367#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryRequirements2.html>"]
21368pub struct MemoryRequirements2 {
21369 pub s_type: StructureType,
21370 pub p_next: *mut c_void,
21371 pub memory_requirements: MemoryRequirements,
21372}
21373impl ::std::default::Default for MemoryRequirements2 {
21374 fn default() -> Self {
21375 Self {
21376 s_type: StructureType::MEMORY_REQUIREMENTS_2,
21377 p_next: ::std::ptr::null_mut(),
21378 memory_requirements: MemoryRequirements::default(),
21379 }
21380 }
21381}
21382impl MemoryRequirements2 {
21383 pub fn builder<'a>() -> MemoryRequirements2Builder<'a> {
21384 MemoryRequirements2Builder {
21385 inner: Self::default(),
21386 marker: ::std::marker::PhantomData,
21387 }
21388 }
21389}
21390#[repr(transparent)]
21391pub struct MemoryRequirements2Builder<'a> {
21392 inner: MemoryRequirements2,
21393 marker: ::std::marker::PhantomData<&'a ()>,
21394}
21395pub unsafe trait ExtendsMemoryRequirements2 {}
21396impl<'a> ::std::ops::Deref for MemoryRequirements2Builder<'a> {
21397 type Target = MemoryRequirements2;
21398 fn deref(&self) -> &Self::Target {
21399 &self.inner
21400 }
21401}
21402impl<'a> ::std::ops::DerefMut for MemoryRequirements2Builder<'a> {
21403 fn deref_mut(&mut self) -> &mut Self::Target {
21404 &mut self.inner
21405 }
21406}
21407impl<'a> MemoryRequirements2Builder<'a> {
21408 pub fn memory_requirements(mut self, memory_requirements: MemoryRequirements) -> Self {
21409 self.inner.memory_requirements = memory_requirements;
21410 self
21411 }
21412 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
21413 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
21414 #[doc = r" valid extension structs can be pushed into the chain."]
21415 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
21416 #[doc = r" chain will look like `A -> D -> B -> C`."]
21417 pub fn push_next<T: ExtendsMemoryRequirements2>(mut self, next: &'a mut T) -> Self {
21418 unsafe {
21419 let next_ptr = <*mut T>::cast(next);
21420 let last_next = ptr_chain_iter(next).last().unwrap();
21421 (*last_next).p_next = self.inner.p_next as _;
21422 self.inner.p_next = next_ptr;
21423 }
21424 self
21425 }
21426 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21427 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21428 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21429 pub fn build(self) -> MemoryRequirements2 {
21430 self.inner
21431 }
21432}
21433#[repr(C)]
21434#[cfg_attr(feature = "debug", derive(Debug))]
21435#[derive(Copy, Clone)]
21436#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageMemoryRequirements2.html>"]
21437pub struct SparseImageMemoryRequirements2 {
21438 pub s_type: StructureType,
21439 pub p_next: *mut c_void,
21440 pub memory_requirements: SparseImageMemoryRequirements,
21441}
21442impl ::std::default::Default for SparseImageMemoryRequirements2 {
21443 fn default() -> Self {
21444 Self {
21445 s_type: StructureType::SPARSE_IMAGE_MEMORY_REQUIREMENTS_2,
21446 p_next: ::std::ptr::null_mut(),
21447 memory_requirements: SparseImageMemoryRequirements::default(),
21448 }
21449 }
21450}
21451impl SparseImageMemoryRequirements2 {
21452 pub fn builder<'a>() -> SparseImageMemoryRequirements2Builder<'a> {
21453 SparseImageMemoryRequirements2Builder {
21454 inner: Self::default(),
21455 marker: ::std::marker::PhantomData,
21456 }
21457 }
21458}
21459#[repr(transparent)]
21460pub struct SparseImageMemoryRequirements2Builder<'a> {
21461 inner: SparseImageMemoryRequirements2,
21462 marker: ::std::marker::PhantomData<&'a ()>,
21463}
21464impl<'a> ::std::ops::Deref for SparseImageMemoryRequirements2Builder<'a> {
21465 type Target = SparseImageMemoryRequirements2;
21466 fn deref(&self) -> &Self::Target {
21467 &self.inner
21468 }
21469}
21470impl<'a> ::std::ops::DerefMut for SparseImageMemoryRequirements2Builder<'a> {
21471 fn deref_mut(&mut self) -> &mut Self::Target {
21472 &mut self.inner
21473 }
21474}
21475impl<'a> SparseImageMemoryRequirements2Builder<'a> {
21476 pub fn memory_requirements(
21477 mut self,
21478 memory_requirements: SparseImageMemoryRequirements,
21479 ) -> Self {
21480 self.inner.memory_requirements = memory_requirements;
21481 self
21482 }
21483 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21484 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21485 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21486 pub fn build(self) -> SparseImageMemoryRequirements2 {
21487 self.inner
21488 }
21489}
21490#[repr(C)]
21491#[cfg_attr(feature = "debug", derive(Debug))]
21492#[derive(Copy, Clone)]
21493#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePointClippingProperties.html>"]
21494pub struct PhysicalDevicePointClippingProperties {
21495 pub s_type: StructureType,
21496 pub p_next: *mut c_void,
21497 pub point_clipping_behavior: PointClippingBehavior,
21498}
21499impl ::std::default::Default for PhysicalDevicePointClippingProperties {
21500 fn default() -> Self {
21501 Self {
21502 s_type: StructureType::PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES,
21503 p_next: ::std::ptr::null_mut(),
21504 point_clipping_behavior: PointClippingBehavior::default(),
21505 }
21506 }
21507}
21508impl PhysicalDevicePointClippingProperties {
21509 pub fn builder<'a>() -> PhysicalDevicePointClippingPropertiesBuilder<'a> {
21510 PhysicalDevicePointClippingPropertiesBuilder {
21511 inner: Self::default(),
21512 marker: ::std::marker::PhantomData,
21513 }
21514 }
21515}
21516#[repr(transparent)]
21517pub struct PhysicalDevicePointClippingPropertiesBuilder<'a> {
21518 inner: PhysicalDevicePointClippingProperties,
21519 marker: ::std::marker::PhantomData<&'a ()>,
21520}
21521unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePointClippingPropertiesBuilder<'_> {}
21522unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePointClippingProperties {}
21523impl<'a> ::std::ops::Deref for PhysicalDevicePointClippingPropertiesBuilder<'a> {
21524 type Target = PhysicalDevicePointClippingProperties;
21525 fn deref(&self) -> &Self::Target {
21526 &self.inner
21527 }
21528}
21529impl<'a> ::std::ops::DerefMut for PhysicalDevicePointClippingPropertiesBuilder<'a> {
21530 fn deref_mut(&mut self) -> &mut Self::Target {
21531 &mut self.inner
21532 }
21533}
21534impl<'a> PhysicalDevicePointClippingPropertiesBuilder<'a> {
21535 pub fn point_clipping_behavior(
21536 mut self,
21537 point_clipping_behavior: PointClippingBehavior,
21538 ) -> Self {
21539 self.inner.point_clipping_behavior = point_clipping_behavior;
21540 self
21541 }
21542 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21543 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21544 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21545 pub fn build(self) -> PhysicalDevicePointClippingProperties {
21546 self.inner
21547 }
21548}
21549#[repr(C)]
21550#[cfg_attr(feature = "debug", derive(Debug))]
21551#[derive(Copy, Clone)]
21552#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryDedicatedRequirements.html>"]
21553pub struct MemoryDedicatedRequirements {
21554 pub s_type: StructureType,
21555 pub p_next: *mut c_void,
21556 pub prefers_dedicated_allocation: Bool32,
21557 pub requires_dedicated_allocation: Bool32,
21558}
21559impl ::std::default::Default for MemoryDedicatedRequirements {
21560 fn default() -> Self {
21561 Self {
21562 s_type: StructureType::MEMORY_DEDICATED_REQUIREMENTS,
21563 p_next: ::std::ptr::null_mut(),
21564 prefers_dedicated_allocation: Bool32::default(),
21565 requires_dedicated_allocation: Bool32::default(),
21566 }
21567 }
21568}
21569impl MemoryDedicatedRequirements {
21570 pub fn builder<'a>() -> MemoryDedicatedRequirementsBuilder<'a> {
21571 MemoryDedicatedRequirementsBuilder {
21572 inner: Self::default(),
21573 marker: ::std::marker::PhantomData,
21574 }
21575 }
21576}
21577#[repr(transparent)]
21578pub struct MemoryDedicatedRequirementsBuilder<'a> {
21579 inner: MemoryDedicatedRequirements,
21580 marker: ::std::marker::PhantomData<&'a ()>,
21581}
21582unsafe impl ExtendsMemoryRequirements2 for MemoryDedicatedRequirementsBuilder<'_> {}
21583unsafe impl ExtendsMemoryRequirements2 for MemoryDedicatedRequirements {}
21584impl<'a> ::std::ops::Deref for MemoryDedicatedRequirementsBuilder<'a> {
21585 type Target = MemoryDedicatedRequirements;
21586 fn deref(&self) -> &Self::Target {
21587 &self.inner
21588 }
21589}
21590impl<'a> ::std::ops::DerefMut for MemoryDedicatedRequirementsBuilder<'a> {
21591 fn deref_mut(&mut self) -> &mut Self::Target {
21592 &mut self.inner
21593 }
21594}
21595impl<'a> MemoryDedicatedRequirementsBuilder<'a> {
21596 pub fn prefers_dedicated_allocation(mut self, prefers_dedicated_allocation: bool) -> Self {
21597 self.inner.prefers_dedicated_allocation = prefers_dedicated_allocation.into();
21598 self
21599 }
21600 pub fn requires_dedicated_allocation(mut self, requires_dedicated_allocation: bool) -> Self {
21601 self.inner.requires_dedicated_allocation = requires_dedicated_allocation.into();
21602 self
21603 }
21604 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21605 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21606 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21607 pub fn build(self) -> MemoryDedicatedRequirements {
21608 self.inner
21609 }
21610}
21611#[repr(C)]
21612#[cfg_attr(feature = "debug", derive(Debug))]
21613#[derive(Copy, Clone)]
21614#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryDedicatedAllocateInfo.html>"]
21615pub struct MemoryDedicatedAllocateInfo {
21616 pub s_type: StructureType,
21617 pub p_next: *const c_void,
21618 pub image: Image,
21619 pub buffer: Buffer,
21620}
21621impl ::std::default::Default for MemoryDedicatedAllocateInfo {
21622 fn default() -> Self {
21623 Self {
21624 s_type: StructureType::MEMORY_DEDICATED_ALLOCATE_INFO,
21625 p_next: ::std::ptr::null(),
21626 image: Image::default(),
21627 buffer: Buffer::default(),
21628 }
21629 }
21630}
21631impl MemoryDedicatedAllocateInfo {
21632 pub fn builder<'a>() -> MemoryDedicatedAllocateInfoBuilder<'a> {
21633 MemoryDedicatedAllocateInfoBuilder {
21634 inner: Self::default(),
21635 marker: ::std::marker::PhantomData,
21636 }
21637 }
21638}
21639#[repr(transparent)]
21640pub struct MemoryDedicatedAllocateInfoBuilder<'a> {
21641 inner: MemoryDedicatedAllocateInfo,
21642 marker: ::std::marker::PhantomData<&'a ()>,
21643}
21644unsafe impl ExtendsMemoryAllocateInfo for MemoryDedicatedAllocateInfoBuilder<'_> {}
21645unsafe impl ExtendsMemoryAllocateInfo for MemoryDedicatedAllocateInfo {}
21646impl<'a> ::std::ops::Deref for MemoryDedicatedAllocateInfoBuilder<'a> {
21647 type Target = MemoryDedicatedAllocateInfo;
21648 fn deref(&self) -> &Self::Target {
21649 &self.inner
21650 }
21651}
21652impl<'a> ::std::ops::DerefMut for MemoryDedicatedAllocateInfoBuilder<'a> {
21653 fn deref_mut(&mut self) -> &mut Self::Target {
21654 &mut self.inner
21655 }
21656}
21657impl<'a> MemoryDedicatedAllocateInfoBuilder<'a> {
21658 pub fn image(mut self, image: Image) -> Self {
21659 self.inner.image = image;
21660 self
21661 }
21662 pub fn buffer(mut self, buffer: Buffer) -> Self {
21663 self.inner.buffer = buffer;
21664 self
21665 }
21666 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21667 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21668 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21669 pub fn build(self) -> MemoryDedicatedAllocateInfo {
21670 self.inner
21671 }
21672}
21673#[repr(C)]
21674#[cfg_attr(feature = "debug", derive(Debug))]
21675#[derive(Copy, Clone)]
21676#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewUsageCreateInfo.html>"]
21677pub struct ImageViewUsageCreateInfo {
21678 pub s_type: StructureType,
21679 pub p_next: *const c_void,
21680 pub usage: ImageUsageFlags,
21681}
21682impl ::std::default::Default for ImageViewUsageCreateInfo {
21683 fn default() -> Self {
21684 Self {
21685 s_type: StructureType::IMAGE_VIEW_USAGE_CREATE_INFO,
21686 p_next: ::std::ptr::null(),
21687 usage: ImageUsageFlags::default(),
21688 }
21689 }
21690}
21691impl ImageViewUsageCreateInfo {
21692 pub fn builder<'a>() -> ImageViewUsageCreateInfoBuilder<'a> {
21693 ImageViewUsageCreateInfoBuilder {
21694 inner: Self::default(),
21695 marker: ::std::marker::PhantomData,
21696 }
21697 }
21698}
21699#[repr(transparent)]
21700pub struct ImageViewUsageCreateInfoBuilder<'a> {
21701 inner: ImageViewUsageCreateInfo,
21702 marker: ::std::marker::PhantomData<&'a ()>,
21703}
21704unsafe impl ExtendsImageViewCreateInfo for ImageViewUsageCreateInfoBuilder<'_> {}
21705unsafe impl ExtendsImageViewCreateInfo for ImageViewUsageCreateInfo {}
21706impl<'a> ::std::ops::Deref for ImageViewUsageCreateInfoBuilder<'a> {
21707 type Target = ImageViewUsageCreateInfo;
21708 fn deref(&self) -> &Self::Target {
21709 &self.inner
21710 }
21711}
21712impl<'a> ::std::ops::DerefMut for ImageViewUsageCreateInfoBuilder<'a> {
21713 fn deref_mut(&mut self) -> &mut Self::Target {
21714 &mut self.inner
21715 }
21716}
21717impl<'a> ImageViewUsageCreateInfoBuilder<'a> {
21718 pub fn usage(mut self, usage: ImageUsageFlags) -> Self {
21719 self.inner.usage = usage;
21720 self
21721 }
21722 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21723 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21724 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21725 pub fn build(self) -> ImageViewUsageCreateInfo {
21726 self.inner
21727 }
21728}
21729#[repr(C)]
21730#[cfg_attr(feature = "debug", derive(Debug))]
21731#[derive(Copy, Clone)]
21732#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineTessellationDomainOriginStateCreateInfo.html>"]
21733pub struct PipelineTessellationDomainOriginStateCreateInfo {
21734 pub s_type: StructureType,
21735 pub p_next: *const c_void,
21736 pub domain_origin: TessellationDomainOrigin,
21737}
21738impl ::std::default::Default for PipelineTessellationDomainOriginStateCreateInfo {
21739 fn default() -> Self {
21740 Self {
21741 s_type: StructureType::PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO,
21742 p_next: ::std::ptr::null(),
21743 domain_origin: TessellationDomainOrigin::default(),
21744 }
21745 }
21746}
21747impl PipelineTessellationDomainOriginStateCreateInfo {
21748 pub fn builder<'a>() -> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
21749 PipelineTessellationDomainOriginStateCreateInfoBuilder {
21750 inner: Self::default(),
21751 marker: ::std::marker::PhantomData,
21752 }
21753 }
21754}
21755#[repr(transparent)]
21756pub struct PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
21757 inner: PipelineTessellationDomainOriginStateCreateInfo,
21758 marker: ::std::marker::PhantomData<&'a ()>,
21759}
21760unsafe impl ExtendsPipelineTessellationStateCreateInfo
21761 for PipelineTessellationDomainOriginStateCreateInfoBuilder<'_>
21762{
21763}
21764unsafe impl ExtendsPipelineTessellationStateCreateInfo
21765 for PipelineTessellationDomainOriginStateCreateInfo
21766{
21767}
21768impl<'a> ::std::ops::Deref for PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
21769 type Target = PipelineTessellationDomainOriginStateCreateInfo;
21770 fn deref(&self) -> &Self::Target {
21771 &self.inner
21772 }
21773}
21774impl<'a> ::std::ops::DerefMut for PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
21775 fn deref_mut(&mut self) -> &mut Self::Target {
21776 &mut self.inner
21777 }
21778}
21779impl<'a> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
21780 pub fn domain_origin(mut self, domain_origin: TessellationDomainOrigin) -> Self {
21781 self.inner.domain_origin = domain_origin;
21782 self
21783 }
21784 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21785 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21786 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21787 pub fn build(self) -> PipelineTessellationDomainOriginStateCreateInfo {
21788 self.inner
21789 }
21790}
21791#[repr(C)]
21792#[cfg_attr(feature = "debug", derive(Debug))]
21793#[derive(Copy, Clone)]
21794#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerYcbcrConversionInfo.html>"]
21795pub struct SamplerYcbcrConversionInfo {
21796 pub s_type: StructureType,
21797 pub p_next: *const c_void,
21798 pub conversion: SamplerYcbcrConversion,
21799}
21800impl ::std::default::Default for SamplerYcbcrConversionInfo {
21801 fn default() -> Self {
21802 Self {
21803 s_type: StructureType::SAMPLER_YCBCR_CONVERSION_INFO,
21804 p_next: ::std::ptr::null(),
21805 conversion: SamplerYcbcrConversion::default(),
21806 }
21807 }
21808}
21809impl SamplerYcbcrConversionInfo {
21810 pub fn builder<'a>() -> SamplerYcbcrConversionInfoBuilder<'a> {
21811 SamplerYcbcrConversionInfoBuilder {
21812 inner: Self::default(),
21813 marker: ::std::marker::PhantomData,
21814 }
21815 }
21816}
21817#[repr(transparent)]
21818pub struct SamplerYcbcrConversionInfoBuilder<'a> {
21819 inner: SamplerYcbcrConversionInfo,
21820 marker: ::std::marker::PhantomData<&'a ()>,
21821}
21822unsafe impl ExtendsSamplerCreateInfo for SamplerYcbcrConversionInfoBuilder<'_> {}
21823unsafe impl ExtendsSamplerCreateInfo for SamplerYcbcrConversionInfo {}
21824unsafe impl ExtendsImageViewCreateInfo for SamplerYcbcrConversionInfoBuilder<'_> {}
21825unsafe impl ExtendsImageViewCreateInfo for SamplerYcbcrConversionInfo {}
21826impl<'a> ::std::ops::Deref for SamplerYcbcrConversionInfoBuilder<'a> {
21827 type Target = SamplerYcbcrConversionInfo;
21828 fn deref(&self) -> &Self::Target {
21829 &self.inner
21830 }
21831}
21832impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionInfoBuilder<'a> {
21833 fn deref_mut(&mut self) -> &mut Self::Target {
21834 &mut self.inner
21835 }
21836}
21837impl<'a> SamplerYcbcrConversionInfoBuilder<'a> {
21838 pub fn conversion(mut self, conversion: SamplerYcbcrConversion) -> Self {
21839 self.inner.conversion = conversion;
21840 self
21841 }
21842 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21843 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21844 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21845 pub fn build(self) -> SamplerYcbcrConversionInfo {
21846 self.inner
21847 }
21848}
21849#[repr(C)]
21850#[cfg_attr(feature = "debug", derive(Debug))]
21851#[derive(Copy, Clone)]
21852#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerYcbcrConversionCreateInfo.html>"]
21853pub struct SamplerYcbcrConversionCreateInfo {
21854 pub s_type: StructureType,
21855 pub p_next: *const c_void,
21856 pub format: Format,
21857 pub ycbcr_model: SamplerYcbcrModelConversion,
21858 pub ycbcr_range: SamplerYcbcrRange,
21859 pub components: ComponentMapping,
21860 pub x_chroma_offset: ChromaLocation,
21861 pub y_chroma_offset: ChromaLocation,
21862 pub chroma_filter: Filter,
21863 pub force_explicit_reconstruction: Bool32,
21864}
21865impl ::std::default::Default for SamplerYcbcrConversionCreateInfo {
21866 fn default() -> Self {
21867 Self {
21868 s_type: StructureType::SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
21869 p_next: ::std::ptr::null(),
21870 format: Format::default(),
21871 ycbcr_model: SamplerYcbcrModelConversion::default(),
21872 ycbcr_range: SamplerYcbcrRange::default(),
21873 components: ComponentMapping::default(),
21874 x_chroma_offset: ChromaLocation::default(),
21875 y_chroma_offset: ChromaLocation::default(),
21876 chroma_filter: Filter::default(),
21877 force_explicit_reconstruction: Bool32::default(),
21878 }
21879 }
21880}
21881impl SamplerYcbcrConversionCreateInfo {
21882 pub fn builder<'a>() -> SamplerYcbcrConversionCreateInfoBuilder<'a> {
21883 SamplerYcbcrConversionCreateInfoBuilder {
21884 inner: Self::default(),
21885 marker: ::std::marker::PhantomData,
21886 }
21887 }
21888}
21889#[repr(transparent)]
21890pub struct SamplerYcbcrConversionCreateInfoBuilder<'a> {
21891 inner: SamplerYcbcrConversionCreateInfo,
21892 marker: ::std::marker::PhantomData<&'a ()>,
21893}
21894pub unsafe trait ExtendsSamplerYcbcrConversionCreateInfo {}
21895impl<'a> ::std::ops::Deref for SamplerYcbcrConversionCreateInfoBuilder<'a> {
21896 type Target = SamplerYcbcrConversionCreateInfo;
21897 fn deref(&self) -> &Self::Target {
21898 &self.inner
21899 }
21900}
21901impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionCreateInfoBuilder<'a> {
21902 fn deref_mut(&mut self) -> &mut Self::Target {
21903 &mut self.inner
21904 }
21905}
21906impl<'a> SamplerYcbcrConversionCreateInfoBuilder<'a> {
21907 pub fn format(mut self, format: Format) -> Self {
21908 self.inner.format = format;
21909 self
21910 }
21911 pub fn ycbcr_model(mut self, ycbcr_model: SamplerYcbcrModelConversion) -> Self {
21912 self.inner.ycbcr_model = ycbcr_model;
21913 self
21914 }
21915 pub fn ycbcr_range(mut self, ycbcr_range: SamplerYcbcrRange) -> Self {
21916 self.inner.ycbcr_range = ycbcr_range;
21917 self
21918 }
21919 pub fn components(mut self, components: ComponentMapping) -> Self {
21920 self.inner.components = components;
21921 self
21922 }
21923 pub fn x_chroma_offset(mut self, x_chroma_offset: ChromaLocation) -> Self {
21924 self.inner.x_chroma_offset = x_chroma_offset;
21925 self
21926 }
21927 pub fn y_chroma_offset(mut self, y_chroma_offset: ChromaLocation) -> Self {
21928 self.inner.y_chroma_offset = y_chroma_offset;
21929 self
21930 }
21931 pub fn chroma_filter(mut self, chroma_filter: Filter) -> Self {
21932 self.inner.chroma_filter = chroma_filter;
21933 self
21934 }
21935 pub fn force_explicit_reconstruction(mut self, force_explicit_reconstruction: bool) -> Self {
21936 self.inner.force_explicit_reconstruction = force_explicit_reconstruction.into();
21937 self
21938 }
21939 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
21940 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
21941 #[doc = r" valid extension structs can be pushed into the chain."]
21942 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
21943 #[doc = r" chain will look like `A -> D -> B -> C`."]
21944 pub fn push_next<T: ExtendsSamplerYcbcrConversionCreateInfo>(
21945 mut self,
21946 next: &'a mut T,
21947 ) -> Self {
21948 unsafe {
21949 let next_ptr = <*const T>::cast(next);
21950 let last_next = ptr_chain_iter(next).last().unwrap();
21951 (*last_next).p_next = self.inner.p_next as _;
21952 self.inner.p_next = next_ptr;
21953 }
21954 self
21955 }
21956 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21957 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21958 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21959 pub fn build(self) -> SamplerYcbcrConversionCreateInfo {
21960 self.inner
21961 }
21962}
21963#[repr(C)]
21964#[cfg_attr(feature = "debug", derive(Debug))]
21965#[derive(Copy, Clone)]
21966#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindImagePlaneMemoryInfo.html>"]
21967pub struct BindImagePlaneMemoryInfo {
21968 pub s_type: StructureType,
21969 pub p_next: *const c_void,
21970 pub plane_aspect: ImageAspectFlags,
21971}
21972impl ::std::default::Default for BindImagePlaneMemoryInfo {
21973 fn default() -> Self {
21974 Self {
21975 s_type: StructureType::BIND_IMAGE_PLANE_MEMORY_INFO,
21976 p_next: ::std::ptr::null(),
21977 plane_aspect: ImageAspectFlags::default(),
21978 }
21979 }
21980}
21981impl BindImagePlaneMemoryInfo {
21982 pub fn builder<'a>() -> BindImagePlaneMemoryInfoBuilder<'a> {
21983 BindImagePlaneMemoryInfoBuilder {
21984 inner: Self::default(),
21985 marker: ::std::marker::PhantomData,
21986 }
21987 }
21988}
21989#[repr(transparent)]
21990pub struct BindImagePlaneMemoryInfoBuilder<'a> {
21991 inner: BindImagePlaneMemoryInfo,
21992 marker: ::std::marker::PhantomData<&'a ()>,
21993}
21994unsafe impl ExtendsBindImageMemoryInfo for BindImagePlaneMemoryInfoBuilder<'_> {}
21995unsafe impl ExtendsBindImageMemoryInfo for BindImagePlaneMemoryInfo {}
21996impl<'a> ::std::ops::Deref for BindImagePlaneMemoryInfoBuilder<'a> {
21997 type Target = BindImagePlaneMemoryInfo;
21998 fn deref(&self) -> &Self::Target {
21999 &self.inner
22000 }
22001}
22002impl<'a> ::std::ops::DerefMut for BindImagePlaneMemoryInfoBuilder<'a> {
22003 fn deref_mut(&mut self) -> &mut Self::Target {
22004 &mut self.inner
22005 }
22006}
22007impl<'a> BindImagePlaneMemoryInfoBuilder<'a> {
22008 pub fn plane_aspect(mut self, plane_aspect: ImageAspectFlags) -> Self {
22009 self.inner.plane_aspect = plane_aspect;
22010 self
22011 }
22012 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22013 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22014 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22015 pub fn build(self) -> BindImagePlaneMemoryInfo {
22016 self.inner
22017 }
22018}
22019#[repr(C)]
22020#[cfg_attr(feature = "debug", derive(Debug))]
22021#[derive(Copy, Clone)]
22022#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImagePlaneMemoryRequirementsInfo.html>"]
22023pub struct ImagePlaneMemoryRequirementsInfo {
22024 pub s_type: StructureType,
22025 pub p_next: *const c_void,
22026 pub plane_aspect: ImageAspectFlags,
22027}
22028impl ::std::default::Default for ImagePlaneMemoryRequirementsInfo {
22029 fn default() -> Self {
22030 Self {
22031 s_type: StructureType::IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO,
22032 p_next: ::std::ptr::null(),
22033 plane_aspect: ImageAspectFlags::default(),
22034 }
22035 }
22036}
22037impl ImagePlaneMemoryRequirementsInfo {
22038 pub fn builder<'a>() -> ImagePlaneMemoryRequirementsInfoBuilder<'a> {
22039 ImagePlaneMemoryRequirementsInfoBuilder {
22040 inner: Self::default(),
22041 marker: ::std::marker::PhantomData,
22042 }
22043 }
22044}
22045#[repr(transparent)]
22046pub struct ImagePlaneMemoryRequirementsInfoBuilder<'a> {
22047 inner: ImagePlaneMemoryRequirementsInfo,
22048 marker: ::std::marker::PhantomData<&'a ()>,
22049}
22050unsafe impl ExtendsImageMemoryRequirementsInfo2 for ImagePlaneMemoryRequirementsInfoBuilder<'_> {}
22051unsafe impl ExtendsImageMemoryRequirementsInfo2 for ImagePlaneMemoryRequirementsInfo {}
22052impl<'a> ::std::ops::Deref for ImagePlaneMemoryRequirementsInfoBuilder<'a> {
22053 type Target = ImagePlaneMemoryRequirementsInfo;
22054 fn deref(&self) -> &Self::Target {
22055 &self.inner
22056 }
22057}
22058impl<'a> ::std::ops::DerefMut for ImagePlaneMemoryRequirementsInfoBuilder<'a> {
22059 fn deref_mut(&mut self) -> &mut Self::Target {
22060 &mut self.inner
22061 }
22062}
22063impl<'a> ImagePlaneMemoryRequirementsInfoBuilder<'a> {
22064 pub fn plane_aspect(mut self, plane_aspect: ImageAspectFlags) -> Self {
22065 self.inner.plane_aspect = plane_aspect;
22066 self
22067 }
22068 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22069 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22070 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22071 pub fn build(self) -> ImagePlaneMemoryRequirementsInfo {
22072 self.inner
22073 }
22074}
22075#[repr(C)]
22076#[cfg_attr(feature = "debug", derive(Debug))]
22077#[derive(Copy, Clone)]
22078#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSamplerYcbcrConversionFeatures.html>"]
22079pub struct PhysicalDeviceSamplerYcbcrConversionFeatures {
22080 pub s_type: StructureType,
22081 pub p_next: *mut c_void,
22082 pub sampler_ycbcr_conversion: Bool32,
22083}
22084impl ::std::default::Default for PhysicalDeviceSamplerYcbcrConversionFeatures {
22085 fn default() -> Self {
22086 Self {
22087 s_type: StructureType::PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES,
22088 p_next: ::std::ptr::null_mut(),
22089 sampler_ycbcr_conversion: Bool32::default(),
22090 }
22091 }
22092}
22093impl PhysicalDeviceSamplerYcbcrConversionFeatures {
22094 pub fn builder<'a>() -> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
22095 PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder {
22096 inner: Self::default(),
22097 marker: ::std::marker::PhantomData,
22098 }
22099 }
22100}
22101#[repr(transparent)]
22102pub struct PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
22103 inner: PhysicalDeviceSamplerYcbcrConversionFeatures,
22104 marker: ::std::marker::PhantomData<&'a ()>,
22105}
22106unsafe impl ExtendsPhysicalDeviceFeatures2
22107 for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'_>
22108{
22109}
22110unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSamplerYcbcrConversionFeatures {}
22111unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'_> {}
22112unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSamplerYcbcrConversionFeatures {}
22113impl<'a> ::std::ops::Deref for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
22114 type Target = PhysicalDeviceSamplerYcbcrConversionFeatures;
22115 fn deref(&self) -> &Self::Target {
22116 &self.inner
22117 }
22118}
22119impl<'a> ::std::ops::DerefMut for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
22120 fn deref_mut(&mut self) -> &mut Self::Target {
22121 &mut self.inner
22122 }
22123}
22124impl<'a> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
22125 pub fn sampler_ycbcr_conversion(mut self, sampler_ycbcr_conversion: bool) -> Self {
22126 self.inner.sampler_ycbcr_conversion = sampler_ycbcr_conversion.into();
22127 self
22128 }
22129 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22130 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22131 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22132 pub fn build(self) -> PhysicalDeviceSamplerYcbcrConversionFeatures {
22133 self.inner
22134 }
22135}
22136#[repr(C)]
22137#[cfg_attr(feature = "debug", derive(Debug))]
22138#[derive(Copy, Clone)]
22139#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerYcbcrConversionImageFormatProperties.html>"]
22140pub struct SamplerYcbcrConversionImageFormatProperties {
22141 pub s_type: StructureType,
22142 pub p_next: *mut c_void,
22143 pub combined_image_sampler_descriptor_count: u32,
22144}
22145impl ::std::default::Default for SamplerYcbcrConversionImageFormatProperties {
22146 fn default() -> Self {
22147 Self {
22148 s_type: StructureType::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES,
22149 p_next: ::std::ptr::null_mut(),
22150 combined_image_sampler_descriptor_count: u32::default(),
22151 }
22152 }
22153}
22154impl SamplerYcbcrConversionImageFormatProperties {
22155 pub fn builder<'a>() -> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
22156 SamplerYcbcrConversionImageFormatPropertiesBuilder {
22157 inner: Self::default(),
22158 marker: ::std::marker::PhantomData,
22159 }
22160 }
22161}
22162#[repr(transparent)]
22163pub struct SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
22164 inner: SamplerYcbcrConversionImageFormatProperties,
22165 marker: ::std::marker::PhantomData<&'a ()>,
22166}
22167unsafe impl ExtendsImageFormatProperties2
22168 for SamplerYcbcrConversionImageFormatPropertiesBuilder<'_>
22169{
22170}
22171unsafe impl ExtendsImageFormatProperties2 for SamplerYcbcrConversionImageFormatProperties {}
22172impl<'a> ::std::ops::Deref for SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
22173 type Target = SamplerYcbcrConversionImageFormatProperties;
22174 fn deref(&self) -> &Self::Target {
22175 &self.inner
22176 }
22177}
22178impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
22179 fn deref_mut(&mut self) -> &mut Self::Target {
22180 &mut self.inner
22181 }
22182}
22183impl<'a> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
22184 pub fn combined_image_sampler_descriptor_count(
22185 mut self,
22186 combined_image_sampler_descriptor_count: u32,
22187 ) -> Self {
22188 self.inner.combined_image_sampler_descriptor_count =
22189 combined_image_sampler_descriptor_count;
22190 self
22191 }
22192 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22193 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22194 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22195 pub fn build(self) -> SamplerYcbcrConversionImageFormatProperties {
22196 self.inner
22197 }
22198}
22199#[repr(C)]
22200#[cfg_attr(feature = "debug", derive(Debug))]
22201#[derive(Copy, Clone)]
22202#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkTextureLODGatherFormatPropertiesAMD.html>"]
22203pub struct TextureLODGatherFormatPropertiesAMD {
22204 pub s_type: StructureType,
22205 pub p_next: *mut c_void,
22206 pub supports_texture_gather_lod_bias_amd: Bool32,
22207}
22208impl ::std::default::Default for TextureLODGatherFormatPropertiesAMD {
22209 fn default() -> Self {
22210 Self {
22211 s_type: StructureType::TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD,
22212 p_next: ::std::ptr::null_mut(),
22213 supports_texture_gather_lod_bias_amd: Bool32::default(),
22214 }
22215 }
22216}
22217impl TextureLODGatherFormatPropertiesAMD {
22218 pub fn builder<'a>() -> TextureLODGatherFormatPropertiesAMDBuilder<'a> {
22219 TextureLODGatherFormatPropertiesAMDBuilder {
22220 inner: Self::default(),
22221 marker: ::std::marker::PhantomData,
22222 }
22223 }
22224}
22225#[repr(transparent)]
22226pub struct TextureLODGatherFormatPropertiesAMDBuilder<'a> {
22227 inner: TextureLODGatherFormatPropertiesAMD,
22228 marker: ::std::marker::PhantomData<&'a ()>,
22229}
22230unsafe impl ExtendsImageFormatProperties2 for TextureLODGatherFormatPropertiesAMDBuilder<'_> {}
22231unsafe impl ExtendsImageFormatProperties2 for TextureLODGatherFormatPropertiesAMD {}
22232impl<'a> ::std::ops::Deref for TextureLODGatherFormatPropertiesAMDBuilder<'a> {
22233 type Target = TextureLODGatherFormatPropertiesAMD;
22234 fn deref(&self) -> &Self::Target {
22235 &self.inner
22236 }
22237}
22238impl<'a> ::std::ops::DerefMut for TextureLODGatherFormatPropertiesAMDBuilder<'a> {
22239 fn deref_mut(&mut self) -> &mut Self::Target {
22240 &mut self.inner
22241 }
22242}
22243impl<'a> TextureLODGatherFormatPropertiesAMDBuilder<'a> {
22244 pub fn supports_texture_gather_lod_bias_amd(
22245 mut self,
22246 supports_texture_gather_lod_bias_amd: bool,
22247 ) -> Self {
22248 self.inner.supports_texture_gather_lod_bias_amd =
22249 supports_texture_gather_lod_bias_amd.into();
22250 self
22251 }
22252 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22253 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22254 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22255 pub fn build(self) -> TextureLODGatherFormatPropertiesAMD {
22256 self.inner
22257 }
22258}
22259#[repr(C)]
22260#[cfg_attr(feature = "debug", derive(Debug))]
22261#[derive(Copy, Clone)]
22262#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkConditionalRenderingBeginInfoEXT.html>"]
22263pub struct ConditionalRenderingBeginInfoEXT {
22264 pub s_type: StructureType,
22265 pub p_next: *const c_void,
22266 pub buffer: Buffer,
22267 pub offset: DeviceSize,
22268 pub flags: ConditionalRenderingFlagsEXT,
22269}
22270impl ::std::default::Default for ConditionalRenderingBeginInfoEXT {
22271 fn default() -> Self {
22272 Self {
22273 s_type: StructureType::CONDITIONAL_RENDERING_BEGIN_INFO_EXT,
22274 p_next: ::std::ptr::null(),
22275 buffer: Buffer::default(),
22276 offset: DeviceSize::default(),
22277 flags: ConditionalRenderingFlagsEXT::default(),
22278 }
22279 }
22280}
22281impl ConditionalRenderingBeginInfoEXT {
22282 pub fn builder<'a>() -> ConditionalRenderingBeginInfoEXTBuilder<'a> {
22283 ConditionalRenderingBeginInfoEXTBuilder {
22284 inner: Self::default(),
22285 marker: ::std::marker::PhantomData,
22286 }
22287 }
22288}
22289#[repr(transparent)]
22290pub struct ConditionalRenderingBeginInfoEXTBuilder<'a> {
22291 inner: ConditionalRenderingBeginInfoEXT,
22292 marker: ::std::marker::PhantomData<&'a ()>,
22293}
22294impl<'a> ::std::ops::Deref for ConditionalRenderingBeginInfoEXTBuilder<'a> {
22295 type Target = ConditionalRenderingBeginInfoEXT;
22296 fn deref(&self) -> &Self::Target {
22297 &self.inner
22298 }
22299}
22300impl<'a> ::std::ops::DerefMut for ConditionalRenderingBeginInfoEXTBuilder<'a> {
22301 fn deref_mut(&mut self) -> &mut Self::Target {
22302 &mut self.inner
22303 }
22304}
22305impl<'a> ConditionalRenderingBeginInfoEXTBuilder<'a> {
22306 pub fn buffer(mut self, buffer: Buffer) -> Self {
22307 self.inner.buffer = buffer;
22308 self
22309 }
22310 pub fn offset(mut self, offset: DeviceSize) -> Self {
22311 self.inner.offset = offset;
22312 self
22313 }
22314 pub fn flags(mut self, flags: ConditionalRenderingFlagsEXT) -> Self {
22315 self.inner.flags = flags;
22316 self
22317 }
22318 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22319 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22320 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22321 pub fn build(self) -> ConditionalRenderingBeginInfoEXT {
22322 self.inner
22323 }
22324}
22325#[repr(C)]
22326#[cfg_attr(feature = "debug", derive(Debug))]
22327#[derive(Copy, Clone)]
22328#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkProtectedSubmitInfo.html>"]
22329pub struct ProtectedSubmitInfo {
22330 pub s_type: StructureType,
22331 pub p_next: *const c_void,
22332 pub protected_submit: Bool32,
22333}
22334impl ::std::default::Default for ProtectedSubmitInfo {
22335 fn default() -> Self {
22336 Self {
22337 s_type: StructureType::PROTECTED_SUBMIT_INFO,
22338 p_next: ::std::ptr::null(),
22339 protected_submit: Bool32::default(),
22340 }
22341 }
22342}
22343impl ProtectedSubmitInfo {
22344 pub fn builder<'a>() -> ProtectedSubmitInfoBuilder<'a> {
22345 ProtectedSubmitInfoBuilder {
22346 inner: Self::default(),
22347 marker: ::std::marker::PhantomData,
22348 }
22349 }
22350}
22351#[repr(transparent)]
22352pub struct ProtectedSubmitInfoBuilder<'a> {
22353 inner: ProtectedSubmitInfo,
22354 marker: ::std::marker::PhantomData<&'a ()>,
22355}
22356unsafe impl ExtendsSubmitInfo for ProtectedSubmitInfoBuilder<'_> {}
22357unsafe impl ExtendsSubmitInfo for ProtectedSubmitInfo {}
22358impl<'a> ::std::ops::Deref for ProtectedSubmitInfoBuilder<'a> {
22359 type Target = ProtectedSubmitInfo;
22360 fn deref(&self) -> &Self::Target {
22361 &self.inner
22362 }
22363}
22364impl<'a> ::std::ops::DerefMut for ProtectedSubmitInfoBuilder<'a> {
22365 fn deref_mut(&mut self) -> &mut Self::Target {
22366 &mut self.inner
22367 }
22368}
22369impl<'a> ProtectedSubmitInfoBuilder<'a> {
22370 pub fn protected_submit(mut self, protected_submit: bool) -> Self {
22371 self.inner.protected_submit = protected_submit.into();
22372 self
22373 }
22374 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22375 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22376 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22377 pub fn build(self) -> ProtectedSubmitInfo {
22378 self.inner
22379 }
22380}
22381#[repr(C)]
22382#[cfg_attr(feature = "debug", derive(Debug))]
22383#[derive(Copy, Clone)]
22384#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProtectedMemoryFeatures.html>"]
22385pub struct PhysicalDeviceProtectedMemoryFeatures {
22386 pub s_type: StructureType,
22387 pub p_next: *mut c_void,
22388 pub protected_memory: Bool32,
22389}
22390impl ::std::default::Default for PhysicalDeviceProtectedMemoryFeatures {
22391 fn default() -> Self {
22392 Self {
22393 s_type: StructureType::PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES,
22394 p_next: ::std::ptr::null_mut(),
22395 protected_memory: Bool32::default(),
22396 }
22397 }
22398}
22399impl PhysicalDeviceProtectedMemoryFeatures {
22400 pub fn builder<'a>() -> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
22401 PhysicalDeviceProtectedMemoryFeaturesBuilder {
22402 inner: Self::default(),
22403 marker: ::std::marker::PhantomData,
22404 }
22405 }
22406}
22407#[repr(transparent)]
22408pub struct PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
22409 inner: PhysicalDeviceProtectedMemoryFeatures,
22410 marker: ::std::marker::PhantomData<&'a ()>,
22411}
22412unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProtectedMemoryFeaturesBuilder<'_> {}
22413unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProtectedMemoryFeatures {}
22414unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProtectedMemoryFeaturesBuilder<'_> {}
22415unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProtectedMemoryFeatures {}
22416impl<'a> ::std::ops::Deref for PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
22417 type Target = PhysicalDeviceProtectedMemoryFeatures;
22418 fn deref(&self) -> &Self::Target {
22419 &self.inner
22420 }
22421}
22422impl<'a> ::std::ops::DerefMut for PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
22423 fn deref_mut(&mut self) -> &mut Self::Target {
22424 &mut self.inner
22425 }
22426}
22427impl<'a> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
22428 pub fn protected_memory(mut self, protected_memory: bool) -> Self {
22429 self.inner.protected_memory = protected_memory.into();
22430 self
22431 }
22432 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22433 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22434 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22435 pub fn build(self) -> PhysicalDeviceProtectedMemoryFeatures {
22436 self.inner
22437 }
22438}
22439#[repr(C)]
22440#[cfg_attr(feature = "debug", derive(Debug))]
22441#[derive(Copy, Clone)]
22442#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProtectedMemoryProperties.html>"]
22443pub struct PhysicalDeviceProtectedMemoryProperties {
22444 pub s_type: StructureType,
22445 pub p_next: *mut c_void,
22446 pub protected_no_fault: Bool32,
22447}
22448impl ::std::default::Default for PhysicalDeviceProtectedMemoryProperties {
22449 fn default() -> Self {
22450 Self {
22451 s_type: StructureType::PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES,
22452 p_next: ::std::ptr::null_mut(),
22453 protected_no_fault: Bool32::default(),
22454 }
22455 }
22456}
22457impl PhysicalDeviceProtectedMemoryProperties {
22458 pub fn builder<'a>() -> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
22459 PhysicalDeviceProtectedMemoryPropertiesBuilder {
22460 inner: Self::default(),
22461 marker: ::std::marker::PhantomData,
22462 }
22463 }
22464}
22465#[repr(transparent)]
22466pub struct PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
22467 inner: PhysicalDeviceProtectedMemoryProperties,
22468 marker: ::std::marker::PhantomData<&'a ()>,
22469}
22470unsafe impl ExtendsPhysicalDeviceProperties2
22471 for PhysicalDeviceProtectedMemoryPropertiesBuilder<'_>
22472{
22473}
22474unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceProtectedMemoryProperties {}
22475impl<'a> ::std::ops::Deref for PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
22476 type Target = PhysicalDeviceProtectedMemoryProperties;
22477 fn deref(&self) -> &Self::Target {
22478 &self.inner
22479 }
22480}
22481impl<'a> ::std::ops::DerefMut for PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
22482 fn deref_mut(&mut self) -> &mut Self::Target {
22483 &mut self.inner
22484 }
22485}
22486impl<'a> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
22487 pub fn protected_no_fault(mut self, protected_no_fault: bool) -> Self {
22488 self.inner.protected_no_fault = protected_no_fault.into();
22489 self
22490 }
22491 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22492 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22493 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22494 pub fn build(self) -> PhysicalDeviceProtectedMemoryProperties {
22495 self.inner
22496 }
22497}
22498#[repr(C)]
22499#[cfg_attr(feature = "debug", derive(Debug))]
22500#[derive(Copy, Clone)]
22501#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceQueueInfo2.html>"]
22502pub struct DeviceQueueInfo2 {
22503 pub s_type: StructureType,
22504 pub p_next: *const c_void,
22505 pub flags: DeviceQueueCreateFlags,
22506 pub queue_family_index: u32,
22507 pub queue_index: u32,
22508}
22509impl ::std::default::Default for DeviceQueueInfo2 {
22510 fn default() -> Self {
22511 Self {
22512 s_type: StructureType::DEVICE_QUEUE_INFO_2,
22513 p_next: ::std::ptr::null(),
22514 flags: DeviceQueueCreateFlags::default(),
22515 queue_family_index: u32::default(),
22516 queue_index: u32::default(),
22517 }
22518 }
22519}
22520impl DeviceQueueInfo2 {
22521 pub fn builder<'a>() -> DeviceQueueInfo2Builder<'a> {
22522 DeviceQueueInfo2Builder {
22523 inner: Self::default(),
22524 marker: ::std::marker::PhantomData,
22525 }
22526 }
22527}
22528#[repr(transparent)]
22529pub struct DeviceQueueInfo2Builder<'a> {
22530 inner: DeviceQueueInfo2,
22531 marker: ::std::marker::PhantomData<&'a ()>,
22532}
22533impl<'a> ::std::ops::Deref for DeviceQueueInfo2Builder<'a> {
22534 type Target = DeviceQueueInfo2;
22535 fn deref(&self) -> &Self::Target {
22536 &self.inner
22537 }
22538}
22539impl<'a> ::std::ops::DerefMut for DeviceQueueInfo2Builder<'a> {
22540 fn deref_mut(&mut self) -> &mut Self::Target {
22541 &mut self.inner
22542 }
22543}
22544impl<'a> DeviceQueueInfo2Builder<'a> {
22545 pub fn flags(mut self, flags: DeviceQueueCreateFlags) -> Self {
22546 self.inner.flags = flags;
22547 self
22548 }
22549 pub fn queue_family_index(mut self, queue_family_index: u32) -> Self {
22550 self.inner.queue_family_index = queue_family_index;
22551 self
22552 }
22553 pub fn queue_index(mut self, queue_index: u32) -> Self {
22554 self.inner.queue_index = queue_index;
22555 self
22556 }
22557 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22558 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22559 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22560 pub fn build(self) -> DeviceQueueInfo2 {
22561 self.inner
22562 }
22563}
22564#[repr(C)]
22565#[cfg_attr(feature = "debug", derive(Debug))]
22566#[derive(Copy, Clone)]
22567#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageToColorStateCreateInfoNV.html>"]
22568pub struct PipelineCoverageToColorStateCreateInfoNV {
22569 pub s_type: StructureType,
22570 pub p_next: *const c_void,
22571 pub flags: PipelineCoverageToColorStateCreateFlagsNV,
22572 pub coverage_to_color_enable: Bool32,
22573 pub coverage_to_color_location: u32,
22574}
22575impl ::std::default::Default for PipelineCoverageToColorStateCreateInfoNV {
22576 fn default() -> Self {
22577 Self {
22578 s_type: StructureType::PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV,
22579 p_next: ::std::ptr::null(),
22580 flags: PipelineCoverageToColorStateCreateFlagsNV::default(),
22581 coverage_to_color_enable: Bool32::default(),
22582 coverage_to_color_location: u32::default(),
22583 }
22584 }
22585}
22586impl PipelineCoverageToColorStateCreateInfoNV {
22587 pub fn builder<'a>() -> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
22588 PipelineCoverageToColorStateCreateInfoNVBuilder {
22589 inner: Self::default(),
22590 marker: ::std::marker::PhantomData,
22591 }
22592 }
22593}
22594#[repr(transparent)]
22595pub struct PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
22596 inner: PipelineCoverageToColorStateCreateInfoNV,
22597 marker: ::std::marker::PhantomData<&'a ()>,
22598}
22599unsafe impl ExtendsPipelineMultisampleStateCreateInfo
22600 for PipelineCoverageToColorStateCreateInfoNVBuilder<'_>
22601{
22602}
22603unsafe impl ExtendsPipelineMultisampleStateCreateInfo for PipelineCoverageToColorStateCreateInfoNV {}
22604impl<'a> ::std::ops::Deref for PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
22605 type Target = PipelineCoverageToColorStateCreateInfoNV;
22606 fn deref(&self) -> &Self::Target {
22607 &self.inner
22608 }
22609}
22610impl<'a> ::std::ops::DerefMut for PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
22611 fn deref_mut(&mut self) -> &mut Self::Target {
22612 &mut self.inner
22613 }
22614}
22615impl<'a> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
22616 pub fn flags(mut self, flags: PipelineCoverageToColorStateCreateFlagsNV) -> Self {
22617 self.inner.flags = flags;
22618 self
22619 }
22620 pub fn coverage_to_color_enable(mut self, coverage_to_color_enable: bool) -> Self {
22621 self.inner.coverage_to_color_enable = coverage_to_color_enable.into();
22622 self
22623 }
22624 pub fn coverage_to_color_location(mut self, coverage_to_color_location: u32) -> Self {
22625 self.inner.coverage_to_color_location = coverage_to_color_location;
22626 self
22627 }
22628 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22629 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22630 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22631 pub fn build(self) -> PipelineCoverageToColorStateCreateInfoNV {
22632 self.inner
22633 }
22634}
22635#[repr(C)]
22636#[cfg_attr(feature = "debug", derive(Debug))]
22637#[derive(Copy, Clone)]
22638#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSamplerFilterMinmaxProperties.html>"]
22639pub struct PhysicalDeviceSamplerFilterMinmaxProperties {
22640 pub s_type: StructureType,
22641 pub p_next: *mut c_void,
22642 pub filter_minmax_single_component_formats: Bool32,
22643 pub filter_minmax_image_component_mapping: Bool32,
22644}
22645impl ::std::default::Default for PhysicalDeviceSamplerFilterMinmaxProperties {
22646 fn default() -> Self {
22647 Self {
22648 s_type: StructureType::PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES,
22649 p_next: ::std::ptr::null_mut(),
22650 filter_minmax_single_component_formats: Bool32::default(),
22651 filter_minmax_image_component_mapping: Bool32::default(),
22652 }
22653 }
22654}
22655impl PhysicalDeviceSamplerFilterMinmaxProperties {
22656 pub fn builder<'a>() -> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
22657 PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder {
22658 inner: Self::default(),
22659 marker: ::std::marker::PhantomData,
22660 }
22661 }
22662}
22663#[repr(transparent)]
22664pub struct PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
22665 inner: PhysicalDeviceSamplerFilterMinmaxProperties,
22666 marker: ::std::marker::PhantomData<&'a ()>,
22667}
22668unsafe impl ExtendsPhysicalDeviceProperties2
22669 for PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'_>
22670{
22671}
22672unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSamplerFilterMinmaxProperties {}
22673impl<'a> ::std::ops::Deref for PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
22674 type Target = PhysicalDeviceSamplerFilterMinmaxProperties;
22675 fn deref(&self) -> &Self::Target {
22676 &self.inner
22677 }
22678}
22679impl<'a> ::std::ops::DerefMut for PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
22680 fn deref_mut(&mut self) -> &mut Self::Target {
22681 &mut self.inner
22682 }
22683}
22684impl<'a> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
22685 pub fn filter_minmax_single_component_formats(
22686 mut self,
22687 filter_minmax_single_component_formats: bool,
22688 ) -> Self {
22689 self.inner.filter_minmax_single_component_formats =
22690 filter_minmax_single_component_formats.into();
22691 self
22692 }
22693 pub fn filter_minmax_image_component_mapping(
22694 mut self,
22695 filter_minmax_image_component_mapping: bool,
22696 ) -> Self {
22697 self.inner.filter_minmax_image_component_mapping =
22698 filter_minmax_image_component_mapping.into();
22699 self
22700 }
22701 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22702 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22703 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22704 pub fn build(self) -> PhysicalDeviceSamplerFilterMinmaxProperties {
22705 self.inner
22706 }
22707}
22708#[repr(C)]
22709#[cfg_attr(feature = "debug", derive(Debug))]
22710#[derive(Copy, Clone, Default)]
22711#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSampleLocationEXT.html>"]
22712pub struct SampleLocationEXT {
22713 pub x: f32,
22714 pub y: f32,
22715}
22716impl SampleLocationEXT {
22717 pub fn builder<'a>() -> SampleLocationEXTBuilder<'a> {
22718 SampleLocationEXTBuilder {
22719 inner: Self::default(),
22720 marker: ::std::marker::PhantomData,
22721 }
22722 }
22723}
22724#[repr(transparent)]
22725pub struct SampleLocationEXTBuilder<'a> {
22726 inner: SampleLocationEXT,
22727 marker: ::std::marker::PhantomData<&'a ()>,
22728}
22729impl<'a> ::std::ops::Deref for SampleLocationEXTBuilder<'a> {
22730 type Target = SampleLocationEXT;
22731 fn deref(&self) -> &Self::Target {
22732 &self.inner
22733 }
22734}
22735impl<'a> ::std::ops::DerefMut for SampleLocationEXTBuilder<'a> {
22736 fn deref_mut(&mut self) -> &mut Self::Target {
22737 &mut self.inner
22738 }
22739}
22740impl<'a> SampleLocationEXTBuilder<'a> {
22741 pub fn x(mut self, x: f32) -> Self {
22742 self.inner.x = x;
22743 self
22744 }
22745 pub fn y(mut self, y: f32) -> Self {
22746 self.inner.y = y;
22747 self
22748 }
22749 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22750 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22751 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22752 pub fn build(self) -> SampleLocationEXT {
22753 self.inner
22754 }
22755}
22756#[repr(C)]
22757#[cfg_attr(feature = "debug", derive(Debug))]
22758#[derive(Copy, Clone)]
22759#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSampleLocationsInfoEXT.html>"]
22760pub struct SampleLocationsInfoEXT {
22761 pub s_type: StructureType,
22762 pub p_next: *const c_void,
22763 pub sample_locations_per_pixel: SampleCountFlags,
22764 pub sample_location_grid_size: Extent2D,
22765 pub sample_locations_count: u32,
22766 pub p_sample_locations: *const SampleLocationEXT,
22767}
22768impl ::std::default::Default for SampleLocationsInfoEXT {
22769 fn default() -> Self {
22770 Self {
22771 s_type: StructureType::SAMPLE_LOCATIONS_INFO_EXT,
22772 p_next: ::std::ptr::null(),
22773 sample_locations_per_pixel: SampleCountFlags::default(),
22774 sample_location_grid_size: Extent2D::default(),
22775 sample_locations_count: u32::default(),
22776 p_sample_locations: ::std::ptr::null(),
22777 }
22778 }
22779}
22780impl SampleLocationsInfoEXT {
22781 pub fn builder<'a>() -> SampleLocationsInfoEXTBuilder<'a> {
22782 SampleLocationsInfoEXTBuilder {
22783 inner: Self::default(),
22784 marker: ::std::marker::PhantomData,
22785 }
22786 }
22787}
22788#[repr(transparent)]
22789pub struct SampleLocationsInfoEXTBuilder<'a> {
22790 inner: SampleLocationsInfoEXT,
22791 marker: ::std::marker::PhantomData<&'a ()>,
22792}
22793unsafe impl ExtendsImageMemoryBarrier for SampleLocationsInfoEXTBuilder<'_> {}
22794unsafe impl ExtendsImageMemoryBarrier for SampleLocationsInfoEXT {}
22795unsafe impl ExtendsImageMemoryBarrier2 for SampleLocationsInfoEXTBuilder<'_> {}
22796unsafe impl ExtendsImageMemoryBarrier2 for SampleLocationsInfoEXT {}
22797impl<'a> ::std::ops::Deref for SampleLocationsInfoEXTBuilder<'a> {
22798 type Target = SampleLocationsInfoEXT;
22799 fn deref(&self) -> &Self::Target {
22800 &self.inner
22801 }
22802}
22803impl<'a> ::std::ops::DerefMut for SampleLocationsInfoEXTBuilder<'a> {
22804 fn deref_mut(&mut self) -> &mut Self::Target {
22805 &mut self.inner
22806 }
22807}
22808impl<'a> SampleLocationsInfoEXTBuilder<'a> {
22809 pub fn sample_locations_per_pixel(
22810 mut self,
22811 sample_locations_per_pixel: SampleCountFlags,
22812 ) -> Self {
22813 self.inner.sample_locations_per_pixel = sample_locations_per_pixel;
22814 self
22815 }
22816 pub fn sample_location_grid_size(mut self, sample_location_grid_size: Extent2D) -> Self {
22817 self.inner.sample_location_grid_size = sample_location_grid_size;
22818 self
22819 }
22820 pub fn sample_locations(mut self, sample_locations: &'a [SampleLocationEXT]) -> Self {
22821 self.inner.sample_locations_count = sample_locations.len() as _;
22822 self.inner.p_sample_locations = sample_locations.as_ptr();
22823 self
22824 }
22825 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22826 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22827 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22828 pub fn build(self) -> SampleLocationsInfoEXT {
22829 self.inner
22830 }
22831}
22832#[repr(C)]
22833#[cfg_attr(feature = "debug", derive(Debug))]
22834#[derive(Copy, Clone, Default)]
22835#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentSampleLocationsEXT.html>"]
22836pub struct AttachmentSampleLocationsEXT {
22837 pub attachment_index: u32,
22838 pub sample_locations_info: SampleLocationsInfoEXT,
22839}
22840impl AttachmentSampleLocationsEXT {
22841 pub fn builder<'a>() -> AttachmentSampleLocationsEXTBuilder<'a> {
22842 AttachmentSampleLocationsEXTBuilder {
22843 inner: Self::default(),
22844 marker: ::std::marker::PhantomData,
22845 }
22846 }
22847}
22848#[repr(transparent)]
22849pub struct AttachmentSampleLocationsEXTBuilder<'a> {
22850 inner: AttachmentSampleLocationsEXT,
22851 marker: ::std::marker::PhantomData<&'a ()>,
22852}
22853impl<'a> ::std::ops::Deref for AttachmentSampleLocationsEXTBuilder<'a> {
22854 type Target = AttachmentSampleLocationsEXT;
22855 fn deref(&self) -> &Self::Target {
22856 &self.inner
22857 }
22858}
22859impl<'a> ::std::ops::DerefMut for AttachmentSampleLocationsEXTBuilder<'a> {
22860 fn deref_mut(&mut self) -> &mut Self::Target {
22861 &mut self.inner
22862 }
22863}
22864impl<'a> AttachmentSampleLocationsEXTBuilder<'a> {
22865 pub fn attachment_index(mut self, attachment_index: u32) -> Self {
22866 self.inner.attachment_index = attachment_index;
22867 self
22868 }
22869 pub fn sample_locations_info(mut self, sample_locations_info: SampleLocationsInfoEXT) -> Self {
22870 self.inner.sample_locations_info = sample_locations_info;
22871 self
22872 }
22873 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22874 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22875 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22876 pub fn build(self) -> AttachmentSampleLocationsEXT {
22877 self.inner
22878 }
22879}
22880#[repr(C)]
22881#[cfg_attr(feature = "debug", derive(Debug))]
22882#[derive(Copy, Clone, Default)]
22883#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassSampleLocationsEXT.html>"]
22884pub struct SubpassSampleLocationsEXT {
22885 pub subpass_index: u32,
22886 pub sample_locations_info: SampleLocationsInfoEXT,
22887}
22888impl SubpassSampleLocationsEXT {
22889 pub fn builder<'a>() -> SubpassSampleLocationsEXTBuilder<'a> {
22890 SubpassSampleLocationsEXTBuilder {
22891 inner: Self::default(),
22892 marker: ::std::marker::PhantomData,
22893 }
22894 }
22895}
22896#[repr(transparent)]
22897pub struct SubpassSampleLocationsEXTBuilder<'a> {
22898 inner: SubpassSampleLocationsEXT,
22899 marker: ::std::marker::PhantomData<&'a ()>,
22900}
22901impl<'a> ::std::ops::Deref for SubpassSampleLocationsEXTBuilder<'a> {
22902 type Target = SubpassSampleLocationsEXT;
22903 fn deref(&self) -> &Self::Target {
22904 &self.inner
22905 }
22906}
22907impl<'a> ::std::ops::DerefMut for SubpassSampleLocationsEXTBuilder<'a> {
22908 fn deref_mut(&mut self) -> &mut Self::Target {
22909 &mut self.inner
22910 }
22911}
22912impl<'a> SubpassSampleLocationsEXTBuilder<'a> {
22913 pub fn subpass_index(mut self, subpass_index: u32) -> Self {
22914 self.inner.subpass_index = subpass_index;
22915 self
22916 }
22917 pub fn sample_locations_info(mut self, sample_locations_info: SampleLocationsInfoEXT) -> Self {
22918 self.inner.sample_locations_info = sample_locations_info;
22919 self
22920 }
22921 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22922 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22923 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22924 pub fn build(self) -> SubpassSampleLocationsEXT {
22925 self.inner
22926 }
22927}
22928#[repr(C)]
22929#[cfg_attr(feature = "debug", derive(Debug))]
22930#[derive(Copy, Clone)]
22931#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassSampleLocationsBeginInfoEXT.html>"]
22932pub struct RenderPassSampleLocationsBeginInfoEXT {
22933 pub s_type: StructureType,
22934 pub p_next: *const c_void,
22935 pub attachment_initial_sample_locations_count: u32,
22936 pub p_attachment_initial_sample_locations: *const AttachmentSampleLocationsEXT,
22937 pub post_subpass_sample_locations_count: u32,
22938 pub p_post_subpass_sample_locations: *const SubpassSampleLocationsEXT,
22939}
22940impl ::std::default::Default for RenderPassSampleLocationsBeginInfoEXT {
22941 fn default() -> Self {
22942 Self {
22943 s_type: StructureType::RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT,
22944 p_next: ::std::ptr::null(),
22945 attachment_initial_sample_locations_count: u32::default(),
22946 p_attachment_initial_sample_locations: ::std::ptr::null(),
22947 post_subpass_sample_locations_count: u32::default(),
22948 p_post_subpass_sample_locations: ::std::ptr::null(),
22949 }
22950 }
22951}
22952impl RenderPassSampleLocationsBeginInfoEXT {
22953 pub fn builder<'a>() -> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
22954 RenderPassSampleLocationsBeginInfoEXTBuilder {
22955 inner: Self::default(),
22956 marker: ::std::marker::PhantomData,
22957 }
22958 }
22959}
22960#[repr(transparent)]
22961pub struct RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
22962 inner: RenderPassSampleLocationsBeginInfoEXT,
22963 marker: ::std::marker::PhantomData<&'a ()>,
22964}
22965unsafe impl ExtendsRenderPassBeginInfo for RenderPassSampleLocationsBeginInfoEXTBuilder<'_> {}
22966unsafe impl ExtendsRenderPassBeginInfo for RenderPassSampleLocationsBeginInfoEXT {}
22967impl<'a> ::std::ops::Deref for RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
22968 type Target = RenderPassSampleLocationsBeginInfoEXT;
22969 fn deref(&self) -> &Self::Target {
22970 &self.inner
22971 }
22972}
22973impl<'a> ::std::ops::DerefMut for RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
22974 fn deref_mut(&mut self) -> &mut Self::Target {
22975 &mut self.inner
22976 }
22977}
22978impl<'a> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
22979 pub fn attachment_initial_sample_locations(
22980 mut self,
22981 attachment_initial_sample_locations: &'a [AttachmentSampleLocationsEXT],
22982 ) -> Self {
22983 self.inner.attachment_initial_sample_locations_count =
22984 attachment_initial_sample_locations.len() as _;
22985 self.inner.p_attachment_initial_sample_locations =
22986 attachment_initial_sample_locations.as_ptr();
22987 self
22988 }
22989 pub fn post_subpass_sample_locations(
22990 mut self,
22991 post_subpass_sample_locations: &'a [SubpassSampleLocationsEXT],
22992 ) -> Self {
22993 self.inner.post_subpass_sample_locations_count = post_subpass_sample_locations.len() as _;
22994 self.inner.p_post_subpass_sample_locations = post_subpass_sample_locations.as_ptr();
22995 self
22996 }
22997 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22998 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22999 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
23000 pub fn build(self) -> RenderPassSampleLocationsBeginInfoEXT {
23001 self.inner
23002 }
23003}
23004#[repr(C)]
23005#[cfg_attr(feature = "debug", derive(Debug))]
23006#[derive(Copy, Clone)]
23007#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineSampleLocationsStateCreateInfoEXT.html>"]
23008pub struct PipelineSampleLocationsStateCreateInfoEXT {
23009 pub s_type: StructureType,
23010 pub p_next: *const c_void,
23011 pub sample_locations_enable: Bool32,
23012 pub sample_locations_info: SampleLocationsInfoEXT,
23013}
23014impl ::std::default::Default for PipelineSampleLocationsStateCreateInfoEXT {
23015 fn default() -> Self {
23016 Self {
23017 s_type: StructureType::PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT,
23018 p_next: ::std::ptr::null(),
23019 sample_locations_enable: Bool32::default(),
23020 sample_locations_info: SampleLocationsInfoEXT::default(),
23021 }
23022 }
23023}
23024impl PipelineSampleLocationsStateCreateInfoEXT {
23025 pub fn builder<'a>() -> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
23026 PipelineSampleLocationsStateCreateInfoEXTBuilder {
23027 inner: Self::default(),
23028 marker: ::std::marker::PhantomData,
23029 }
23030 }
23031}
23032#[repr(transparent)]
23033pub struct PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
23034 inner: PipelineSampleLocationsStateCreateInfoEXT,
23035 marker: ::std::marker::PhantomData<&'a ()>,
23036}
23037unsafe impl ExtendsPipelineMultisampleStateCreateInfo
23038 for PipelineSampleLocationsStateCreateInfoEXTBuilder<'_>
23039{
23040}
23041unsafe impl ExtendsPipelineMultisampleStateCreateInfo
23042 for PipelineSampleLocationsStateCreateInfoEXT
23043{
23044}
23045impl<'a> ::std::ops::Deref for PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
23046 type Target = PipelineSampleLocationsStateCreateInfoEXT;
23047 fn deref(&self) -> &Self::Target {
23048 &self.inner
23049 }
23050}
23051impl<'a> ::std::ops::DerefMut for PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
23052 fn deref_mut(&mut self) -> &mut Self::Target {
23053 &mut self.inner
23054 }
23055}
23056impl<'a> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
23057 pub fn sample_locations_enable(mut self, sample_locations_enable: bool) -> Self {
23058 self.inner.sample_locations_enable = sample_locations_enable.into();
23059 self
23060 }
23061 pub fn sample_locations_info(mut self, sample_locations_info: SampleLocationsInfoEXT) -> Self {
23062 self.inner.sample_locations_info = sample_locations_info;
23063 self
23064 }
23065 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23066 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23067 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
23068 pub fn build(self) -> PipelineSampleLocationsStateCreateInfoEXT {
23069 self.inner
23070 }
23071}
23072#[repr(C)]
23073#[cfg_attr(feature = "debug", derive(Debug))]
23074#[derive(Copy, Clone)]
23075#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSampleLocationsPropertiesEXT.html>"]
23076pub struct PhysicalDeviceSampleLocationsPropertiesEXT {
23077 pub s_type: StructureType,
23078 pub p_next: *mut c_void,
23079 pub sample_location_sample_counts: SampleCountFlags,
23080 pub max_sample_location_grid_size: Extent2D,
23081 pub sample_location_coordinate_range: [f32; 2],
23082 pub sample_location_sub_pixel_bits: u32,
23083 pub variable_sample_locations: Bool32,
23084}
23085impl ::std::default::Default for PhysicalDeviceSampleLocationsPropertiesEXT {
23086 fn default() -> Self {
23087 Self {
23088 s_type: StructureType::PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT,
23089 p_next: ::std::ptr::null_mut(),
23090 sample_location_sample_counts: SampleCountFlags::default(),
23091 max_sample_location_grid_size: Extent2D::default(),
23092 sample_location_coordinate_range: unsafe { ::std::mem::zeroed() },
23093 sample_location_sub_pixel_bits: u32::default(),
23094 variable_sample_locations: Bool32::default(),
23095 }
23096 }
23097}
23098impl PhysicalDeviceSampleLocationsPropertiesEXT {
23099 pub fn builder<'a>() -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
23100 PhysicalDeviceSampleLocationsPropertiesEXTBuilder {
23101 inner: Self::default(),
23102 marker: ::std::marker::PhantomData,
23103 }
23104 }
23105}
23106#[repr(transparent)]
23107pub struct PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
23108 inner: PhysicalDeviceSampleLocationsPropertiesEXT,
23109 marker: ::std::marker::PhantomData<&'a ()>,
23110}
23111unsafe impl ExtendsPhysicalDeviceProperties2
23112 for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'_>
23113{
23114}
23115unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSampleLocationsPropertiesEXT {}
23116impl<'a> ::std::ops::Deref for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
23117 type Target = PhysicalDeviceSampleLocationsPropertiesEXT;
23118 fn deref(&self) -> &Self::Target {
23119 &self.inner
23120 }
23121}
23122impl<'a> ::std::ops::DerefMut for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
23123 fn deref_mut(&mut self) -> &mut Self::Target {
23124 &mut self.inner
23125 }
23126}
23127impl<'a> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
23128 pub fn sample_location_sample_counts(
23129 mut self,
23130 sample_location_sample_counts: SampleCountFlags,
23131 ) -> Self {
23132 self.inner.sample_location_sample_counts = sample_location_sample_counts;
23133 self
23134 }
23135 pub fn max_sample_location_grid_size(
23136 mut self,
23137 max_sample_location_grid_size: Extent2D,
23138 ) -> Self {
23139 self.inner.max_sample_location_grid_size = max_sample_location_grid_size;
23140 self
23141 }
23142 pub fn sample_location_coordinate_range(
23143 mut self,
23144 sample_location_coordinate_range: [f32; 2],
23145 ) -> Self {
23146 self.inner.sample_location_coordinate_range = sample_location_coordinate_range;
23147 self
23148 }
23149 pub fn sample_location_sub_pixel_bits(mut self, sample_location_sub_pixel_bits: u32) -> Self {
23150 self.inner.sample_location_sub_pixel_bits = sample_location_sub_pixel_bits;
23151 self
23152 }
23153 pub fn variable_sample_locations(mut self, variable_sample_locations: bool) -> Self {
23154 self.inner.variable_sample_locations = variable_sample_locations.into();
23155 self
23156 }
23157 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23158 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23159 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
23160 pub fn build(self) -> PhysicalDeviceSampleLocationsPropertiesEXT {
23161 self.inner
23162 }
23163}
23164#[repr(C)]
23165#[cfg_attr(feature = "debug", derive(Debug))]
23166#[derive(Copy, Clone)]
23167#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMultisamplePropertiesEXT.html>"]
23168pub struct MultisamplePropertiesEXT {
23169 pub s_type: StructureType,
23170 pub p_next: *mut c_void,
23171 pub max_sample_location_grid_size: Extent2D,
23172}
23173impl ::std::default::Default for MultisamplePropertiesEXT {
23174 fn default() -> Self {
23175 Self {
23176 s_type: StructureType::MULTISAMPLE_PROPERTIES_EXT,
23177 p_next: ::std::ptr::null_mut(),
23178 max_sample_location_grid_size: Extent2D::default(),
23179 }
23180 }
23181}
23182impl MultisamplePropertiesEXT {
23183 pub fn builder<'a>() -> MultisamplePropertiesEXTBuilder<'a> {
23184 MultisamplePropertiesEXTBuilder {
23185 inner: Self::default(),
23186 marker: ::std::marker::PhantomData,
23187 }
23188 }
23189}
23190#[repr(transparent)]
23191pub struct MultisamplePropertiesEXTBuilder<'a> {
23192 inner: MultisamplePropertiesEXT,
23193 marker: ::std::marker::PhantomData<&'a ()>,
23194}
23195impl<'a> ::std::ops::Deref for MultisamplePropertiesEXTBuilder<'a> {
23196 type Target = MultisamplePropertiesEXT;
23197 fn deref(&self) -> &Self::Target {
23198 &self.inner
23199 }
23200}
23201impl<'a> ::std::ops::DerefMut for MultisamplePropertiesEXTBuilder<'a> {
23202 fn deref_mut(&mut self) -> &mut Self::Target {
23203 &mut self.inner
23204 }
23205}
23206impl<'a> MultisamplePropertiesEXTBuilder<'a> {
23207 pub fn max_sample_location_grid_size(
23208 mut self,
23209 max_sample_location_grid_size: Extent2D,
23210 ) -> Self {
23211 self.inner.max_sample_location_grid_size = max_sample_location_grid_size;
23212 self
23213 }
23214 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23215 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23216 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
23217 pub fn build(self) -> MultisamplePropertiesEXT {
23218 self.inner
23219 }
23220}
23221#[repr(C)]
23222#[cfg_attr(feature = "debug", derive(Debug))]
23223#[derive(Copy, Clone)]
23224#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerReductionModeCreateInfo.html>"]
23225pub struct SamplerReductionModeCreateInfo {
23226 pub s_type: StructureType,
23227 pub p_next: *const c_void,
23228 pub reduction_mode: SamplerReductionMode,
23229}
23230impl ::std::default::Default for SamplerReductionModeCreateInfo {
23231 fn default() -> Self {
23232 Self {
23233 s_type: StructureType::SAMPLER_REDUCTION_MODE_CREATE_INFO,
23234 p_next: ::std::ptr::null(),
23235 reduction_mode: SamplerReductionMode::default(),
23236 }
23237 }
23238}
23239impl SamplerReductionModeCreateInfo {
23240 pub fn builder<'a>() -> SamplerReductionModeCreateInfoBuilder<'a> {
23241 SamplerReductionModeCreateInfoBuilder {
23242 inner: Self::default(),
23243 marker: ::std::marker::PhantomData,
23244 }
23245 }
23246}
23247#[repr(transparent)]
23248pub struct SamplerReductionModeCreateInfoBuilder<'a> {
23249 inner: SamplerReductionModeCreateInfo,
23250 marker: ::std::marker::PhantomData<&'a ()>,
23251}
23252unsafe impl ExtendsSamplerCreateInfo for SamplerReductionModeCreateInfoBuilder<'_> {}
23253unsafe impl ExtendsSamplerCreateInfo for SamplerReductionModeCreateInfo {}
23254impl<'a> ::std::ops::Deref for SamplerReductionModeCreateInfoBuilder<'a> {
23255 type Target = SamplerReductionModeCreateInfo;
23256 fn deref(&self) -> &Self::Target {
23257 &self.inner
23258 }
23259}
23260impl<'a> ::std::ops::DerefMut for SamplerReductionModeCreateInfoBuilder<'a> {
23261 fn deref_mut(&mut self) -> &mut Self::Target {
23262 &mut self.inner
23263 }
23264}
23265impl<'a> SamplerReductionModeCreateInfoBuilder<'a> {
23266 pub fn reduction_mode(mut self, reduction_mode: SamplerReductionMode) -> Self {
23267 self.inner.reduction_mode = reduction_mode;
23268 self
23269 }
23270 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23271 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23272 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
23273 pub fn build(self) -> SamplerReductionModeCreateInfo {
23274 self.inner
23275 }
23276}
23277#[repr(C)]
23278#[cfg_attr(feature = "debug", derive(Debug))]
23279#[derive(Copy, Clone)]
23280#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT.html>"]
23281pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
23282 pub s_type: StructureType,
23283 pub p_next: *mut c_void,
23284 pub advanced_blend_coherent_operations: Bool32,
23285}
23286impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
23287 fn default() -> Self {
23288 Self {
23289 s_type: StructureType::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT,
23290 p_next: ::std::ptr::null_mut(),
23291 advanced_blend_coherent_operations: Bool32::default(),
23292 }
23293 }
23294}
23295impl PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
23296 pub fn builder<'a>() -> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
23297 PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder {
23298 inner: Self::default(),
23299 marker: ::std::marker::PhantomData,
23300 }
23301 }
23302}
23303#[repr(transparent)]
23304pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
23305 inner: PhysicalDeviceBlendOperationAdvancedFeaturesEXT,
23306 marker: ::std::marker::PhantomData<&'a ()>,
23307}
23308unsafe impl ExtendsPhysicalDeviceFeatures2
23309 for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'_>
23310{
23311}
23312unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBlendOperationAdvancedFeaturesEXT {}
23313unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'_> {}
23314unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBlendOperationAdvancedFeaturesEXT {}
23315impl<'a> ::std::ops::Deref for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
23316 type Target = PhysicalDeviceBlendOperationAdvancedFeaturesEXT;
23317 fn deref(&self) -> &Self::Target {
23318 &self.inner
23319 }
23320}
23321impl<'a> ::std::ops::DerefMut for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
23322 fn deref_mut(&mut self) -> &mut Self::Target {
23323 &mut self.inner
23324 }
23325}
23326impl<'a> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
23327 pub fn advanced_blend_coherent_operations(
23328 mut self,
23329 advanced_blend_coherent_operations: bool,
23330 ) -> Self {
23331 self.inner.advanced_blend_coherent_operations = advanced_blend_coherent_operations.into();
23332 self
23333 }
23334 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23335 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23336 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
23337 pub fn build(self) -> PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
23338 self.inner
23339 }
23340}
23341#[repr(C)]
23342#[cfg_attr(feature = "debug", derive(Debug))]
23343#[derive(Copy, Clone)]
23344#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiDrawFeaturesEXT.html>"]
23345pub struct PhysicalDeviceMultiDrawFeaturesEXT {
23346 pub s_type: StructureType,
23347 pub p_next: *mut c_void,
23348 pub multi_draw: Bool32,
23349}
23350impl ::std::default::Default for PhysicalDeviceMultiDrawFeaturesEXT {
23351 fn default() -> Self {
23352 Self {
23353 s_type: StructureType::PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT,
23354 p_next: ::std::ptr::null_mut(),
23355 multi_draw: Bool32::default(),
23356 }
23357 }
23358}
23359impl PhysicalDeviceMultiDrawFeaturesEXT {
23360 pub fn builder<'a>() -> PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> {
23361 PhysicalDeviceMultiDrawFeaturesEXTBuilder {
23362 inner: Self::default(),
23363 marker: ::std::marker::PhantomData,
23364 }
23365 }
23366}
23367#[repr(transparent)]
23368pub struct PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> {
23369 inner: PhysicalDeviceMultiDrawFeaturesEXT,
23370 marker: ::std::marker::PhantomData<&'a ()>,
23371}
23372unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiDrawFeaturesEXTBuilder<'_> {}
23373unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiDrawFeaturesEXT {}
23374unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiDrawFeaturesEXTBuilder<'_> {}
23375unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiDrawFeaturesEXT {}
23376impl<'a> ::std::ops::Deref for PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> {
23377 type Target = PhysicalDeviceMultiDrawFeaturesEXT;
23378 fn deref(&self) -> &Self::Target {
23379 &self.inner
23380 }
23381}
23382impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> {
23383 fn deref_mut(&mut self) -> &mut Self::Target {
23384 &mut self.inner
23385 }
23386}
23387impl<'a> PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> {
23388 pub fn multi_draw(mut self, multi_draw: bool) -> Self {
23389 self.inner.multi_draw = multi_draw.into();
23390 self
23391 }
23392 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23393 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23394 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
23395 pub fn build(self) -> PhysicalDeviceMultiDrawFeaturesEXT {
23396 self.inner
23397 }
23398}
23399#[repr(C)]
23400#[cfg_attr(feature = "debug", derive(Debug))]
23401#[derive(Copy, Clone)]
23402#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT.html>"]
23403pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
23404 pub s_type: StructureType,
23405 pub p_next: *mut c_void,
23406 pub advanced_blend_max_color_attachments: u32,
23407 pub advanced_blend_independent_blend: Bool32,
23408 pub advanced_blend_non_premultiplied_src_color: Bool32,
23409 pub advanced_blend_non_premultiplied_dst_color: Bool32,
23410 pub advanced_blend_correlated_overlap: Bool32,
23411 pub advanced_blend_all_operations: Bool32,
23412}
23413impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
23414 fn default() -> Self {
23415 Self {
23416 s_type: StructureType::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT,
23417 p_next: ::std::ptr::null_mut(),
23418 advanced_blend_max_color_attachments: u32::default(),
23419 advanced_blend_independent_blend: Bool32::default(),
23420 advanced_blend_non_premultiplied_src_color: Bool32::default(),
23421 advanced_blend_non_premultiplied_dst_color: Bool32::default(),
23422 advanced_blend_correlated_overlap: Bool32::default(),
23423 advanced_blend_all_operations: Bool32::default(),
23424 }
23425 }
23426}
23427impl PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
23428 pub fn builder<'a>() -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
23429 PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder {
23430 inner: Self::default(),
23431 marker: ::std::marker::PhantomData,
23432 }
23433 }
23434}
23435#[repr(transparent)]
23436pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
23437 inner: PhysicalDeviceBlendOperationAdvancedPropertiesEXT,
23438 marker: ::std::marker::PhantomData<&'a ()>,
23439}
23440unsafe impl ExtendsPhysicalDeviceProperties2
23441 for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'_>
23442{
23443}
23444unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceBlendOperationAdvancedPropertiesEXT {}
23445impl<'a> ::std::ops::Deref for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
23446 type Target = PhysicalDeviceBlendOperationAdvancedPropertiesEXT;
23447 fn deref(&self) -> &Self::Target {
23448 &self.inner
23449 }
23450}
23451impl<'a> ::std::ops::DerefMut for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
23452 fn deref_mut(&mut self) -> &mut Self::Target {
23453 &mut self.inner
23454 }
23455}
23456impl<'a> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
23457 pub fn advanced_blend_max_color_attachments(
23458 mut self,
23459 advanced_blend_max_color_attachments: u32,
23460 ) -> Self {
23461 self.inner.advanced_blend_max_color_attachments = advanced_blend_max_color_attachments;
23462 self
23463 }
23464 pub fn advanced_blend_independent_blend(
23465 mut self,
23466 advanced_blend_independent_blend: bool,
23467 ) -> Self {
23468 self.inner.advanced_blend_independent_blend = advanced_blend_independent_blend.into();
23469 self
23470 }
23471 pub fn advanced_blend_non_premultiplied_src_color(
23472 mut self,
23473 advanced_blend_non_premultiplied_src_color: bool,
23474 ) -> Self {
23475 self.inner.advanced_blend_non_premultiplied_src_color =
23476 advanced_blend_non_premultiplied_src_color.into();
23477 self
23478 }
23479 pub fn advanced_blend_non_premultiplied_dst_color(
23480 mut self,
23481 advanced_blend_non_premultiplied_dst_color: bool,
23482 ) -> Self {
23483 self.inner.advanced_blend_non_premultiplied_dst_color =
23484 advanced_blend_non_premultiplied_dst_color.into();
23485 self
23486 }
23487 pub fn advanced_blend_correlated_overlap(
23488 mut self,
23489 advanced_blend_correlated_overlap: bool,
23490 ) -> Self {
23491 self.inner.advanced_blend_correlated_overlap = advanced_blend_correlated_overlap.into();
23492 self
23493 }
23494 pub fn advanced_blend_all_operations(mut self, advanced_blend_all_operations: bool) -> Self {
23495 self.inner.advanced_blend_all_operations = advanced_blend_all_operations.into();
23496 self
23497 }
23498 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23499 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23500 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
23501 pub fn build(self) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
23502 self.inner
23503 }
23504}
23505#[repr(C)]
23506#[cfg_attr(feature = "debug", derive(Debug))]
23507#[derive(Copy, Clone)]
23508#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineColorBlendAdvancedStateCreateInfoEXT.html>"]
23509pub struct PipelineColorBlendAdvancedStateCreateInfoEXT {
23510 pub s_type: StructureType,
23511 pub p_next: *const c_void,
23512 pub src_premultiplied: Bool32,
23513 pub dst_premultiplied: Bool32,
23514 pub blend_overlap: BlendOverlapEXT,
23515}
23516impl ::std::default::Default for PipelineColorBlendAdvancedStateCreateInfoEXT {
23517 fn default() -> Self {
23518 Self {
23519 s_type: StructureType::PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT,
23520 p_next: ::std::ptr::null(),
23521 src_premultiplied: Bool32::default(),
23522 dst_premultiplied: Bool32::default(),
23523 blend_overlap: BlendOverlapEXT::default(),
23524 }
23525 }
23526}
23527impl PipelineColorBlendAdvancedStateCreateInfoEXT {
23528 pub fn builder<'a>() -> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
23529 PipelineColorBlendAdvancedStateCreateInfoEXTBuilder {
23530 inner: Self::default(),
23531 marker: ::std::marker::PhantomData,
23532 }
23533 }
23534}
23535#[repr(transparent)]
23536pub struct PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
23537 inner: PipelineColorBlendAdvancedStateCreateInfoEXT,
23538 marker: ::std::marker::PhantomData<&'a ()>,
23539}
23540unsafe impl ExtendsPipelineColorBlendStateCreateInfo
23541 for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'_>
23542{
23543}
23544unsafe impl ExtendsPipelineColorBlendStateCreateInfo
23545 for PipelineColorBlendAdvancedStateCreateInfoEXT
23546{
23547}
23548impl<'a> ::std::ops::Deref for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
23549 type Target = PipelineColorBlendAdvancedStateCreateInfoEXT;
23550 fn deref(&self) -> &Self::Target {
23551 &self.inner
23552 }
23553}
23554impl<'a> ::std::ops::DerefMut for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
23555 fn deref_mut(&mut self) -> &mut Self::Target {
23556 &mut self.inner
23557 }
23558}
23559impl<'a> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
23560 pub fn src_premultiplied(mut self, src_premultiplied: bool) -> Self {
23561 self.inner.src_premultiplied = src_premultiplied.into();
23562 self
23563 }
23564 pub fn dst_premultiplied(mut self, dst_premultiplied: bool) -> Self {
23565 self.inner.dst_premultiplied = dst_premultiplied.into();
23566 self
23567 }
23568 pub fn blend_overlap(mut self, blend_overlap: BlendOverlapEXT) -> Self {
23569 self.inner.blend_overlap = blend_overlap;
23570 self
23571 }
23572 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23573 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23574 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
23575 pub fn build(self) -> PipelineColorBlendAdvancedStateCreateInfoEXT {
23576 self.inner
23577 }
23578}
23579#[repr(C)]
23580#[cfg_attr(feature = "debug", derive(Debug))]
23581#[derive(Copy, Clone)]
23582#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceInlineUniformBlockFeatures.html>"]
23583pub struct PhysicalDeviceInlineUniformBlockFeatures {
23584 pub s_type: StructureType,
23585 pub p_next: *mut c_void,
23586 pub inline_uniform_block: Bool32,
23587 pub descriptor_binding_inline_uniform_block_update_after_bind: Bool32,
23588}
23589impl ::std::default::Default for PhysicalDeviceInlineUniformBlockFeatures {
23590 fn default() -> Self {
23591 Self {
23592 s_type: StructureType::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES,
23593 p_next: ::std::ptr::null_mut(),
23594 inline_uniform_block: Bool32::default(),
23595 descriptor_binding_inline_uniform_block_update_after_bind: Bool32::default(),
23596 }
23597 }
23598}
23599impl PhysicalDeviceInlineUniformBlockFeatures {
23600 pub fn builder<'a>() -> PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> {
23601 PhysicalDeviceInlineUniformBlockFeaturesBuilder {
23602 inner: Self::default(),
23603 marker: ::std::marker::PhantomData,
23604 }
23605 }
23606}
23607#[repr(transparent)]
23608pub struct PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> {
23609 inner: PhysicalDeviceInlineUniformBlockFeatures,
23610 marker: ::std::marker::PhantomData<&'a ()>,
23611}
23612unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'_> {}
23613unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInlineUniformBlockFeatures {}
23614unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'_> {}
23615unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeatures {}
23616impl<'a> ::std::ops::Deref for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> {
23617 type Target = PhysicalDeviceInlineUniformBlockFeatures;
23618 fn deref(&self) -> &Self::Target {
23619 &self.inner
23620 }
23621}
23622impl<'a> ::std::ops::DerefMut for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> {
23623 fn deref_mut(&mut self) -> &mut Self::Target {
23624 &mut self.inner
23625 }
23626}
23627impl<'a> PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> {
23628 pub fn inline_uniform_block(mut self, inline_uniform_block: bool) -> Self {
23629 self.inner.inline_uniform_block = inline_uniform_block.into();
23630 self
23631 }
23632 pub fn descriptor_binding_inline_uniform_block_update_after_bind(
23633 mut self,
23634 descriptor_binding_inline_uniform_block_update_after_bind: bool,
23635 ) -> Self {
23636 self.inner
23637 .descriptor_binding_inline_uniform_block_update_after_bind =
23638 descriptor_binding_inline_uniform_block_update_after_bind.into();
23639 self
23640 }
23641 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23642 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23643 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
23644 pub fn build(self) -> PhysicalDeviceInlineUniformBlockFeatures {
23645 self.inner
23646 }
23647}
23648#[repr(C)]
23649#[cfg_attr(feature = "debug", derive(Debug))]
23650#[derive(Copy, Clone)]
23651#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceInlineUniformBlockProperties.html>"]
23652pub struct PhysicalDeviceInlineUniformBlockProperties {
23653 pub s_type: StructureType,
23654 pub p_next: *mut c_void,
23655 pub max_inline_uniform_block_size: u32,
23656 pub max_per_stage_descriptor_inline_uniform_blocks: u32,
23657 pub max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32,
23658 pub max_descriptor_set_inline_uniform_blocks: u32,
23659 pub max_descriptor_set_update_after_bind_inline_uniform_blocks: u32,
23660}
23661impl ::std::default::Default for PhysicalDeviceInlineUniformBlockProperties {
23662 fn default() -> Self {
23663 Self {
23664 s_type: StructureType::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES,
23665 p_next: ::std::ptr::null_mut(),
23666 max_inline_uniform_block_size: u32::default(),
23667 max_per_stage_descriptor_inline_uniform_blocks: u32::default(),
23668 max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32::default(),
23669 max_descriptor_set_inline_uniform_blocks: u32::default(),
23670 max_descriptor_set_update_after_bind_inline_uniform_blocks: u32::default(),
23671 }
23672 }
23673}
23674impl PhysicalDeviceInlineUniformBlockProperties {
23675 pub fn builder<'a>() -> PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> {
23676 PhysicalDeviceInlineUniformBlockPropertiesBuilder {
23677 inner: Self::default(),
23678 marker: ::std::marker::PhantomData,
23679 }
23680 }
23681}
23682#[repr(transparent)]
23683pub struct PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> {
23684 inner: PhysicalDeviceInlineUniformBlockProperties,
23685 marker: ::std::marker::PhantomData<&'a ()>,
23686}
23687unsafe impl ExtendsPhysicalDeviceProperties2
23688 for PhysicalDeviceInlineUniformBlockPropertiesBuilder<'_>
23689{
23690}
23691unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceInlineUniformBlockProperties {}
23692impl<'a> ::std::ops::Deref for PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> {
23693 type Target = PhysicalDeviceInlineUniformBlockProperties;
23694 fn deref(&self) -> &Self::Target {
23695 &self.inner
23696 }
23697}
23698impl<'a> ::std::ops::DerefMut for PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> {
23699 fn deref_mut(&mut self) -> &mut Self::Target {
23700 &mut self.inner
23701 }
23702}
23703impl<'a> PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> {
23704 pub fn max_inline_uniform_block_size(mut self, max_inline_uniform_block_size: u32) -> Self {
23705 self.inner.max_inline_uniform_block_size = max_inline_uniform_block_size;
23706 self
23707 }
23708 pub fn max_per_stage_descriptor_inline_uniform_blocks(
23709 mut self,
23710 max_per_stage_descriptor_inline_uniform_blocks: u32,
23711 ) -> Self {
23712 self.inner.max_per_stage_descriptor_inline_uniform_blocks =
23713 max_per_stage_descriptor_inline_uniform_blocks;
23714 self
23715 }
23716 pub fn max_per_stage_descriptor_update_after_bind_inline_uniform_blocks(
23717 mut self,
23718 max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32,
23719 ) -> Self {
23720 self.inner
23721 .max_per_stage_descriptor_update_after_bind_inline_uniform_blocks =
23722 max_per_stage_descriptor_update_after_bind_inline_uniform_blocks;
23723 self
23724 }
23725 pub fn max_descriptor_set_inline_uniform_blocks(
23726 mut self,
23727 max_descriptor_set_inline_uniform_blocks: u32,
23728 ) -> Self {
23729 self.inner.max_descriptor_set_inline_uniform_blocks =
23730 max_descriptor_set_inline_uniform_blocks;
23731 self
23732 }
23733 pub fn max_descriptor_set_update_after_bind_inline_uniform_blocks(
23734 mut self,
23735 max_descriptor_set_update_after_bind_inline_uniform_blocks: u32,
23736 ) -> Self {
23737 self.inner
23738 .max_descriptor_set_update_after_bind_inline_uniform_blocks =
23739 max_descriptor_set_update_after_bind_inline_uniform_blocks;
23740 self
23741 }
23742 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23743 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23744 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
23745 pub fn build(self) -> PhysicalDeviceInlineUniformBlockProperties {
23746 self.inner
23747 }
23748}
23749#[repr(C)]
23750#[cfg_attr(feature = "debug", derive(Debug))]
23751#[derive(Copy, Clone)]
23752#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWriteDescriptorSetInlineUniformBlock.html>"]
23753pub struct WriteDescriptorSetInlineUniformBlock {
23754 pub s_type: StructureType,
23755 pub p_next: *const c_void,
23756 pub data_size: u32,
23757 pub p_data: *const c_void,
23758}
23759impl ::std::default::Default for WriteDescriptorSetInlineUniformBlock {
23760 fn default() -> Self {
23761 Self {
23762 s_type: StructureType::WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK,
23763 p_next: ::std::ptr::null(),
23764 data_size: u32::default(),
23765 p_data: ::std::ptr::null(),
23766 }
23767 }
23768}
23769impl WriteDescriptorSetInlineUniformBlock {
23770 pub fn builder<'a>() -> WriteDescriptorSetInlineUniformBlockBuilder<'a> {
23771 WriteDescriptorSetInlineUniformBlockBuilder {
23772 inner: Self::default(),
23773 marker: ::std::marker::PhantomData,
23774 }
23775 }
23776}
23777#[repr(transparent)]
23778pub struct WriteDescriptorSetInlineUniformBlockBuilder<'a> {
23779 inner: WriteDescriptorSetInlineUniformBlock,
23780 marker: ::std::marker::PhantomData<&'a ()>,
23781}
23782unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetInlineUniformBlockBuilder<'_> {}
23783unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetInlineUniformBlock {}
23784impl<'a> ::std::ops::Deref for WriteDescriptorSetInlineUniformBlockBuilder<'a> {
23785 type Target = WriteDescriptorSetInlineUniformBlock;
23786 fn deref(&self) -> &Self::Target {
23787 &self.inner
23788 }
23789}
23790impl<'a> ::std::ops::DerefMut for WriteDescriptorSetInlineUniformBlockBuilder<'a> {
23791 fn deref_mut(&mut self) -> &mut Self::Target {
23792 &mut self.inner
23793 }
23794}
23795impl<'a> WriteDescriptorSetInlineUniformBlockBuilder<'a> {
23796 pub fn data(mut self, data: &'a [u8]) -> Self {
23797 self.inner.data_size = data.len() as _;
23798 self.inner.p_data = data.as_ptr() as *const c_void;
23799 self
23800 }
23801 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23802 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23803 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
23804 pub fn build(self) -> WriteDescriptorSetInlineUniformBlock {
23805 self.inner
23806 }
23807}
23808#[repr(C)]
23809#[cfg_attr(feature = "debug", derive(Debug))]
23810#[derive(Copy, Clone)]
23811#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPoolInlineUniformBlockCreateInfo.html>"]
23812pub struct DescriptorPoolInlineUniformBlockCreateInfo {
23813 pub s_type: StructureType,
23814 pub p_next: *const c_void,
23815 pub max_inline_uniform_block_bindings: u32,
23816}
23817impl ::std::default::Default for DescriptorPoolInlineUniformBlockCreateInfo {
23818 fn default() -> Self {
23819 Self {
23820 s_type: StructureType::DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO,
23821 p_next: ::std::ptr::null(),
23822 max_inline_uniform_block_bindings: u32::default(),
23823 }
23824 }
23825}
23826impl DescriptorPoolInlineUniformBlockCreateInfo {
23827 pub fn builder<'a>() -> DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> {
23828 DescriptorPoolInlineUniformBlockCreateInfoBuilder {
23829 inner: Self::default(),
23830 marker: ::std::marker::PhantomData,
23831 }
23832 }
23833}
23834#[repr(transparent)]
23835pub struct DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> {
23836 inner: DescriptorPoolInlineUniformBlockCreateInfo,
23837 marker: ::std::marker::PhantomData<&'a ()>,
23838}
23839unsafe impl ExtendsDescriptorPoolCreateInfo
23840 for DescriptorPoolInlineUniformBlockCreateInfoBuilder<'_>
23841{
23842}
23843unsafe impl ExtendsDescriptorPoolCreateInfo for DescriptorPoolInlineUniformBlockCreateInfo {}
23844impl<'a> ::std::ops::Deref for DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> {
23845 type Target = DescriptorPoolInlineUniformBlockCreateInfo;
23846 fn deref(&self) -> &Self::Target {
23847 &self.inner
23848 }
23849}
23850impl<'a> ::std::ops::DerefMut for DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> {
23851 fn deref_mut(&mut self) -> &mut Self::Target {
23852 &mut self.inner
23853 }
23854}
23855impl<'a> DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> {
23856 pub fn max_inline_uniform_block_bindings(
23857 mut self,
23858 max_inline_uniform_block_bindings: u32,
23859 ) -> Self {
23860 self.inner.max_inline_uniform_block_bindings = max_inline_uniform_block_bindings;
23861 self
23862 }
23863 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23864 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23865 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
23866 pub fn build(self) -> DescriptorPoolInlineUniformBlockCreateInfo {
23867 self.inner
23868 }
23869}
23870#[repr(C)]
23871#[cfg_attr(feature = "debug", derive(Debug))]
23872#[derive(Copy, Clone)]
23873#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageModulationStateCreateInfoNV.html>"]
23874pub struct PipelineCoverageModulationStateCreateInfoNV {
23875 pub s_type: StructureType,
23876 pub p_next: *const c_void,
23877 pub flags: PipelineCoverageModulationStateCreateFlagsNV,
23878 pub coverage_modulation_mode: CoverageModulationModeNV,
23879 pub coverage_modulation_table_enable: Bool32,
23880 pub coverage_modulation_table_count: u32,
23881 pub p_coverage_modulation_table: *const f32,
23882}
23883impl ::std::default::Default for PipelineCoverageModulationStateCreateInfoNV {
23884 fn default() -> Self {
23885 Self {
23886 s_type: StructureType::PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV,
23887 p_next: ::std::ptr::null(),
23888 flags: PipelineCoverageModulationStateCreateFlagsNV::default(),
23889 coverage_modulation_mode: CoverageModulationModeNV::default(),
23890 coverage_modulation_table_enable: Bool32::default(),
23891 coverage_modulation_table_count: u32::default(),
23892 p_coverage_modulation_table: ::std::ptr::null(),
23893 }
23894 }
23895}
23896impl PipelineCoverageModulationStateCreateInfoNV {
23897 pub fn builder<'a>() -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
23898 PipelineCoverageModulationStateCreateInfoNVBuilder {
23899 inner: Self::default(),
23900 marker: ::std::marker::PhantomData,
23901 }
23902 }
23903}
23904#[repr(transparent)]
23905pub struct PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
23906 inner: PipelineCoverageModulationStateCreateInfoNV,
23907 marker: ::std::marker::PhantomData<&'a ()>,
23908}
23909unsafe impl ExtendsPipelineMultisampleStateCreateInfo
23910 for PipelineCoverageModulationStateCreateInfoNVBuilder<'_>
23911{
23912}
23913unsafe impl ExtendsPipelineMultisampleStateCreateInfo
23914 for PipelineCoverageModulationStateCreateInfoNV
23915{
23916}
23917impl<'a> ::std::ops::Deref for PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
23918 type Target = PipelineCoverageModulationStateCreateInfoNV;
23919 fn deref(&self) -> &Self::Target {
23920 &self.inner
23921 }
23922}
23923impl<'a> ::std::ops::DerefMut for PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
23924 fn deref_mut(&mut self) -> &mut Self::Target {
23925 &mut self.inner
23926 }
23927}
23928impl<'a> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
23929 pub fn flags(mut self, flags: PipelineCoverageModulationStateCreateFlagsNV) -> Self {
23930 self.inner.flags = flags;
23931 self
23932 }
23933 pub fn coverage_modulation_mode(
23934 mut self,
23935 coverage_modulation_mode: CoverageModulationModeNV,
23936 ) -> Self {
23937 self.inner.coverage_modulation_mode = coverage_modulation_mode;
23938 self
23939 }
23940 pub fn coverage_modulation_table_enable(
23941 mut self,
23942 coverage_modulation_table_enable: bool,
23943 ) -> Self {
23944 self.inner.coverage_modulation_table_enable = coverage_modulation_table_enable.into();
23945 self
23946 }
23947 pub fn coverage_modulation_table(mut self, coverage_modulation_table: &'a [f32]) -> Self {
23948 self.inner.coverage_modulation_table_count = coverage_modulation_table.len() as _;
23949 self.inner.p_coverage_modulation_table = coverage_modulation_table.as_ptr();
23950 self
23951 }
23952 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23953 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23954 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
23955 pub fn build(self) -> PipelineCoverageModulationStateCreateInfoNV {
23956 self.inner
23957 }
23958}
23959#[repr(C)]
23960#[cfg_attr(feature = "debug", derive(Debug))]
23961#[derive(Copy, Clone)]
23962#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageFormatListCreateInfo.html>"]
23963pub struct ImageFormatListCreateInfo {
23964 pub s_type: StructureType,
23965 pub p_next: *const c_void,
23966 pub view_format_count: u32,
23967 pub p_view_formats: *const Format,
23968}
23969impl ::std::default::Default for ImageFormatListCreateInfo {
23970 fn default() -> Self {
23971 Self {
23972 s_type: StructureType::IMAGE_FORMAT_LIST_CREATE_INFO,
23973 p_next: ::std::ptr::null(),
23974 view_format_count: u32::default(),
23975 p_view_formats: ::std::ptr::null(),
23976 }
23977 }
23978}
23979impl ImageFormatListCreateInfo {
23980 pub fn builder<'a>() -> ImageFormatListCreateInfoBuilder<'a> {
23981 ImageFormatListCreateInfoBuilder {
23982 inner: Self::default(),
23983 marker: ::std::marker::PhantomData,
23984 }
23985 }
23986}
23987#[repr(transparent)]
23988pub struct ImageFormatListCreateInfoBuilder<'a> {
23989 inner: ImageFormatListCreateInfo,
23990 marker: ::std::marker::PhantomData<&'a ()>,
23991}
23992unsafe impl ExtendsImageCreateInfo for ImageFormatListCreateInfoBuilder<'_> {}
23993unsafe impl ExtendsImageCreateInfo for ImageFormatListCreateInfo {}
23994unsafe impl ExtendsSwapchainCreateInfoKHR for ImageFormatListCreateInfoBuilder<'_> {}
23995unsafe impl ExtendsSwapchainCreateInfoKHR for ImageFormatListCreateInfo {}
23996unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageFormatListCreateInfoBuilder<'_> {}
23997unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageFormatListCreateInfo {}
23998impl<'a> ::std::ops::Deref for ImageFormatListCreateInfoBuilder<'a> {
23999 type Target = ImageFormatListCreateInfo;
24000 fn deref(&self) -> &Self::Target {
24001 &self.inner
24002 }
24003}
24004impl<'a> ::std::ops::DerefMut for ImageFormatListCreateInfoBuilder<'a> {
24005 fn deref_mut(&mut self) -> &mut Self::Target {
24006 &mut self.inner
24007 }
24008}
24009impl<'a> ImageFormatListCreateInfoBuilder<'a> {
24010 pub fn view_formats(mut self, view_formats: &'a [Format]) -> Self {
24011 self.inner.view_format_count = view_formats.len() as _;
24012 self.inner.p_view_formats = view_formats.as_ptr();
24013 self
24014 }
24015 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24016 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24017 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24018 pub fn build(self) -> ImageFormatListCreateInfo {
24019 self.inner
24020 }
24021}
24022#[repr(C)]
24023#[cfg_attr(feature = "debug", derive(Debug))]
24024#[derive(Copy, Clone)]
24025#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationCacheCreateInfoEXT.html>"]
24026pub struct ValidationCacheCreateInfoEXT {
24027 pub s_type: StructureType,
24028 pub p_next: *const c_void,
24029 pub flags: ValidationCacheCreateFlagsEXT,
24030 pub initial_data_size: usize,
24031 pub p_initial_data: *const c_void,
24032}
24033impl ::std::default::Default for ValidationCacheCreateInfoEXT {
24034 fn default() -> Self {
24035 Self {
24036 s_type: StructureType::VALIDATION_CACHE_CREATE_INFO_EXT,
24037 p_next: ::std::ptr::null(),
24038 flags: ValidationCacheCreateFlagsEXT::default(),
24039 initial_data_size: usize::default(),
24040 p_initial_data: ::std::ptr::null(),
24041 }
24042 }
24043}
24044impl ValidationCacheCreateInfoEXT {
24045 pub fn builder<'a>() -> ValidationCacheCreateInfoEXTBuilder<'a> {
24046 ValidationCacheCreateInfoEXTBuilder {
24047 inner: Self::default(),
24048 marker: ::std::marker::PhantomData,
24049 }
24050 }
24051}
24052#[repr(transparent)]
24053pub struct ValidationCacheCreateInfoEXTBuilder<'a> {
24054 inner: ValidationCacheCreateInfoEXT,
24055 marker: ::std::marker::PhantomData<&'a ()>,
24056}
24057impl<'a> ::std::ops::Deref for ValidationCacheCreateInfoEXTBuilder<'a> {
24058 type Target = ValidationCacheCreateInfoEXT;
24059 fn deref(&self) -> &Self::Target {
24060 &self.inner
24061 }
24062}
24063impl<'a> ::std::ops::DerefMut for ValidationCacheCreateInfoEXTBuilder<'a> {
24064 fn deref_mut(&mut self) -> &mut Self::Target {
24065 &mut self.inner
24066 }
24067}
24068impl<'a> ValidationCacheCreateInfoEXTBuilder<'a> {
24069 pub fn flags(mut self, flags: ValidationCacheCreateFlagsEXT) -> Self {
24070 self.inner.flags = flags;
24071 self
24072 }
24073 pub fn initial_data(mut self, initial_data: &'a [u8]) -> Self {
24074 self.inner.initial_data_size = initial_data.len();
24075 self.inner.p_initial_data = initial_data.as_ptr() as *const c_void;
24076 self
24077 }
24078 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24079 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24080 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24081 pub fn build(self) -> ValidationCacheCreateInfoEXT {
24082 self.inner
24083 }
24084}
24085#[repr(C)]
24086#[cfg_attr(feature = "debug", derive(Debug))]
24087#[derive(Copy, Clone)]
24088#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderModuleValidationCacheCreateInfoEXT.html>"]
24089pub struct ShaderModuleValidationCacheCreateInfoEXT {
24090 pub s_type: StructureType,
24091 pub p_next: *const c_void,
24092 pub validation_cache: ValidationCacheEXT,
24093}
24094impl ::std::default::Default for ShaderModuleValidationCacheCreateInfoEXT {
24095 fn default() -> Self {
24096 Self {
24097 s_type: StructureType::SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT,
24098 p_next: ::std::ptr::null(),
24099 validation_cache: ValidationCacheEXT::default(),
24100 }
24101 }
24102}
24103impl ShaderModuleValidationCacheCreateInfoEXT {
24104 pub fn builder<'a>() -> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
24105 ShaderModuleValidationCacheCreateInfoEXTBuilder {
24106 inner: Self::default(),
24107 marker: ::std::marker::PhantomData,
24108 }
24109 }
24110}
24111#[repr(transparent)]
24112pub struct ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
24113 inner: ShaderModuleValidationCacheCreateInfoEXT,
24114 marker: ::std::marker::PhantomData<&'a ()>,
24115}
24116unsafe impl ExtendsShaderModuleCreateInfo for ShaderModuleValidationCacheCreateInfoEXTBuilder<'_> {}
24117unsafe impl ExtendsShaderModuleCreateInfo for ShaderModuleValidationCacheCreateInfoEXT {}
24118impl<'a> ::std::ops::Deref for ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
24119 type Target = ShaderModuleValidationCacheCreateInfoEXT;
24120 fn deref(&self) -> &Self::Target {
24121 &self.inner
24122 }
24123}
24124impl<'a> ::std::ops::DerefMut for ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
24125 fn deref_mut(&mut self) -> &mut Self::Target {
24126 &mut self.inner
24127 }
24128}
24129impl<'a> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
24130 pub fn validation_cache(mut self, validation_cache: ValidationCacheEXT) -> Self {
24131 self.inner.validation_cache = validation_cache;
24132 self
24133 }
24134 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24135 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24136 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24137 pub fn build(self) -> ShaderModuleValidationCacheCreateInfoEXT {
24138 self.inner
24139 }
24140}
24141#[repr(C)]
24142#[cfg_attr(feature = "debug", derive(Debug))]
24143#[derive(Copy, Clone)]
24144#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMaintenance3Properties.html>"]
24145pub struct PhysicalDeviceMaintenance3Properties {
24146 pub s_type: StructureType,
24147 pub p_next: *mut c_void,
24148 pub max_per_set_descriptors: u32,
24149 pub max_memory_allocation_size: DeviceSize,
24150}
24151impl ::std::default::Default for PhysicalDeviceMaintenance3Properties {
24152 fn default() -> Self {
24153 Self {
24154 s_type: StructureType::PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES,
24155 p_next: ::std::ptr::null_mut(),
24156 max_per_set_descriptors: u32::default(),
24157 max_memory_allocation_size: DeviceSize::default(),
24158 }
24159 }
24160}
24161impl PhysicalDeviceMaintenance3Properties {
24162 pub fn builder<'a>() -> PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
24163 PhysicalDeviceMaintenance3PropertiesBuilder {
24164 inner: Self::default(),
24165 marker: ::std::marker::PhantomData,
24166 }
24167 }
24168}
24169#[repr(transparent)]
24170pub struct PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
24171 inner: PhysicalDeviceMaintenance3Properties,
24172 marker: ::std::marker::PhantomData<&'a ()>,
24173}
24174unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance3PropertiesBuilder<'_> {}
24175unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance3Properties {}
24176impl<'a> ::std::ops::Deref for PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
24177 type Target = PhysicalDeviceMaintenance3Properties;
24178 fn deref(&self) -> &Self::Target {
24179 &self.inner
24180 }
24181}
24182impl<'a> ::std::ops::DerefMut for PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
24183 fn deref_mut(&mut self) -> &mut Self::Target {
24184 &mut self.inner
24185 }
24186}
24187impl<'a> PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
24188 pub fn max_per_set_descriptors(mut self, max_per_set_descriptors: u32) -> Self {
24189 self.inner.max_per_set_descriptors = max_per_set_descriptors;
24190 self
24191 }
24192 pub fn max_memory_allocation_size(mut self, max_memory_allocation_size: DeviceSize) -> Self {
24193 self.inner.max_memory_allocation_size = max_memory_allocation_size;
24194 self
24195 }
24196 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24197 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24198 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24199 pub fn build(self) -> PhysicalDeviceMaintenance3Properties {
24200 self.inner
24201 }
24202}
24203#[repr(C)]
24204#[cfg_attr(feature = "debug", derive(Debug))]
24205#[derive(Copy, Clone)]
24206#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMaintenance4Features.html>"]
24207pub struct PhysicalDeviceMaintenance4Features {
24208 pub s_type: StructureType,
24209 pub p_next: *mut c_void,
24210 pub maintenance4: Bool32,
24211}
24212impl ::std::default::Default for PhysicalDeviceMaintenance4Features {
24213 fn default() -> Self {
24214 Self {
24215 s_type: StructureType::PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES,
24216 p_next: ::std::ptr::null_mut(),
24217 maintenance4: Bool32::default(),
24218 }
24219 }
24220}
24221impl PhysicalDeviceMaintenance4Features {
24222 pub fn builder<'a>() -> PhysicalDeviceMaintenance4FeaturesBuilder<'a> {
24223 PhysicalDeviceMaintenance4FeaturesBuilder {
24224 inner: Self::default(),
24225 marker: ::std::marker::PhantomData,
24226 }
24227 }
24228}
24229#[repr(transparent)]
24230pub struct PhysicalDeviceMaintenance4FeaturesBuilder<'a> {
24231 inner: PhysicalDeviceMaintenance4Features,
24232 marker: ::std::marker::PhantomData<&'a ()>,
24233}
24234unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMaintenance4FeaturesBuilder<'_> {}
24235unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMaintenance4Features {}
24236unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMaintenance4FeaturesBuilder<'_> {}
24237unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMaintenance4Features {}
24238impl<'a> ::std::ops::Deref for PhysicalDeviceMaintenance4FeaturesBuilder<'a> {
24239 type Target = PhysicalDeviceMaintenance4Features;
24240 fn deref(&self) -> &Self::Target {
24241 &self.inner
24242 }
24243}
24244impl<'a> ::std::ops::DerefMut for PhysicalDeviceMaintenance4FeaturesBuilder<'a> {
24245 fn deref_mut(&mut self) -> &mut Self::Target {
24246 &mut self.inner
24247 }
24248}
24249impl<'a> PhysicalDeviceMaintenance4FeaturesBuilder<'a> {
24250 pub fn maintenance4(mut self, maintenance4: bool) -> Self {
24251 self.inner.maintenance4 = maintenance4.into();
24252 self
24253 }
24254 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24255 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24256 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24257 pub fn build(self) -> PhysicalDeviceMaintenance4Features {
24258 self.inner
24259 }
24260}
24261#[repr(C)]
24262#[cfg_attr(feature = "debug", derive(Debug))]
24263#[derive(Copy, Clone)]
24264#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMaintenance4Properties.html>"]
24265pub struct PhysicalDeviceMaintenance4Properties {
24266 pub s_type: StructureType,
24267 pub p_next: *mut c_void,
24268 pub max_buffer_size: DeviceSize,
24269}
24270impl ::std::default::Default for PhysicalDeviceMaintenance4Properties {
24271 fn default() -> Self {
24272 Self {
24273 s_type: StructureType::PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES,
24274 p_next: ::std::ptr::null_mut(),
24275 max_buffer_size: DeviceSize::default(),
24276 }
24277 }
24278}
24279impl PhysicalDeviceMaintenance4Properties {
24280 pub fn builder<'a>() -> PhysicalDeviceMaintenance4PropertiesBuilder<'a> {
24281 PhysicalDeviceMaintenance4PropertiesBuilder {
24282 inner: Self::default(),
24283 marker: ::std::marker::PhantomData,
24284 }
24285 }
24286}
24287#[repr(transparent)]
24288pub struct PhysicalDeviceMaintenance4PropertiesBuilder<'a> {
24289 inner: PhysicalDeviceMaintenance4Properties,
24290 marker: ::std::marker::PhantomData<&'a ()>,
24291}
24292unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance4PropertiesBuilder<'_> {}
24293unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance4Properties {}
24294impl<'a> ::std::ops::Deref for PhysicalDeviceMaintenance4PropertiesBuilder<'a> {
24295 type Target = PhysicalDeviceMaintenance4Properties;
24296 fn deref(&self) -> &Self::Target {
24297 &self.inner
24298 }
24299}
24300impl<'a> ::std::ops::DerefMut for PhysicalDeviceMaintenance4PropertiesBuilder<'a> {
24301 fn deref_mut(&mut self) -> &mut Self::Target {
24302 &mut self.inner
24303 }
24304}
24305impl<'a> PhysicalDeviceMaintenance4PropertiesBuilder<'a> {
24306 pub fn max_buffer_size(mut self, max_buffer_size: DeviceSize) -> Self {
24307 self.inner.max_buffer_size = max_buffer_size;
24308 self
24309 }
24310 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24311 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24312 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24313 pub fn build(self) -> PhysicalDeviceMaintenance4Properties {
24314 self.inner
24315 }
24316}
24317#[repr(C)]
24318#[cfg_attr(feature = "debug", derive(Debug))]
24319#[derive(Copy, Clone)]
24320#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutSupport.html>"]
24321pub struct DescriptorSetLayoutSupport {
24322 pub s_type: StructureType,
24323 pub p_next: *mut c_void,
24324 pub supported: Bool32,
24325}
24326impl ::std::default::Default for DescriptorSetLayoutSupport {
24327 fn default() -> Self {
24328 Self {
24329 s_type: StructureType::DESCRIPTOR_SET_LAYOUT_SUPPORT,
24330 p_next: ::std::ptr::null_mut(),
24331 supported: Bool32::default(),
24332 }
24333 }
24334}
24335impl DescriptorSetLayoutSupport {
24336 pub fn builder<'a>() -> DescriptorSetLayoutSupportBuilder<'a> {
24337 DescriptorSetLayoutSupportBuilder {
24338 inner: Self::default(),
24339 marker: ::std::marker::PhantomData,
24340 }
24341 }
24342}
24343#[repr(transparent)]
24344pub struct DescriptorSetLayoutSupportBuilder<'a> {
24345 inner: DescriptorSetLayoutSupport,
24346 marker: ::std::marker::PhantomData<&'a ()>,
24347}
24348pub unsafe trait ExtendsDescriptorSetLayoutSupport {}
24349impl<'a> ::std::ops::Deref for DescriptorSetLayoutSupportBuilder<'a> {
24350 type Target = DescriptorSetLayoutSupport;
24351 fn deref(&self) -> &Self::Target {
24352 &self.inner
24353 }
24354}
24355impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutSupportBuilder<'a> {
24356 fn deref_mut(&mut self) -> &mut Self::Target {
24357 &mut self.inner
24358 }
24359}
24360impl<'a> DescriptorSetLayoutSupportBuilder<'a> {
24361 pub fn supported(mut self, supported: bool) -> Self {
24362 self.inner.supported = supported.into();
24363 self
24364 }
24365 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
24366 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
24367 #[doc = r" valid extension structs can be pushed into the chain."]
24368 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
24369 #[doc = r" chain will look like `A -> D -> B -> C`."]
24370 pub fn push_next<T: ExtendsDescriptorSetLayoutSupport>(mut self, next: &'a mut T) -> Self {
24371 unsafe {
24372 let next_ptr = <*mut T>::cast(next);
24373 let last_next = ptr_chain_iter(next).last().unwrap();
24374 (*last_next).p_next = self.inner.p_next as _;
24375 self.inner.p_next = next_ptr;
24376 }
24377 self
24378 }
24379 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24380 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24381 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24382 pub fn build(self) -> DescriptorSetLayoutSupport {
24383 self.inner
24384 }
24385}
24386#[repr(C)]
24387#[cfg_attr(feature = "debug", derive(Debug))]
24388#[derive(Copy, Clone)]
24389#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderDrawParametersFeatures.html>"]
24390pub struct PhysicalDeviceShaderDrawParametersFeatures {
24391 pub s_type: StructureType,
24392 pub p_next: *mut c_void,
24393 pub shader_draw_parameters: Bool32,
24394}
24395impl ::std::default::Default for PhysicalDeviceShaderDrawParametersFeatures {
24396 fn default() -> Self {
24397 Self {
24398 s_type: StructureType::PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
24399 p_next: ::std::ptr::null_mut(),
24400 shader_draw_parameters: Bool32::default(),
24401 }
24402 }
24403}
24404impl PhysicalDeviceShaderDrawParametersFeatures {
24405 pub fn builder<'a>() -> PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
24406 PhysicalDeviceShaderDrawParametersFeaturesBuilder {
24407 inner: Self::default(),
24408 marker: ::std::marker::PhantomData,
24409 }
24410 }
24411}
24412#[repr(transparent)]
24413pub struct PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
24414 inner: PhysicalDeviceShaderDrawParametersFeatures,
24415 marker: ::std::marker::PhantomData<&'a ()>,
24416}
24417unsafe impl ExtendsPhysicalDeviceFeatures2
24418 for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'_>
24419{
24420}
24421unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderDrawParametersFeatures {}
24422unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'_> {}
24423unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDrawParametersFeatures {}
24424impl<'a> ::std::ops::Deref for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
24425 type Target = PhysicalDeviceShaderDrawParametersFeatures;
24426 fn deref(&self) -> &Self::Target {
24427 &self.inner
24428 }
24429}
24430impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
24431 fn deref_mut(&mut self) -> &mut Self::Target {
24432 &mut self.inner
24433 }
24434}
24435impl<'a> PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
24436 pub fn shader_draw_parameters(mut self, shader_draw_parameters: bool) -> Self {
24437 self.inner.shader_draw_parameters = shader_draw_parameters.into();
24438 self
24439 }
24440 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24441 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24442 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24443 pub fn build(self) -> PhysicalDeviceShaderDrawParametersFeatures {
24444 self.inner
24445 }
24446}
24447#[repr(C)]
24448#[cfg_attr(feature = "debug", derive(Debug))]
24449#[derive(Copy, Clone)]
24450#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderFloat16Int8Features.html>"]
24451pub struct PhysicalDeviceShaderFloat16Int8Features {
24452 pub s_type: StructureType,
24453 pub p_next: *mut c_void,
24454 pub shader_float16: Bool32,
24455 pub shader_int8: Bool32,
24456}
24457impl ::std::default::Default for PhysicalDeviceShaderFloat16Int8Features {
24458 fn default() -> Self {
24459 Self {
24460 s_type: StructureType::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES,
24461 p_next: ::std::ptr::null_mut(),
24462 shader_float16: Bool32::default(),
24463 shader_int8: Bool32::default(),
24464 }
24465 }
24466}
24467impl PhysicalDeviceShaderFloat16Int8Features {
24468 pub fn builder<'a>() -> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
24469 PhysicalDeviceShaderFloat16Int8FeaturesBuilder {
24470 inner: Self::default(),
24471 marker: ::std::marker::PhantomData,
24472 }
24473 }
24474}
24475#[repr(transparent)]
24476pub struct PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
24477 inner: PhysicalDeviceShaderFloat16Int8Features,
24478 marker: ::std::marker::PhantomData<&'a ()>,
24479}
24480unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'_> {}
24481unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderFloat16Int8Features {}
24482unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'_> {}
24483unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderFloat16Int8Features {}
24484impl<'a> ::std::ops::Deref for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
24485 type Target = PhysicalDeviceShaderFloat16Int8Features;
24486 fn deref(&self) -> &Self::Target {
24487 &self.inner
24488 }
24489}
24490impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
24491 fn deref_mut(&mut self) -> &mut Self::Target {
24492 &mut self.inner
24493 }
24494}
24495impl<'a> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
24496 pub fn shader_float16(mut self, shader_float16: bool) -> Self {
24497 self.inner.shader_float16 = shader_float16.into();
24498 self
24499 }
24500 pub fn shader_int8(mut self, shader_int8: bool) -> Self {
24501 self.inner.shader_int8 = shader_int8.into();
24502 self
24503 }
24504 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24505 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24506 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24507 pub fn build(self) -> PhysicalDeviceShaderFloat16Int8Features {
24508 self.inner
24509 }
24510}
24511#[repr(C)]
24512#[cfg_attr(feature = "debug", derive(Debug))]
24513#[derive(Copy, Clone)]
24514#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFloatControlsProperties.html>"]
24515pub struct PhysicalDeviceFloatControlsProperties {
24516 pub s_type: StructureType,
24517 pub p_next: *mut c_void,
24518 pub denorm_behavior_independence: ShaderFloatControlsIndependence,
24519 pub rounding_mode_independence: ShaderFloatControlsIndependence,
24520 pub shader_signed_zero_inf_nan_preserve_float16: Bool32,
24521 pub shader_signed_zero_inf_nan_preserve_float32: Bool32,
24522 pub shader_signed_zero_inf_nan_preserve_float64: Bool32,
24523 pub shader_denorm_preserve_float16: Bool32,
24524 pub shader_denorm_preserve_float32: Bool32,
24525 pub shader_denorm_preserve_float64: Bool32,
24526 pub shader_denorm_flush_to_zero_float16: Bool32,
24527 pub shader_denorm_flush_to_zero_float32: Bool32,
24528 pub shader_denorm_flush_to_zero_float64: Bool32,
24529 pub shader_rounding_mode_rte_float16: Bool32,
24530 pub shader_rounding_mode_rte_float32: Bool32,
24531 pub shader_rounding_mode_rte_float64: Bool32,
24532 pub shader_rounding_mode_rtz_float16: Bool32,
24533 pub shader_rounding_mode_rtz_float32: Bool32,
24534 pub shader_rounding_mode_rtz_float64: Bool32,
24535}
24536impl ::std::default::Default for PhysicalDeviceFloatControlsProperties {
24537 fn default() -> Self {
24538 Self {
24539 s_type: StructureType::PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES,
24540 p_next: ::std::ptr::null_mut(),
24541 denorm_behavior_independence: ShaderFloatControlsIndependence::default(),
24542 rounding_mode_independence: ShaderFloatControlsIndependence::default(),
24543 shader_signed_zero_inf_nan_preserve_float16: Bool32::default(),
24544 shader_signed_zero_inf_nan_preserve_float32: Bool32::default(),
24545 shader_signed_zero_inf_nan_preserve_float64: Bool32::default(),
24546 shader_denorm_preserve_float16: Bool32::default(),
24547 shader_denorm_preserve_float32: Bool32::default(),
24548 shader_denorm_preserve_float64: Bool32::default(),
24549 shader_denorm_flush_to_zero_float16: Bool32::default(),
24550 shader_denorm_flush_to_zero_float32: Bool32::default(),
24551 shader_denorm_flush_to_zero_float64: Bool32::default(),
24552 shader_rounding_mode_rte_float16: Bool32::default(),
24553 shader_rounding_mode_rte_float32: Bool32::default(),
24554 shader_rounding_mode_rte_float64: Bool32::default(),
24555 shader_rounding_mode_rtz_float16: Bool32::default(),
24556 shader_rounding_mode_rtz_float32: Bool32::default(),
24557 shader_rounding_mode_rtz_float64: Bool32::default(),
24558 }
24559 }
24560}
24561impl PhysicalDeviceFloatControlsProperties {
24562 pub fn builder<'a>() -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
24563 PhysicalDeviceFloatControlsPropertiesBuilder {
24564 inner: Self::default(),
24565 marker: ::std::marker::PhantomData,
24566 }
24567 }
24568}
24569#[repr(transparent)]
24570pub struct PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
24571 inner: PhysicalDeviceFloatControlsProperties,
24572 marker: ::std::marker::PhantomData<&'a ()>,
24573}
24574unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFloatControlsPropertiesBuilder<'_> {}
24575unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFloatControlsProperties {}
24576impl<'a> ::std::ops::Deref for PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
24577 type Target = PhysicalDeviceFloatControlsProperties;
24578 fn deref(&self) -> &Self::Target {
24579 &self.inner
24580 }
24581}
24582impl<'a> ::std::ops::DerefMut for PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
24583 fn deref_mut(&mut self) -> &mut Self::Target {
24584 &mut self.inner
24585 }
24586}
24587impl<'a> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
24588 pub fn denorm_behavior_independence(
24589 mut self,
24590 denorm_behavior_independence: ShaderFloatControlsIndependence,
24591 ) -> Self {
24592 self.inner.denorm_behavior_independence = denorm_behavior_independence;
24593 self
24594 }
24595 pub fn rounding_mode_independence(
24596 mut self,
24597 rounding_mode_independence: ShaderFloatControlsIndependence,
24598 ) -> Self {
24599 self.inner.rounding_mode_independence = rounding_mode_independence;
24600 self
24601 }
24602 pub fn shader_signed_zero_inf_nan_preserve_float16(
24603 mut self,
24604 shader_signed_zero_inf_nan_preserve_float16: bool,
24605 ) -> Self {
24606 self.inner.shader_signed_zero_inf_nan_preserve_float16 =
24607 shader_signed_zero_inf_nan_preserve_float16.into();
24608 self
24609 }
24610 pub fn shader_signed_zero_inf_nan_preserve_float32(
24611 mut self,
24612 shader_signed_zero_inf_nan_preserve_float32: bool,
24613 ) -> Self {
24614 self.inner.shader_signed_zero_inf_nan_preserve_float32 =
24615 shader_signed_zero_inf_nan_preserve_float32.into();
24616 self
24617 }
24618 pub fn shader_signed_zero_inf_nan_preserve_float64(
24619 mut self,
24620 shader_signed_zero_inf_nan_preserve_float64: bool,
24621 ) -> Self {
24622 self.inner.shader_signed_zero_inf_nan_preserve_float64 =
24623 shader_signed_zero_inf_nan_preserve_float64.into();
24624 self
24625 }
24626 pub fn shader_denorm_preserve_float16(mut self, shader_denorm_preserve_float16: bool) -> Self {
24627 self.inner.shader_denorm_preserve_float16 = shader_denorm_preserve_float16.into();
24628 self
24629 }
24630 pub fn shader_denorm_preserve_float32(mut self, shader_denorm_preserve_float32: bool) -> Self {
24631 self.inner.shader_denorm_preserve_float32 = shader_denorm_preserve_float32.into();
24632 self
24633 }
24634 pub fn shader_denorm_preserve_float64(mut self, shader_denorm_preserve_float64: bool) -> Self {
24635 self.inner.shader_denorm_preserve_float64 = shader_denorm_preserve_float64.into();
24636 self
24637 }
24638 pub fn shader_denorm_flush_to_zero_float16(
24639 mut self,
24640 shader_denorm_flush_to_zero_float16: bool,
24641 ) -> Self {
24642 self.inner.shader_denorm_flush_to_zero_float16 = shader_denorm_flush_to_zero_float16.into();
24643 self
24644 }
24645 pub fn shader_denorm_flush_to_zero_float32(
24646 mut self,
24647 shader_denorm_flush_to_zero_float32: bool,
24648 ) -> Self {
24649 self.inner.shader_denorm_flush_to_zero_float32 = shader_denorm_flush_to_zero_float32.into();
24650 self
24651 }
24652 pub fn shader_denorm_flush_to_zero_float64(
24653 mut self,
24654 shader_denorm_flush_to_zero_float64: bool,
24655 ) -> Self {
24656 self.inner.shader_denorm_flush_to_zero_float64 = shader_denorm_flush_to_zero_float64.into();
24657 self
24658 }
24659 pub fn shader_rounding_mode_rte_float16(
24660 mut self,
24661 shader_rounding_mode_rte_float16: bool,
24662 ) -> Self {
24663 self.inner.shader_rounding_mode_rte_float16 = shader_rounding_mode_rte_float16.into();
24664 self
24665 }
24666 pub fn shader_rounding_mode_rte_float32(
24667 mut self,
24668 shader_rounding_mode_rte_float32: bool,
24669 ) -> Self {
24670 self.inner.shader_rounding_mode_rte_float32 = shader_rounding_mode_rte_float32.into();
24671 self
24672 }
24673 pub fn shader_rounding_mode_rte_float64(
24674 mut self,
24675 shader_rounding_mode_rte_float64: bool,
24676 ) -> Self {
24677 self.inner.shader_rounding_mode_rte_float64 = shader_rounding_mode_rte_float64.into();
24678 self
24679 }
24680 pub fn shader_rounding_mode_rtz_float16(
24681 mut self,
24682 shader_rounding_mode_rtz_float16: bool,
24683 ) -> Self {
24684 self.inner.shader_rounding_mode_rtz_float16 = shader_rounding_mode_rtz_float16.into();
24685 self
24686 }
24687 pub fn shader_rounding_mode_rtz_float32(
24688 mut self,
24689 shader_rounding_mode_rtz_float32: bool,
24690 ) -> Self {
24691 self.inner.shader_rounding_mode_rtz_float32 = shader_rounding_mode_rtz_float32.into();
24692 self
24693 }
24694 pub fn shader_rounding_mode_rtz_float64(
24695 mut self,
24696 shader_rounding_mode_rtz_float64: bool,
24697 ) -> Self {
24698 self.inner.shader_rounding_mode_rtz_float64 = shader_rounding_mode_rtz_float64.into();
24699 self
24700 }
24701 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24702 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24703 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24704 pub fn build(self) -> PhysicalDeviceFloatControlsProperties {
24705 self.inner
24706 }
24707}
24708#[repr(C)]
24709#[cfg_attr(feature = "debug", derive(Debug))]
24710#[derive(Copy, Clone)]
24711#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceHostQueryResetFeatures.html>"]
24712pub struct PhysicalDeviceHostQueryResetFeatures {
24713 pub s_type: StructureType,
24714 pub p_next: *mut c_void,
24715 pub host_query_reset: Bool32,
24716}
24717impl ::std::default::Default for PhysicalDeviceHostQueryResetFeatures {
24718 fn default() -> Self {
24719 Self {
24720 s_type: StructureType::PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES,
24721 p_next: ::std::ptr::null_mut(),
24722 host_query_reset: Bool32::default(),
24723 }
24724 }
24725}
24726impl PhysicalDeviceHostQueryResetFeatures {
24727 pub fn builder<'a>() -> PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
24728 PhysicalDeviceHostQueryResetFeaturesBuilder {
24729 inner: Self::default(),
24730 marker: ::std::marker::PhantomData,
24731 }
24732 }
24733}
24734#[repr(transparent)]
24735pub struct PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
24736 inner: PhysicalDeviceHostQueryResetFeatures,
24737 marker: ::std::marker::PhantomData<&'a ()>,
24738}
24739unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceHostQueryResetFeaturesBuilder<'_> {}
24740unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceHostQueryResetFeatures {}
24741unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceHostQueryResetFeaturesBuilder<'_> {}
24742unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceHostQueryResetFeatures {}
24743impl<'a> ::std::ops::Deref for PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
24744 type Target = PhysicalDeviceHostQueryResetFeatures;
24745 fn deref(&self) -> &Self::Target {
24746 &self.inner
24747 }
24748}
24749impl<'a> ::std::ops::DerefMut for PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
24750 fn deref_mut(&mut self) -> &mut Self::Target {
24751 &mut self.inner
24752 }
24753}
24754impl<'a> PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
24755 pub fn host_query_reset(mut self, host_query_reset: bool) -> Self {
24756 self.inner.host_query_reset = host_query_reset.into();
24757 self
24758 }
24759 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24760 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24761 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24762 pub fn build(self) -> PhysicalDeviceHostQueryResetFeatures {
24763 self.inner
24764 }
24765}
24766#[repr(C)]
24767#[cfg_attr(feature = "debug", derive(Debug))]
24768#[derive(Copy, Clone, Default)]
24769#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkNativeBufferUsage2ANDROID.html>"]
24770pub struct NativeBufferUsage2ANDROID {
24771 pub consumer: u64,
24772 pub producer: u64,
24773}
24774impl NativeBufferUsage2ANDROID {
24775 pub fn builder<'a>() -> NativeBufferUsage2ANDROIDBuilder<'a> {
24776 NativeBufferUsage2ANDROIDBuilder {
24777 inner: Self::default(),
24778 marker: ::std::marker::PhantomData,
24779 }
24780 }
24781}
24782#[repr(transparent)]
24783pub struct NativeBufferUsage2ANDROIDBuilder<'a> {
24784 inner: NativeBufferUsage2ANDROID,
24785 marker: ::std::marker::PhantomData<&'a ()>,
24786}
24787impl<'a> ::std::ops::Deref for NativeBufferUsage2ANDROIDBuilder<'a> {
24788 type Target = NativeBufferUsage2ANDROID;
24789 fn deref(&self) -> &Self::Target {
24790 &self.inner
24791 }
24792}
24793impl<'a> ::std::ops::DerefMut for NativeBufferUsage2ANDROIDBuilder<'a> {
24794 fn deref_mut(&mut self) -> &mut Self::Target {
24795 &mut self.inner
24796 }
24797}
24798impl<'a> NativeBufferUsage2ANDROIDBuilder<'a> {
24799 pub fn consumer(mut self, consumer: u64) -> Self {
24800 self.inner.consumer = consumer;
24801 self
24802 }
24803 pub fn producer(mut self, producer: u64) -> Self {
24804 self.inner.producer = producer;
24805 self
24806 }
24807 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24808 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24809 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24810 pub fn build(self) -> NativeBufferUsage2ANDROID {
24811 self.inner
24812 }
24813}
24814#[repr(C)]
24815#[cfg_attr(feature = "debug", derive(Debug))]
24816#[derive(Copy, Clone)]
24817#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkNativeBufferANDROID.html>"]
24818pub struct NativeBufferANDROID {
24819 pub s_type: StructureType,
24820 pub p_next: *const c_void,
24821 pub handle: *const c_void,
24822 pub stride: c_int,
24823 pub format: c_int,
24824 pub usage: c_int,
24825 pub usage2: NativeBufferUsage2ANDROID,
24826}
24827impl ::std::default::Default for NativeBufferANDROID {
24828 fn default() -> Self {
24829 Self {
24830 s_type: StructureType::NATIVE_BUFFER_ANDROID,
24831 p_next: ::std::ptr::null(),
24832 handle: ::std::ptr::null(),
24833 stride: c_int::default(),
24834 format: c_int::default(),
24835 usage: c_int::default(),
24836 usage2: NativeBufferUsage2ANDROID::default(),
24837 }
24838 }
24839}
24840impl NativeBufferANDROID {
24841 pub fn builder<'a>() -> NativeBufferANDROIDBuilder<'a> {
24842 NativeBufferANDROIDBuilder {
24843 inner: Self::default(),
24844 marker: ::std::marker::PhantomData,
24845 }
24846 }
24847}
24848#[repr(transparent)]
24849pub struct NativeBufferANDROIDBuilder<'a> {
24850 inner: NativeBufferANDROID,
24851 marker: ::std::marker::PhantomData<&'a ()>,
24852}
24853impl<'a> ::std::ops::Deref for NativeBufferANDROIDBuilder<'a> {
24854 type Target = NativeBufferANDROID;
24855 fn deref(&self) -> &Self::Target {
24856 &self.inner
24857 }
24858}
24859impl<'a> ::std::ops::DerefMut for NativeBufferANDROIDBuilder<'a> {
24860 fn deref_mut(&mut self) -> &mut Self::Target {
24861 &mut self.inner
24862 }
24863}
24864impl<'a> NativeBufferANDROIDBuilder<'a> {
24865 pub fn handle(mut self, handle: *const c_void) -> Self {
24866 self.inner.handle = handle;
24867 self
24868 }
24869 pub fn stride(mut self, stride: c_int) -> Self {
24870 self.inner.stride = stride;
24871 self
24872 }
24873 pub fn format(mut self, format: c_int) -> Self {
24874 self.inner.format = format;
24875 self
24876 }
24877 pub fn usage(mut self, usage: c_int) -> Self {
24878 self.inner.usage = usage;
24879 self
24880 }
24881 pub fn usage2(mut self, usage2: NativeBufferUsage2ANDROID) -> Self {
24882 self.inner.usage2 = usage2;
24883 self
24884 }
24885 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24886 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24887 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24888 pub fn build(self) -> NativeBufferANDROID {
24889 self.inner
24890 }
24891}
24892#[repr(C)]
24893#[cfg_attr(feature = "debug", derive(Debug))]
24894#[derive(Copy, Clone)]
24895#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainImageCreateInfoANDROID.html>"]
24896pub struct SwapchainImageCreateInfoANDROID {
24897 pub s_type: StructureType,
24898 pub p_next: *const c_void,
24899 pub usage: SwapchainImageUsageFlagsANDROID,
24900}
24901impl ::std::default::Default for SwapchainImageCreateInfoANDROID {
24902 fn default() -> Self {
24903 Self {
24904 s_type: StructureType::SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID,
24905 p_next: ::std::ptr::null(),
24906 usage: SwapchainImageUsageFlagsANDROID::default(),
24907 }
24908 }
24909}
24910impl SwapchainImageCreateInfoANDROID {
24911 pub fn builder<'a>() -> SwapchainImageCreateInfoANDROIDBuilder<'a> {
24912 SwapchainImageCreateInfoANDROIDBuilder {
24913 inner: Self::default(),
24914 marker: ::std::marker::PhantomData,
24915 }
24916 }
24917}
24918#[repr(transparent)]
24919pub struct SwapchainImageCreateInfoANDROIDBuilder<'a> {
24920 inner: SwapchainImageCreateInfoANDROID,
24921 marker: ::std::marker::PhantomData<&'a ()>,
24922}
24923impl<'a> ::std::ops::Deref for SwapchainImageCreateInfoANDROIDBuilder<'a> {
24924 type Target = SwapchainImageCreateInfoANDROID;
24925 fn deref(&self) -> &Self::Target {
24926 &self.inner
24927 }
24928}
24929impl<'a> ::std::ops::DerefMut for SwapchainImageCreateInfoANDROIDBuilder<'a> {
24930 fn deref_mut(&mut self) -> &mut Self::Target {
24931 &mut self.inner
24932 }
24933}
24934impl<'a> SwapchainImageCreateInfoANDROIDBuilder<'a> {
24935 pub fn usage(mut self, usage: SwapchainImageUsageFlagsANDROID) -> Self {
24936 self.inner.usage = usage;
24937 self
24938 }
24939 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24940 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24941 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24942 pub fn build(self) -> SwapchainImageCreateInfoANDROID {
24943 self.inner
24944 }
24945}
24946#[repr(C)]
24947#[cfg_attr(feature = "debug", derive(Debug))]
24948#[derive(Copy, Clone)]
24949#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePresentationPropertiesANDROID.html>"]
24950pub struct PhysicalDevicePresentationPropertiesANDROID {
24951 pub s_type: StructureType,
24952 pub p_next: *const c_void,
24953 pub shared_image: Bool32,
24954}
24955impl ::std::default::Default for PhysicalDevicePresentationPropertiesANDROID {
24956 fn default() -> Self {
24957 Self {
24958 s_type: StructureType::PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID,
24959 p_next: ::std::ptr::null(),
24960 shared_image: Bool32::default(),
24961 }
24962 }
24963}
24964impl PhysicalDevicePresentationPropertiesANDROID {
24965 pub fn builder<'a>() -> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
24966 PhysicalDevicePresentationPropertiesANDROIDBuilder {
24967 inner: Self::default(),
24968 marker: ::std::marker::PhantomData,
24969 }
24970 }
24971}
24972#[repr(transparent)]
24973pub struct PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
24974 inner: PhysicalDevicePresentationPropertiesANDROID,
24975 marker: ::std::marker::PhantomData<&'a ()>,
24976}
24977impl<'a> ::std::ops::Deref for PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
24978 type Target = PhysicalDevicePresentationPropertiesANDROID;
24979 fn deref(&self) -> &Self::Target {
24980 &self.inner
24981 }
24982}
24983impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
24984 fn deref_mut(&mut self) -> &mut Self::Target {
24985 &mut self.inner
24986 }
24987}
24988impl<'a> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
24989 pub fn shared_image(mut self, shared_image: bool) -> Self {
24990 self.inner.shared_image = shared_image.into();
24991 self
24992 }
24993 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24994 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24995 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24996 pub fn build(self) -> PhysicalDevicePresentationPropertiesANDROID {
24997 self.inner
24998 }
24999}
25000#[repr(C)]
25001#[cfg_attr(feature = "debug", derive(Debug))]
25002#[derive(Copy, Clone, Default)]
25003#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderResourceUsageAMD.html>"]
25004pub struct ShaderResourceUsageAMD {
25005 pub num_used_vgprs: u32,
25006 pub num_used_sgprs: u32,
25007 pub lds_size_per_local_work_group: u32,
25008 pub lds_usage_size_in_bytes: usize,
25009 pub scratch_mem_usage_in_bytes: usize,
25010}
25011impl ShaderResourceUsageAMD {
25012 pub fn builder<'a>() -> ShaderResourceUsageAMDBuilder<'a> {
25013 ShaderResourceUsageAMDBuilder {
25014 inner: Self::default(),
25015 marker: ::std::marker::PhantomData,
25016 }
25017 }
25018}
25019#[repr(transparent)]
25020pub struct ShaderResourceUsageAMDBuilder<'a> {
25021 inner: ShaderResourceUsageAMD,
25022 marker: ::std::marker::PhantomData<&'a ()>,
25023}
25024impl<'a> ::std::ops::Deref for ShaderResourceUsageAMDBuilder<'a> {
25025 type Target = ShaderResourceUsageAMD;
25026 fn deref(&self) -> &Self::Target {
25027 &self.inner
25028 }
25029}
25030impl<'a> ::std::ops::DerefMut for ShaderResourceUsageAMDBuilder<'a> {
25031 fn deref_mut(&mut self) -> &mut Self::Target {
25032 &mut self.inner
25033 }
25034}
25035impl<'a> ShaderResourceUsageAMDBuilder<'a> {
25036 pub fn num_used_vgprs(mut self, num_used_vgprs: u32) -> Self {
25037 self.inner.num_used_vgprs = num_used_vgprs;
25038 self
25039 }
25040 pub fn num_used_sgprs(mut self, num_used_sgprs: u32) -> Self {
25041 self.inner.num_used_sgprs = num_used_sgprs;
25042 self
25043 }
25044 pub fn lds_size_per_local_work_group(mut self, lds_size_per_local_work_group: u32) -> Self {
25045 self.inner.lds_size_per_local_work_group = lds_size_per_local_work_group;
25046 self
25047 }
25048 pub fn lds_usage_size_in_bytes(mut self, lds_usage_size_in_bytes: usize) -> Self {
25049 self.inner.lds_usage_size_in_bytes = lds_usage_size_in_bytes;
25050 self
25051 }
25052 pub fn scratch_mem_usage_in_bytes(mut self, scratch_mem_usage_in_bytes: usize) -> Self {
25053 self.inner.scratch_mem_usage_in_bytes = scratch_mem_usage_in_bytes;
25054 self
25055 }
25056 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25057 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25058 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
25059 pub fn build(self) -> ShaderResourceUsageAMD {
25060 self.inner
25061 }
25062}
25063#[repr(C)]
25064#[cfg_attr(feature = "debug", derive(Debug))]
25065#[derive(Copy, Clone)]
25066#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderStatisticsInfoAMD.html>"]
25067pub struct ShaderStatisticsInfoAMD {
25068 pub shader_stage_mask: ShaderStageFlags,
25069 pub resource_usage: ShaderResourceUsageAMD,
25070 pub num_physical_vgprs: u32,
25071 pub num_physical_sgprs: u32,
25072 pub num_available_vgprs: u32,
25073 pub num_available_sgprs: u32,
25074 pub compute_work_group_size: [u32; 3],
25075}
25076impl ::std::default::Default for ShaderStatisticsInfoAMD {
25077 fn default() -> Self {
25078 Self {
25079 shader_stage_mask: ShaderStageFlags::default(),
25080 resource_usage: ShaderResourceUsageAMD::default(),
25081 num_physical_vgprs: u32::default(),
25082 num_physical_sgprs: u32::default(),
25083 num_available_vgprs: u32::default(),
25084 num_available_sgprs: u32::default(),
25085 compute_work_group_size: unsafe { ::std::mem::zeroed() },
25086 }
25087 }
25088}
25089impl ShaderStatisticsInfoAMD {
25090 pub fn builder<'a>() -> ShaderStatisticsInfoAMDBuilder<'a> {
25091 ShaderStatisticsInfoAMDBuilder {
25092 inner: Self::default(),
25093 marker: ::std::marker::PhantomData,
25094 }
25095 }
25096}
25097#[repr(transparent)]
25098pub struct ShaderStatisticsInfoAMDBuilder<'a> {
25099 inner: ShaderStatisticsInfoAMD,
25100 marker: ::std::marker::PhantomData<&'a ()>,
25101}
25102impl<'a> ::std::ops::Deref for ShaderStatisticsInfoAMDBuilder<'a> {
25103 type Target = ShaderStatisticsInfoAMD;
25104 fn deref(&self) -> &Self::Target {
25105 &self.inner
25106 }
25107}
25108impl<'a> ::std::ops::DerefMut for ShaderStatisticsInfoAMDBuilder<'a> {
25109 fn deref_mut(&mut self) -> &mut Self::Target {
25110 &mut self.inner
25111 }
25112}
25113impl<'a> ShaderStatisticsInfoAMDBuilder<'a> {
25114 pub fn shader_stage_mask(mut self, shader_stage_mask: ShaderStageFlags) -> Self {
25115 self.inner.shader_stage_mask = shader_stage_mask;
25116 self
25117 }
25118 pub fn resource_usage(mut self, resource_usage: ShaderResourceUsageAMD) -> Self {
25119 self.inner.resource_usage = resource_usage;
25120 self
25121 }
25122 pub fn num_physical_vgprs(mut self, num_physical_vgprs: u32) -> Self {
25123 self.inner.num_physical_vgprs = num_physical_vgprs;
25124 self
25125 }
25126 pub fn num_physical_sgprs(mut self, num_physical_sgprs: u32) -> Self {
25127 self.inner.num_physical_sgprs = num_physical_sgprs;
25128 self
25129 }
25130 pub fn num_available_vgprs(mut self, num_available_vgprs: u32) -> Self {
25131 self.inner.num_available_vgprs = num_available_vgprs;
25132 self
25133 }
25134 pub fn num_available_sgprs(mut self, num_available_sgprs: u32) -> Self {
25135 self.inner.num_available_sgprs = num_available_sgprs;
25136 self
25137 }
25138 pub fn compute_work_group_size(mut self, compute_work_group_size: [u32; 3]) -> Self {
25139 self.inner.compute_work_group_size = compute_work_group_size;
25140 self
25141 }
25142 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25143 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25144 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
25145 pub fn build(self) -> ShaderStatisticsInfoAMD {
25146 self.inner
25147 }
25148}
25149#[repr(C)]
25150#[cfg_attr(feature = "debug", derive(Debug))]
25151#[derive(Copy, Clone)]
25152#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceQueueGlobalPriorityCreateInfoKHR.html>"]
25153pub struct DeviceQueueGlobalPriorityCreateInfoKHR {
25154 pub s_type: StructureType,
25155 pub p_next: *const c_void,
25156 pub global_priority: QueueGlobalPriorityKHR,
25157}
25158impl ::std::default::Default for DeviceQueueGlobalPriorityCreateInfoKHR {
25159 fn default() -> Self {
25160 Self {
25161 s_type: StructureType::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR,
25162 p_next: ::std::ptr::null(),
25163 global_priority: QueueGlobalPriorityKHR::default(),
25164 }
25165 }
25166}
25167impl DeviceQueueGlobalPriorityCreateInfoKHR {
25168 pub fn builder<'a>() -> DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> {
25169 DeviceQueueGlobalPriorityCreateInfoKHRBuilder {
25170 inner: Self::default(),
25171 marker: ::std::marker::PhantomData,
25172 }
25173 }
25174}
25175#[repr(transparent)]
25176pub struct DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> {
25177 inner: DeviceQueueGlobalPriorityCreateInfoKHR,
25178 marker: ::std::marker::PhantomData<&'a ()>,
25179}
25180unsafe impl ExtendsDeviceQueueCreateInfo for DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'_> {}
25181unsafe impl ExtendsDeviceQueueCreateInfo for DeviceQueueGlobalPriorityCreateInfoKHR {}
25182impl<'a> ::std::ops::Deref for DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> {
25183 type Target = DeviceQueueGlobalPriorityCreateInfoKHR;
25184 fn deref(&self) -> &Self::Target {
25185 &self.inner
25186 }
25187}
25188impl<'a> ::std::ops::DerefMut for DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> {
25189 fn deref_mut(&mut self) -> &mut Self::Target {
25190 &mut self.inner
25191 }
25192}
25193impl<'a> DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> {
25194 pub fn global_priority(mut self, global_priority: QueueGlobalPriorityKHR) -> Self {
25195 self.inner.global_priority = global_priority;
25196 self
25197 }
25198 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25199 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25200 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
25201 pub fn build(self) -> DeviceQueueGlobalPriorityCreateInfoKHR {
25202 self.inner
25203 }
25204}
25205#[repr(C)]
25206#[cfg_attr(feature = "debug", derive(Debug))]
25207#[derive(Copy, Clone)]
25208#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR.html>"]
25209pub struct PhysicalDeviceGlobalPriorityQueryFeaturesKHR {
25210 pub s_type: StructureType,
25211 pub p_next: *mut c_void,
25212 pub global_priority_query: Bool32,
25213}
25214impl ::std::default::Default for PhysicalDeviceGlobalPriorityQueryFeaturesKHR {
25215 fn default() -> Self {
25216 Self {
25217 s_type: StructureType::PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR,
25218 p_next: ::std::ptr::null_mut(),
25219 global_priority_query: Bool32::default(),
25220 }
25221 }
25222}
25223impl PhysicalDeviceGlobalPriorityQueryFeaturesKHR {
25224 pub fn builder<'a>() -> PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> {
25225 PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder {
25226 inner: Self::default(),
25227 marker: ::std::marker::PhantomData,
25228 }
25229 }
25230}
25231#[repr(transparent)]
25232pub struct PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> {
25233 inner: PhysicalDeviceGlobalPriorityQueryFeaturesKHR,
25234 marker: ::std::marker::PhantomData<&'a ()>,
25235}
25236unsafe impl ExtendsPhysicalDeviceFeatures2
25237 for PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'_>
25238{
25239}
25240unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceGlobalPriorityQueryFeaturesKHR {}
25241unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'_> {}
25242unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceGlobalPriorityQueryFeaturesKHR {}
25243impl<'a> ::std::ops::Deref for PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> {
25244 type Target = PhysicalDeviceGlobalPriorityQueryFeaturesKHR;
25245 fn deref(&self) -> &Self::Target {
25246 &self.inner
25247 }
25248}
25249impl<'a> ::std::ops::DerefMut for PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> {
25250 fn deref_mut(&mut self) -> &mut Self::Target {
25251 &mut self.inner
25252 }
25253}
25254impl<'a> PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> {
25255 pub fn global_priority_query(mut self, global_priority_query: bool) -> Self {
25256 self.inner.global_priority_query = global_priority_query.into();
25257 self
25258 }
25259 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25260 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25261 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
25262 pub fn build(self) -> PhysicalDeviceGlobalPriorityQueryFeaturesKHR {
25263 self.inner
25264 }
25265}
25266#[repr(C)]
25267#[cfg_attr(feature = "debug", derive(Debug))]
25268#[derive(Copy, Clone)]
25269#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyGlobalPriorityPropertiesKHR.html>"]
25270pub struct QueueFamilyGlobalPriorityPropertiesKHR {
25271 pub s_type: StructureType,
25272 pub p_next: *mut c_void,
25273 pub priority_count: u32,
25274 pub priorities: [QueueGlobalPriorityKHR; MAX_GLOBAL_PRIORITY_SIZE_KHR],
25275}
25276impl ::std::default::Default for QueueFamilyGlobalPriorityPropertiesKHR {
25277 fn default() -> Self {
25278 Self {
25279 s_type: StructureType::QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR,
25280 p_next: ::std::ptr::null_mut(),
25281 priority_count: u32::default(),
25282 priorities: unsafe { ::std::mem::zeroed() },
25283 }
25284 }
25285}
25286impl QueueFamilyGlobalPriorityPropertiesKHR {
25287 pub fn builder<'a>() -> QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> {
25288 QueueFamilyGlobalPriorityPropertiesKHRBuilder {
25289 inner: Self::default(),
25290 marker: ::std::marker::PhantomData,
25291 }
25292 }
25293}
25294#[repr(transparent)]
25295pub struct QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> {
25296 inner: QueueFamilyGlobalPriorityPropertiesKHR,
25297 marker: ::std::marker::PhantomData<&'a ()>,
25298}
25299unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyGlobalPriorityPropertiesKHRBuilder<'_> {}
25300unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyGlobalPriorityPropertiesKHR {}
25301impl<'a> ::std::ops::Deref for QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> {
25302 type Target = QueueFamilyGlobalPriorityPropertiesKHR;
25303 fn deref(&self) -> &Self::Target {
25304 &self.inner
25305 }
25306}
25307impl<'a> ::std::ops::DerefMut for QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> {
25308 fn deref_mut(&mut self) -> &mut Self::Target {
25309 &mut self.inner
25310 }
25311}
25312impl<'a> QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> {
25313 pub fn priority_count(mut self, priority_count: u32) -> Self {
25314 self.inner.priority_count = priority_count;
25315 self
25316 }
25317 pub fn priorities(
25318 mut self,
25319 priorities: [QueueGlobalPriorityKHR; MAX_GLOBAL_PRIORITY_SIZE_KHR],
25320 ) -> Self {
25321 self.inner.priorities = priorities;
25322 self
25323 }
25324 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25325 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25326 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
25327 pub fn build(self) -> QueueFamilyGlobalPriorityPropertiesKHR {
25328 self.inner
25329 }
25330}
25331#[repr(C)]
25332#[cfg_attr(feature = "debug", derive(Debug))]
25333#[derive(Copy, Clone)]
25334#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsObjectNameInfoEXT.html>"]
25335pub struct DebugUtilsObjectNameInfoEXT {
25336 pub s_type: StructureType,
25337 pub p_next: *const c_void,
25338 pub object_type: ObjectType,
25339 pub object_handle: u64,
25340 pub p_object_name: *const c_char,
25341}
25342impl ::std::default::Default for DebugUtilsObjectNameInfoEXT {
25343 fn default() -> Self {
25344 Self {
25345 s_type: StructureType::DEBUG_UTILS_OBJECT_NAME_INFO_EXT,
25346 p_next: ::std::ptr::null(),
25347 object_type: ObjectType::default(),
25348 object_handle: u64::default(),
25349 p_object_name: ::std::ptr::null(),
25350 }
25351 }
25352}
25353impl DebugUtilsObjectNameInfoEXT {
25354 pub fn builder<'a>() -> DebugUtilsObjectNameInfoEXTBuilder<'a> {
25355 DebugUtilsObjectNameInfoEXTBuilder {
25356 inner: Self::default(),
25357 marker: ::std::marker::PhantomData,
25358 }
25359 }
25360}
25361#[repr(transparent)]
25362pub struct DebugUtilsObjectNameInfoEXTBuilder<'a> {
25363 inner: DebugUtilsObjectNameInfoEXT,
25364 marker: ::std::marker::PhantomData<&'a ()>,
25365}
25366impl<'a> ::std::ops::Deref for DebugUtilsObjectNameInfoEXTBuilder<'a> {
25367 type Target = DebugUtilsObjectNameInfoEXT;
25368 fn deref(&self) -> &Self::Target {
25369 &self.inner
25370 }
25371}
25372impl<'a> ::std::ops::DerefMut for DebugUtilsObjectNameInfoEXTBuilder<'a> {
25373 fn deref_mut(&mut self) -> &mut Self::Target {
25374 &mut self.inner
25375 }
25376}
25377impl<'a> DebugUtilsObjectNameInfoEXTBuilder<'a> {
25378 pub fn object_type(mut self, object_type: ObjectType) -> Self {
25379 self.inner.object_type = object_type;
25380 self
25381 }
25382 pub fn object_handle(mut self, object_handle: u64) -> Self {
25383 self.inner.object_handle = object_handle;
25384 self
25385 }
25386 pub fn object_name(mut self, object_name: &'a ::std::ffi::CStr) -> Self {
25387 self.inner.p_object_name = object_name.as_ptr();
25388 self
25389 }
25390 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25391 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25392 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
25393 pub fn build(self) -> DebugUtilsObjectNameInfoEXT {
25394 self.inner
25395 }
25396}
25397#[repr(C)]
25398#[cfg_attr(feature = "debug", derive(Debug))]
25399#[derive(Copy, Clone)]
25400#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsObjectTagInfoEXT.html>"]
25401pub struct DebugUtilsObjectTagInfoEXT {
25402 pub s_type: StructureType,
25403 pub p_next: *const c_void,
25404 pub object_type: ObjectType,
25405 pub object_handle: u64,
25406 pub tag_name: u64,
25407 pub tag_size: usize,
25408 pub p_tag: *const c_void,
25409}
25410impl ::std::default::Default for DebugUtilsObjectTagInfoEXT {
25411 fn default() -> Self {
25412 Self {
25413 s_type: StructureType::DEBUG_UTILS_OBJECT_TAG_INFO_EXT,
25414 p_next: ::std::ptr::null(),
25415 object_type: ObjectType::default(),
25416 object_handle: u64::default(),
25417 tag_name: u64::default(),
25418 tag_size: usize::default(),
25419 p_tag: ::std::ptr::null(),
25420 }
25421 }
25422}
25423impl DebugUtilsObjectTagInfoEXT {
25424 pub fn builder<'a>() -> DebugUtilsObjectTagInfoEXTBuilder<'a> {
25425 DebugUtilsObjectTagInfoEXTBuilder {
25426 inner: Self::default(),
25427 marker: ::std::marker::PhantomData,
25428 }
25429 }
25430}
25431#[repr(transparent)]
25432pub struct DebugUtilsObjectTagInfoEXTBuilder<'a> {
25433 inner: DebugUtilsObjectTagInfoEXT,
25434 marker: ::std::marker::PhantomData<&'a ()>,
25435}
25436impl<'a> ::std::ops::Deref for DebugUtilsObjectTagInfoEXTBuilder<'a> {
25437 type Target = DebugUtilsObjectTagInfoEXT;
25438 fn deref(&self) -> &Self::Target {
25439 &self.inner
25440 }
25441}
25442impl<'a> ::std::ops::DerefMut for DebugUtilsObjectTagInfoEXTBuilder<'a> {
25443 fn deref_mut(&mut self) -> &mut Self::Target {
25444 &mut self.inner
25445 }
25446}
25447impl<'a> DebugUtilsObjectTagInfoEXTBuilder<'a> {
25448 pub fn object_type(mut self, object_type: ObjectType) -> Self {
25449 self.inner.object_type = object_type;
25450 self
25451 }
25452 pub fn object_handle(mut self, object_handle: u64) -> Self {
25453 self.inner.object_handle = object_handle;
25454 self
25455 }
25456 pub fn tag_name(mut self, tag_name: u64) -> Self {
25457 self.inner.tag_name = tag_name;
25458 self
25459 }
25460 pub fn tag(mut self, tag: &'a [u8]) -> Self {
25461 self.inner.tag_size = tag.len();
25462 self.inner.p_tag = tag.as_ptr() as *const c_void;
25463 self
25464 }
25465 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25466 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25467 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
25468 pub fn build(self) -> DebugUtilsObjectTagInfoEXT {
25469 self.inner
25470 }
25471}
25472#[repr(C)]
25473#[cfg_attr(feature = "debug", derive(Debug))]
25474#[derive(Copy, Clone)]
25475#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsLabelEXT.html>"]
25476pub struct DebugUtilsLabelEXT {
25477 pub s_type: StructureType,
25478 pub p_next: *const c_void,
25479 pub p_label_name: *const c_char,
25480 pub color: [f32; 4],
25481}
25482impl ::std::default::Default for DebugUtilsLabelEXT {
25483 fn default() -> Self {
25484 Self {
25485 s_type: StructureType::DEBUG_UTILS_LABEL_EXT,
25486 p_next: ::std::ptr::null(),
25487 p_label_name: ::std::ptr::null(),
25488 color: unsafe { ::std::mem::zeroed() },
25489 }
25490 }
25491}
25492impl DebugUtilsLabelEXT {
25493 pub fn builder<'a>() -> DebugUtilsLabelEXTBuilder<'a> {
25494 DebugUtilsLabelEXTBuilder {
25495 inner: Self::default(),
25496 marker: ::std::marker::PhantomData,
25497 }
25498 }
25499}
25500#[repr(transparent)]
25501pub struct DebugUtilsLabelEXTBuilder<'a> {
25502 inner: DebugUtilsLabelEXT,
25503 marker: ::std::marker::PhantomData<&'a ()>,
25504}
25505impl<'a> ::std::ops::Deref for DebugUtilsLabelEXTBuilder<'a> {
25506 type Target = DebugUtilsLabelEXT;
25507 fn deref(&self) -> &Self::Target {
25508 &self.inner
25509 }
25510}
25511impl<'a> ::std::ops::DerefMut for DebugUtilsLabelEXTBuilder<'a> {
25512 fn deref_mut(&mut self) -> &mut Self::Target {
25513 &mut self.inner
25514 }
25515}
25516impl<'a> DebugUtilsLabelEXTBuilder<'a> {
25517 pub fn label_name(mut self, label_name: &'a ::std::ffi::CStr) -> Self {
25518 self.inner.p_label_name = label_name.as_ptr();
25519 self
25520 }
25521 pub fn color(mut self, color: [f32; 4]) -> Self {
25522 self.inner.color = color;
25523 self
25524 }
25525 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25526 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25527 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
25528 pub fn build(self) -> DebugUtilsLabelEXT {
25529 self.inner
25530 }
25531}
25532#[repr(C)]
25533#[derive(Copy, Clone)]
25534#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessengerCreateInfoEXT.html>"]
25535pub struct DebugUtilsMessengerCreateInfoEXT {
25536 pub s_type: StructureType,
25537 pub p_next: *const c_void,
25538 pub flags: DebugUtilsMessengerCreateFlagsEXT,
25539 pub message_severity: DebugUtilsMessageSeverityFlagsEXT,
25540 pub message_type: DebugUtilsMessageTypeFlagsEXT,
25541 pub pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT,
25542 pub p_user_data: *mut c_void,
25543}
25544#[cfg(feature = "debug")]
25545impl fmt::Debug for DebugUtilsMessengerCreateInfoEXT {
25546 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
25547 fmt.debug_struct("DebugUtilsMessengerCreateInfoEXT")
25548 .field("s_type", &self.s_type)
25549 .field("p_next", &self.p_next)
25550 .field("flags", &self.flags)
25551 .field("message_severity", &self.message_severity)
25552 .field("message_type", &self.message_type)
25553 .field(
25554 "pfn_user_callback",
25555 &(self.pfn_user_callback.map(|x| x as *const ())),
25556 )
25557 .field("p_user_data", &self.p_user_data)
25558 .finish()
25559 }
25560}
25561impl ::std::default::Default for DebugUtilsMessengerCreateInfoEXT {
25562 fn default() -> Self {
25563 Self {
25564 s_type: StructureType::DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
25565 p_next: ::std::ptr::null(),
25566 flags: DebugUtilsMessengerCreateFlagsEXT::default(),
25567 message_severity: DebugUtilsMessageSeverityFlagsEXT::default(),
25568 message_type: DebugUtilsMessageTypeFlagsEXT::default(),
25569 pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT::default(),
25570 p_user_data: ::std::ptr::null_mut(),
25571 }
25572 }
25573}
25574impl DebugUtilsMessengerCreateInfoEXT {
25575 pub fn builder<'a>() -> DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
25576 DebugUtilsMessengerCreateInfoEXTBuilder {
25577 inner: Self::default(),
25578 marker: ::std::marker::PhantomData,
25579 }
25580 }
25581}
25582#[repr(transparent)]
25583pub struct DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
25584 inner: DebugUtilsMessengerCreateInfoEXT,
25585 marker: ::std::marker::PhantomData<&'a ()>,
25586}
25587unsafe impl ExtendsInstanceCreateInfo for DebugUtilsMessengerCreateInfoEXTBuilder<'_> {}
25588unsafe impl ExtendsInstanceCreateInfo for DebugUtilsMessengerCreateInfoEXT {}
25589impl<'a> ::std::ops::Deref for DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
25590 type Target = DebugUtilsMessengerCreateInfoEXT;
25591 fn deref(&self) -> &Self::Target {
25592 &self.inner
25593 }
25594}
25595impl<'a> ::std::ops::DerefMut for DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
25596 fn deref_mut(&mut self) -> &mut Self::Target {
25597 &mut self.inner
25598 }
25599}
25600impl<'a> DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
25601 pub fn flags(mut self, flags: DebugUtilsMessengerCreateFlagsEXT) -> Self {
25602 self.inner.flags = flags;
25603 self
25604 }
25605 pub fn message_severity(mut self, message_severity: DebugUtilsMessageSeverityFlagsEXT) -> Self {
25606 self.inner.message_severity = message_severity;
25607 self
25608 }
25609 pub fn message_type(mut self, message_type: DebugUtilsMessageTypeFlagsEXT) -> Self {
25610 self.inner.message_type = message_type;
25611 self
25612 }
25613 pub fn pfn_user_callback(
25614 mut self,
25615 pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT,
25616 ) -> Self {
25617 self.inner.pfn_user_callback = pfn_user_callback;
25618 self
25619 }
25620 pub fn user_data(mut self, user_data: *mut c_void) -> Self {
25621 self.inner.p_user_data = user_data;
25622 self
25623 }
25624 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25625 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25626 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
25627 pub fn build(self) -> DebugUtilsMessengerCreateInfoEXT {
25628 self.inner
25629 }
25630}
25631#[repr(C)]
25632#[cfg_attr(feature = "debug", derive(Debug))]
25633#[derive(Copy, Clone)]
25634#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessengerCallbackDataEXT.html>"]
25635pub struct DebugUtilsMessengerCallbackDataEXT {
25636 pub s_type: StructureType,
25637 pub p_next: *const c_void,
25638 pub flags: DebugUtilsMessengerCallbackDataFlagsEXT,
25639 pub p_message_id_name: *const c_char,
25640 pub message_id_number: i32,
25641 pub p_message: *const c_char,
25642 pub queue_label_count: u32,
25643 pub p_queue_labels: *const DebugUtilsLabelEXT,
25644 pub cmd_buf_label_count: u32,
25645 pub p_cmd_buf_labels: *const DebugUtilsLabelEXT,
25646 pub object_count: u32,
25647 pub p_objects: *const DebugUtilsObjectNameInfoEXT,
25648}
25649impl ::std::default::Default for DebugUtilsMessengerCallbackDataEXT {
25650 fn default() -> Self {
25651 Self {
25652 s_type: StructureType::DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT,
25653 p_next: ::std::ptr::null(),
25654 flags: DebugUtilsMessengerCallbackDataFlagsEXT::default(),
25655 p_message_id_name: ::std::ptr::null(),
25656 message_id_number: i32::default(),
25657 p_message: ::std::ptr::null(),
25658 queue_label_count: u32::default(),
25659 p_queue_labels: ::std::ptr::null(),
25660 cmd_buf_label_count: u32::default(),
25661 p_cmd_buf_labels: ::std::ptr::null(),
25662 object_count: u32::default(),
25663 p_objects: ::std::ptr::null(),
25664 }
25665 }
25666}
25667impl DebugUtilsMessengerCallbackDataEXT {
25668 pub fn builder<'a>() -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
25669 DebugUtilsMessengerCallbackDataEXTBuilder {
25670 inner: Self::default(),
25671 marker: ::std::marker::PhantomData,
25672 }
25673 }
25674}
25675#[repr(transparent)]
25676pub struct DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
25677 inner: DebugUtilsMessengerCallbackDataEXT,
25678 marker: ::std::marker::PhantomData<&'a ()>,
25679}
25680impl<'a> ::std::ops::Deref for DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
25681 type Target = DebugUtilsMessengerCallbackDataEXT;
25682 fn deref(&self) -> &Self::Target {
25683 &self.inner
25684 }
25685}
25686impl<'a> ::std::ops::DerefMut for DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
25687 fn deref_mut(&mut self) -> &mut Self::Target {
25688 &mut self.inner
25689 }
25690}
25691impl<'a> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
25692 pub fn flags(mut self, flags: DebugUtilsMessengerCallbackDataFlagsEXT) -> Self {
25693 self.inner.flags = flags;
25694 self
25695 }
25696 pub fn message_id_name(mut self, message_id_name: &'a ::std::ffi::CStr) -> Self {
25697 self.inner.p_message_id_name = message_id_name.as_ptr();
25698 self
25699 }
25700 pub fn message_id_number(mut self, message_id_number: i32) -> Self {
25701 self.inner.message_id_number = message_id_number;
25702 self
25703 }
25704 pub fn message(mut self, message: &'a ::std::ffi::CStr) -> Self {
25705 self.inner.p_message = message.as_ptr();
25706 self
25707 }
25708 pub fn queue_labels(mut self, queue_labels: &'a [DebugUtilsLabelEXT]) -> Self {
25709 self.inner.queue_label_count = queue_labels.len() as _;
25710 self.inner.p_queue_labels = queue_labels.as_ptr();
25711 self
25712 }
25713 pub fn cmd_buf_labels(mut self, cmd_buf_labels: &'a [DebugUtilsLabelEXT]) -> Self {
25714 self.inner.cmd_buf_label_count = cmd_buf_labels.len() as _;
25715 self.inner.p_cmd_buf_labels = cmd_buf_labels.as_ptr();
25716 self
25717 }
25718 pub fn objects(mut self, objects: &'a [DebugUtilsObjectNameInfoEXT]) -> Self {
25719 self.inner.object_count = objects.len() as _;
25720 self.inner.p_objects = objects.as_ptr();
25721 self
25722 }
25723 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25724 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25725 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
25726 pub fn build(self) -> DebugUtilsMessengerCallbackDataEXT {
25727 self.inner
25728 }
25729}
25730#[repr(C)]
25731#[cfg_attr(feature = "debug", derive(Debug))]
25732#[derive(Copy, Clone)]
25733#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDeviceMemoryReportFeaturesEXT.html>"]
25734pub struct PhysicalDeviceDeviceMemoryReportFeaturesEXT {
25735 pub s_type: StructureType,
25736 pub p_next: *mut c_void,
25737 pub device_memory_report: Bool32,
25738}
25739impl ::std::default::Default for PhysicalDeviceDeviceMemoryReportFeaturesEXT {
25740 fn default() -> Self {
25741 Self {
25742 s_type: StructureType::PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT,
25743 p_next: ::std::ptr::null_mut(),
25744 device_memory_report: Bool32::default(),
25745 }
25746 }
25747}
25748impl PhysicalDeviceDeviceMemoryReportFeaturesEXT {
25749 pub fn builder<'a>() -> PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> {
25750 PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder {
25751 inner: Self::default(),
25752 marker: ::std::marker::PhantomData,
25753 }
25754 }
25755}
25756#[repr(transparent)]
25757pub struct PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> {
25758 inner: PhysicalDeviceDeviceMemoryReportFeaturesEXT,
25759 marker: ::std::marker::PhantomData<&'a ()>,
25760}
25761unsafe impl ExtendsPhysicalDeviceFeatures2
25762 for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'_>
25763{
25764}
25765unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDeviceMemoryReportFeaturesEXT {}
25766unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'_> {}
25767unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceMemoryReportFeaturesEXT {}
25768impl<'a> ::std::ops::Deref for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> {
25769 type Target = PhysicalDeviceDeviceMemoryReportFeaturesEXT;
25770 fn deref(&self) -> &Self::Target {
25771 &self.inner
25772 }
25773}
25774impl<'a> ::std::ops::DerefMut for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> {
25775 fn deref_mut(&mut self) -> &mut Self::Target {
25776 &mut self.inner
25777 }
25778}
25779impl<'a> PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> {
25780 pub fn device_memory_report(mut self, device_memory_report: bool) -> Self {
25781 self.inner.device_memory_report = device_memory_report.into();
25782 self
25783 }
25784 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25785 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25786 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
25787 pub fn build(self) -> PhysicalDeviceDeviceMemoryReportFeaturesEXT {
25788 self.inner
25789 }
25790}
25791#[repr(C)]
25792#[derive(Copy, Clone)]
25793#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceDeviceMemoryReportCreateInfoEXT.html>"]
25794pub struct DeviceDeviceMemoryReportCreateInfoEXT {
25795 pub s_type: StructureType,
25796 pub p_next: *const c_void,
25797 pub flags: DeviceMemoryReportFlagsEXT,
25798 pub pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT,
25799 pub p_user_data: *mut c_void,
25800}
25801#[cfg(feature = "debug")]
25802impl fmt::Debug for DeviceDeviceMemoryReportCreateInfoEXT {
25803 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
25804 fmt.debug_struct("DeviceDeviceMemoryReportCreateInfoEXT")
25805 .field("s_type", &self.s_type)
25806 .field("p_next", &self.p_next)
25807 .field("flags", &self.flags)
25808 .field(
25809 "pfn_user_callback",
25810 &(self.pfn_user_callback.map(|x| x as *const ())),
25811 )
25812 .field("p_user_data", &self.p_user_data)
25813 .finish()
25814 }
25815}
25816impl ::std::default::Default for DeviceDeviceMemoryReportCreateInfoEXT {
25817 fn default() -> Self {
25818 Self {
25819 s_type: StructureType::DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT,
25820 p_next: ::std::ptr::null(),
25821 flags: DeviceMemoryReportFlagsEXT::default(),
25822 pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT::default(),
25823 p_user_data: ::std::ptr::null_mut(),
25824 }
25825 }
25826}
25827impl DeviceDeviceMemoryReportCreateInfoEXT {
25828 pub fn builder<'a>() -> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
25829 DeviceDeviceMemoryReportCreateInfoEXTBuilder {
25830 inner: Self::default(),
25831 marker: ::std::marker::PhantomData,
25832 }
25833 }
25834}
25835#[repr(transparent)]
25836pub struct DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
25837 inner: DeviceDeviceMemoryReportCreateInfoEXT,
25838 marker: ::std::marker::PhantomData<&'a ()>,
25839}
25840unsafe impl ExtendsDeviceCreateInfo for DeviceDeviceMemoryReportCreateInfoEXTBuilder<'_> {}
25841unsafe impl ExtendsDeviceCreateInfo for DeviceDeviceMemoryReportCreateInfoEXT {}
25842impl<'a> ::std::ops::Deref for DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
25843 type Target = DeviceDeviceMemoryReportCreateInfoEXT;
25844 fn deref(&self) -> &Self::Target {
25845 &self.inner
25846 }
25847}
25848impl<'a> ::std::ops::DerefMut for DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
25849 fn deref_mut(&mut self) -> &mut Self::Target {
25850 &mut self.inner
25851 }
25852}
25853impl<'a> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
25854 pub fn flags(mut self, flags: DeviceMemoryReportFlagsEXT) -> Self {
25855 self.inner.flags = flags;
25856 self
25857 }
25858 pub fn pfn_user_callback(
25859 mut self,
25860 pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT,
25861 ) -> Self {
25862 self.inner.pfn_user_callback = pfn_user_callback;
25863 self
25864 }
25865 pub fn user_data(mut self, user_data: *mut c_void) -> Self {
25866 self.inner.p_user_data = user_data;
25867 self
25868 }
25869 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25870 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25871 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
25872 pub fn build(self) -> DeviceDeviceMemoryReportCreateInfoEXT {
25873 self.inner
25874 }
25875}
25876#[repr(C)]
25877#[cfg_attr(feature = "debug", derive(Debug))]
25878#[derive(Copy, Clone)]
25879#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceMemoryReportCallbackDataEXT.html>"]
25880pub struct DeviceMemoryReportCallbackDataEXT {
25881 pub s_type: StructureType,
25882 pub p_next: *mut c_void,
25883 pub flags: DeviceMemoryReportFlagsEXT,
25884 pub ty: DeviceMemoryReportEventTypeEXT,
25885 pub memory_object_id: u64,
25886 pub size: DeviceSize,
25887 pub object_type: ObjectType,
25888 pub object_handle: u64,
25889 pub heap_index: u32,
25890}
25891impl ::std::default::Default for DeviceMemoryReportCallbackDataEXT {
25892 fn default() -> Self {
25893 Self {
25894 s_type: StructureType::DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT,
25895 p_next: ::std::ptr::null_mut(),
25896 flags: DeviceMemoryReportFlagsEXT::default(),
25897 ty: DeviceMemoryReportEventTypeEXT::default(),
25898 memory_object_id: u64::default(),
25899 size: DeviceSize::default(),
25900 object_type: ObjectType::default(),
25901 object_handle: u64::default(),
25902 heap_index: u32::default(),
25903 }
25904 }
25905}
25906impl DeviceMemoryReportCallbackDataEXT {
25907 pub fn builder<'a>() -> DeviceMemoryReportCallbackDataEXTBuilder<'a> {
25908 DeviceMemoryReportCallbackDataEXTBuilder {
25909 inner: Self::default(),
25910 marker: ::std::marker::PhantomData,
25911 }
25912 }
25913}
25914#[repr(transparent)]
25915pub struct DeviceMemoryReportCallbackDataEXTBuilder<'a> {
25916 inner: DeviceMemoryReportCallbackDataEXT,
25917 marker: ::std::marker::PhantomData<&'a ()>,
25918}
25919impl<'a> ::std::ops::Deref for DeviceMemoryReportCallbackDataEXTBuilder<'a> {
25920 type Target = DeviceMemoryReportCallbackDataEXT;
25921 fn deref(&self) -> &Self::Target {
25922 &self.inner
25923 }
25924}
25925impl<'a> ::std::ops::DerefMut for DeviceMemoryReportCallbackDataEXTBuilder<'a> {
25926 fn deref_mut(&mut self) -> &mut Self::Target {
25927 &mut self.inner
25928 }
25929}
25930impl<'a> DeviceMemoryReportCallbackDataEXTBuilder<'a> {
25931 pub fn flags(mut self, flags: DeviceMemoryReportFlagsEXT) -> Self {
25932 self.inner.flags = flags;
25933 self
25934 }
25935 pub fn ty(mut self, ty: DeviceMemoryReportEventTypeEXT) -> Self {
25936 self.inner.ty = ty;
25937 self
25938 }
25939 pub fn memory_object_id(mut self, memory_object_id: u64) -> Self {
25940 self.inner.memory_object_id = memory_object_id;
25941 self
25942 }
25943 pub fn size(mut self, size: DeviceSize) -> Self {
25944 self.inner.size = size;
25945 self
25946 }
25947 pub fn object_type(mut self, object_type: ObjectType) -> Self {
25948 self.inner.object_type = object_type;
25949 self
25950 }
25951 pub fn object_handle(mut self, object_handle: u64) -> Self {
25952 self.inner.object_handle = object_handle;
25953 self
25954 }
25955 pub fn heap_index(mut self, heap_index: u32) -> Self {
25956 self.inner.heap_index = heap_index;
25957 self
25958 }
25959 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25960 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25961 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
25962 pub fn build(self) -> DeviceMemoryReportCallbackDataEXT {
25963 self.inner
25964 }
25965}
25966#[repr(C)]
25967#[cfg_attr(feature = "debug", derive(Debug))]
25968#[derive(Copy, Clone)]
25969#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMemoryHostPointerInfoEXT.html>"]
25970pub struct ImportMemoryHostPointerInfoEXT {
25971 pub s_type: StructureType,
25972 pub p_next: *const c_void,
25973 pub handle_type: ExternalMemoryHandleTypeFlags,
25974 pub p_host_pointer: *mut c_void,
25975}
25976impl ::std::default::Default for ImportMemoryHostPointerInfoEXT {
25977 fn default() -> Self {
25978 Self {
25979 s_type: StructureType::IMPORT_MEMORY_HOST_POINTER_INFO_EXT,
25980 p_next: ::std::ptr::null(),
25981 handle_type: ExternalMemoryHandleTypeFlags::default(),
25982 p_host_pointer: ::std::ptr::null_mut(),
25983 }
25984 }
25985}
25986impl ImportMemoryHostPointerInfoEXT {
25987 pub fn builder<'a>() -> ImportMemoryHostPointerInfoEXTBuilder<'a> {
25988 ImportMemoryHostPointerInfoEXTBuilder {
25989 inner: Self::default(),
25990 marker: ::std::marker::PhantomData,
25991 }
25992 }
25993}
25994#[repr(transparent)]
25995pub struct ImportMemoryHostPointerInfoEXTBuilder<'a> {
25996 inner: ImportMemoryHostPointerInfoEXT,
25997 marker: ::std::marker::PhantomData<&'a ()>,
25998}
25999unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryHostPointerInfoEXTBuilder<'_> {}
26000unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryHostPointerInfoEXT {}
26001impl<'a> ::std::ops::Deref for ImportMemoryHostPointerInfoEXTBuilder<'a> {
26002 type Target = ImportMemoryHostPointerInfoEXT;
26003 fn deref(&self) -> &Self::Target {
26004 &self.inner
26005 }
26006}
26007impl<'a> ::std::ops::DerefMut for ImportMemoryHostPointerInfoEXTBuilder<'a> {
26008 fn deref_mut(&mut self) -> &mut Self::Target {
26009 &mut self.inner
26010 }
26011}
26012impl<'a> ImportMemoryHostPointerInfoEXTBuilder<'a> {
26013 pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
26014 self.inner.handle_type = handle_type;
26015 self
26016 }
26017 pub fn host_pointer(mut self, host_pointer: *mut c_void) -> Self {
26018 self.inner.p_host_pointer = host_pointer;
26019 self
26020 }
26021 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26022 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26023 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
26024 pub fn build(self) -> ImportMemoryHostPointerInfoEXT {
26025 self.inner
26026 }
26027}
26028#[repr(C)]
26029#[cfg_attr(feature = "debug", derive(Debug))]
26030#[derive(Copy, Clone)]
26031#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryHostPointerPropertiesEXT.html>"]
26032pub struct MemoryHostPointerPropertiesEXT {
26033 pub s_type: StructureType,
26034 pub p_next: *mut c_void,
26035 pub memory_type_bits: u32,
26036}
26037impl ::std::default::Default for MemoryHostPointerPropertiesEXT {
26038 fn default() -> Self {
26039 Self {
26040 s_type: StructureType::MEMORY_HOST_POINTER_PROPERTIES_EXT,
26041 p_next: ::std::ptr::null_mut(),
26042 memory_type_bits: u32::default(),
26043 }
26044 }
26045}
26046impl MemoryHostPointerPropertiesEXT {
26047 pub fn builder<'a>() -> MemoryHostPointerPropertiesEXTBuilder<'a> {
26048 MemoryHostPointerPropertiesEXTBuilder {
26049 inner: Self::default(),
26050 marker: ::std::marker::PhantomData,
26051 }
26052 }
26053}
26054#[repr(transparent)]
26055pub struct MemoryHostPointerPropertiesEXTBuilder<'a> {
26056 inner: MemoryHostPointerPropertiesEXT,
26057 marker: ::std::marker::PhantomData<&'a ()>,
26058}
26059impl<'a> ::std::ops::Deref for MemoryHostPointerPropertiesEXTBuilder<'a> {
26060 type Target = MemoryHostPointerPropertiesEXT;
26061 fn deref(&self) -> &Self::Target {
26062 &self.inner
26063 }
26064}
26065impl<'a> ::std::ops::DerefMut for MemoryHostPointerPropertiesEXTBuilder<'a> {
26066 fn deref_mut(&mut self) -> &mut Self::Target {
26067 &mut self.inner
26068 }
26069}
26070impl<'a> MemoryHostPointerPropertiesEXTBuilder<'a> {
26071 pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self {
26072 self.inner.memory_type_bits = memory_type_bits;
26073 self
26074 }
26075 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26076 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26077 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
26078 pub fn build(self) -> MemoryHostPointerPropertiesEXT {
26079 self.inner
26080 }
26081}
26082#[repr(C)]
26083#[cfg_attr(feature = "debug", derive(Debug))]
26084#[derive(Copy, Clone)]
26085#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalMemoryHostPropertiesEXT.html>"]
26086pub struct PhysicalDeviceExternalMemoryHostPropertiesEXT {
26087 pub s_type: StructureType,
26088 pub p_next: *mut c_void,
26089 pub min_imported_host_pointer_alignment: DeviceSize,
26090}
26091impl ::std::default::Default for PhysicalDeviceExternalMemoryHostPropertiesEXT {
26092 fn default() -> Self {
26093 Self {
26094 s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT,
26095 p_next: ::std::ptr::null_mut(),
26096 min_imported_host_pointer_alignment: DeviceSize::default(),
26097 }
26098 }
26099}
26100impl PhysicalDeviceExternalMemoryHostPropertiesEXT {
26101 pub fn builder<'a>() -> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
26102 PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder {
26103 inner: Self::default(),
26104 marker: ::std::marker::PhantomData,
26105 }
26106 }
26107}
26108#[repr(transparent)]
26109pub struct PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
26110 inner: PhysicalDeviceExternalMemoryHostPropertiesEXT,
26111 marker: ::std::marker::PhantomData<&'a ()>,
26112}
26113unsafe impl ExtendsPhysicalDeviceProperties2
26114 for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'_>
26115{
26116}
26117unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceExternalMemoryHostPropertiesEXT {}
26118impl<'a> ::std::ops::Deref for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
26119 type Target = PhysicalDeviceExternalMemoryHostPropertiesEXT;
26120 fn deref(&self) -> &Self::Target {
26121 &self.inner
26122 }
26123}
26124impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
26125 fn deref_mut(&mut self) -> &mut Self::Target {
26126 &mut self.inner
26127 }
26128}
26129impl<'a> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
26130 pub fn min_imported_host_pointer_alignment(
26131 mut self,
26132 min_imported_host_pointer_alignment: DeviceSize,
26133 ) -> Self {
26134 self.inner.min_imported_host_pointer_alignment = min_imported_host_pointer_alignment;
26135 self
26136 }
26137 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26138 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26139 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
26140 pub fn build(self) -> PhysicalDeviceExternalMemoryHostPropertiesEXT {
26141 self.inner
26142 }
26143}
26144#[repr(C)]
26145#[cfg_attr(feature = "debug", derive(Debug))]
26146#[derive(Copy, Clone)]
26147#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceConservativeRasterizationPropertiesEXT.html>"]
26148pub struct PhysicalDeviceConservativeRasterizationPropertiesEXT {
26149 pub s_type: StructureType,
26150 pub p_next: *mut c_void,
26151 pub primitive_overestimation_size: f32,
26152 pub max_extra_primitive_overestimation_size: f32,
26153 pub extra_primitive_overestimation_size_granularity: f32,
26154 pub primitive_underestimation: Bool32,
26155 pub conservative_point_and_line_rasterization: Bool32,
26156 pub degenerate_triangles_rasterized: Bool32,
26157 pub degenerate_lines_rasterized: Bool32,
26158 pub fully_covered_fragment_shader_input_variable: Bool32,
26159 pub conservative_rasterization_post_depth_coverage: Bool32,
26160}
26161impl ::std::default::Default for PhysicalDeviceConservativeRasterizationPropertiesEXT {
26162 fn default() -> Self {
26163 Self {
26164 s_type: StructureType::PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT,
26165 p_next: ::std::ptr::null_mut(),
26166 primitive_overestimation_size: f32::default(),
26167 max_extra_primitive_overestimation_size: f32::default(),
26168 extra_primitive_overestimation_size_granularity: f32::default(),
26169 primitive_underestimation: Bool32::default(),
26170 conservative_point_and_line_rasterization: Bool32::default(),
26171 degenerate_triangles_rasterized: Bool32::default(),
26172 degenerate_lines_rasterized: Bool32::default(),
26173 fully_covered_fragment_shader_input_variable: Bool32::default(),
26174 conservative_rasterization_post_depth_coverage: Bool32::default(),
26175 }
26176 }
26177}
26178impl PhysicalDeviceConservativeRasterizationPropertiesEXT {
26179 pub fn builder<'a>() -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
26180 PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder {
26181 inner: Self::default(),
26182 marker: ::std::marker::PhantomData,
26183 }
26184 }
26185}
26186#[repr(transparent)]
26187pub struct PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
26188 inner: PhysicalDeviceConservativeRasterizationPropertiesEXT,
26189 marker: ::std::marker::PhantomData<&'a ()>,
26190}
26191unsafe impl ExtendsPhysicalDeviceProperties2
26192 for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'_>
26193{
26194}
26195unsafe impl ExtendsPhysicalDeviceProperties2
26196 for PhysicalDeviceConservativeRasterizationPropertiesEXT
26197{
26198}
26199impl<'a> ::std::ops::Deref for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
26200 type Target = PhysicalDeviceConservativeRasterizationPropertiesEXT;
26201 fn deref(&self) -> &Self::Target {
26202 &self.inner
26203 }
26204}
26205impl<'a> ::std::ops::DerefMut for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
26206 fn deref_mut(&mut self) -> &mut Self::Target {
26207 &mut self.inner
26208 }
26209}
26210impl<'a> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
26211 pub fn primitive_overestimation_size(mut self, primitive_overestimation_size: f32) -> Self {
26212 self.inner.primitive_overestimation_size = primitive_overestimation_size;
26213 self
26214 }
26215 pub fn max_extra_primitive_overestimation_size(
26216 mut self,
26217 max_extra_primitive_overestimation_size: f32,
26218 ) -> Self {
26219 self.inner.max_extra_primitive_overestimation_size =
26220 max_extra_primitive_overestimation_size;
26221 self
26222 }
26223 pub fn extra_primitive_overestimation_size_granularity(
26224 mut self,
26225 extra_primitive_overestimation_size_granularity: f32,
26226 ) -> Self {
26227 self.inner.extra_primitive_overestimation_size_granularity =
26228 extra_primitive_overestimation_size_granularity;
26229 self
26230 }
26231 pub fn primitive_underestimation(mut self, primitive_underestimation: bool) -> Self {
26232 self.inner.primitive_underestimation = primitive_underestimation.into();
26233 self
26234 }
26235 pub fn conservative_point_and_line_rasterization(
26236 mut self,
26237 conservative_point_and_line_rasterization: bool,
26238 ) -> Self {
26239 self.inner.conservative_point_and_line_rasterization =
26240 conservative_point_and_line_rasterization.into();
26241 self
26242 }
26243 pub fn degenerate_triangles_rasterized(
26244 mut self,
26245 degenerate_triangles_rasterized: bool,
26246 ) -> Self {
26247 self.inner.degenerate_triangles_rasterized = degenerate_triangles_rasterized.into();
26248 self
26249 }
26250 pub fn degenerate_lines_rasterized(mut self, degenerate_lines_rasterized: bool) -> Self {
26251 self.inner.degenerate_lines_rasterized = degenerate_lines_rasterized.into();
26252 self
26253 }
26254 pub fn fully_covered_fragment_shader_input_variable(
26255 mut self,
26256 fully_covered_fragment_shader_input_variable: bool,
26257 ) -> Self {
26258 self.inner.fully_covered_fragment_shader_input_variable =
26259 fully_covered_fragment_shader_input_variable.into();
26260 self
26261 }
26262 pub fn conservative_rasterization_post_depth_coverage(
26263 mut self,
26264 conservative_rasterization_post_depth_coverage: bool,
26265 ) -> Self {
26266 self.inner.conservative_rasterization_post_depth_coverage =
26267 conservative_rasterization_post_depth_coverage.into();
26268 self
26269 }
26270 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26271 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26272 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
26273 pub fn build(self) -> PhysicalDeviceConservativeRasterizationPropertiesEXT {
26274 self.inner
26275 }
26276}
26277#[repr(C)]
26278#[cfg_attr(feature = "debug", derive(Debug))]
26279#[derive(Copy, Clone)]
26280#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCalibratedTimestampInfoEXT.html>"]
26281pub struct CalibratedTimestampInfoEXT {
26282 pub s_type: StructureType,
26283 pub p_next: *const c_void,
26284 pub time_domain: TimeDomainEXT,
26285}
26286impl ::std::default::Default for CalibratedTimestampInfoEXT {
26287 fn default() -> Self {
26288 Self {
26289 s_type: StructureType::CALIBRATED_TIMESTAMP_INFO_EXT,
26290 p_next: ::std::ptr::null(),
26291 time_domain: TimeDomainEXT::default(),
26292 }
26293 }
26294}
26295impl CalibratedTimestampInfoEXT {
26296 pub fn builder<'a>() -> CalibratedTimestampInfoEXTBuilder<'a> {
26297 CalibratedTimestampInfoEXTBuilder {
26298 inner: Self::default(),
26299 marker: ::std::marker::PhantomData,
26300 }
26301 }
26302}
26303#[repr(transparent)]
26304pub struct CalibratedTimestampInfoEXTBuilder<'a> {
26305 inner: CalibratedTimestampInfoEXT,
26306 marker: ::std::marker::PhantomData<&'a ()>,
26307}
26308impl<'a> ::std::ops::Deref for CalibratedTimestampInfoEXTBuilder<'a> {
26309 type Target = CalibratedTimestampInfoEXT;
26310 fn deref(&self) -> &Self::Target {
26311 &self.inner
26312 }
26313}
26314impl<'a> ::std::ops::DerefMut for CalibratedTimestampInfoEXTBuilder<'a> {
26315 fn deref_mut(&mut self) -> &mut Self::Target {
26316 &mut self.inner
26317 }
26318}
26319impl<'a> CalibratedTimestampInfoEXTBuilder<'a> {
26320 pub fn time_domain(mut self, time_domain: TimeDomainEXT) -> Self {
26321 self.inner.time_domain = time_domain;
26322 self
26323 }
26324 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26325 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26326 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
26327 pub fn build(self) -> CalibratedTimestampInfoEXT {
26328 self.inner
26329 }
26330}
26331#[repr(C)]
26332#[cfg_attr(feature = "debug", derive(Debug))]
26333#[derive(Copy, Clone)]
26334#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderCorePropertiesAMD.html>"]
26335pub struct PhysicalDeviceShaderCorePropertiesAMD {
26336 pub s_type: StructureType,
26337 pub p_next: *mut c_void,
26338 pub shader_engine_count: u32,
26339 pub shader_arrays_per_engine_count: u32,
26340 pub compute_units_per_shader_array: u32,
26341 pub simd_per_compute_unit: u32,
26342 pub wavefronts_per_simd: u32,
26343 pub wavefront_size: u32,
26344 pub sgprs_per_simd: u32,
26345 pub min_sgpr_allocation: u32,
26346 pub max_sgpr_allocation: u32,
26347 pub sgpr_allocation_granularity: u32,
26348 pub vgprs_per_simd: u32,
26349 pub min_vgpr_allocation: u32,
26350 pub max_vgpr_allocation: u32,
26351 pub vgpr_allocation_granularity: u32,
26352}
26353impl ::std::default::Default for PhysicalDeviceShaderCorePropertiesAMD {
26354 fn default() -> Self {
26355 Self {
26356 s_type: StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD,
26357 p_next: ::std::ptr::null_mut(),
26358 shader_engine_count: u32::default(),
26359 shader_arrays_per_engine_count: u32::default(),
26360 compute_units_per_shader_array: u32::default(),
26361 simd_per_compute_unit: u32::default(),
26362 wavefronts_per_simd: u32::default(),
26363 wavefront_size: u32::default(),
26364 sgprs_per_simd: u32::default(),
26365 min_sgpr_allocation: u32::default(),
26366 max_sgpr_allocation: u32::default(),
26367 sgpr_allocation_granularity: u32::default(),
26368 vgprs_per_simd: u32::default(),
26369 min_vgpr_allocation: u32::default(),
26370 max_vgpr_allocation: u32::default(),
26371 vgpr_allocation_granularity: u32::default(),
26372 }
26373 }
26374}
26375impl PhysicalDeviceShaderCorePropertiesAMD {
26376 pub fn builder<'a>() -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
26377 PhysicalDeviceShaderCorePropertiesAMDBuilder {
26378 inner: Self::default(),
26379 marker: ::std::marker::PhantomData,
26380 }
26381 }
26382}
26383#[repr(transparent)]
26384pub struct PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
26385 inner: PhysicalDeviceShaderCorePropertiesAMD,
26386 marker: ::std::marker::PhantomData<&'a ()>,
26387}
26388unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesAMDBuilder<'_> {}
26389unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesAMD {}
26390impl<'a> ::std::ops::Deref for PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
26391 type Target = PhysicalDeviceShaderCorePropertiesAMD;
26392 fn deref(&self) -> &Self::Target {
26393 &self.inner
26394 }
26395}
26396impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
26397 fn deref_mut(&mut self) -> &mut Self::Target {
26398 &mut self.inner
26399 }
26400}
26401impl<'a> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
26402 pub fn shader_engine_count(mut self, shader_engine_count: u32) -> Self {
26403 self.inner.shader_engine_count = shader_engine_count;
26404 self
26405 }
26406 pub fn shader_arrays_per_engine_count(mut self, shader_arrays_per_engine_count: u32) -> Self {
26407 self.inner.shader_arrays_per_engine_count = shader_arrays_per_engine_count;
26408 self
26409 }
26410 pub fn compute_units_per_shader_array(mut self, compute_units_per_shader_array: u32) -> Self {
26411 self.inner.compute_units_per_shader_array = compute_units_per_shader_array;
26412 self
26413 }
26414 pub fn simd_per_compute_unit(mut self, simd_per_compute_unit: u32) -> Self {
26415 self.inner.simd_per_compute_unit = simd_per_compute_unit;
26416 self
26417 }
26418 pub fn wavefronts_per_simd(mut self, wavefronts_per_simd: u32) -> Self {
26419 self.inner.wavefronts_per_simd = wavefronts_per_simd;
26420 self
26421 }
26422 pub fn wavefront_size(mut self, wavefront_size: u32) -> Self {
26423 self.inner.wavefront_size = wavefront_size;
26424 self
26425 }
26426 pub fn sgprs_per_simd(mut self, sgprs_per_simd: u32) -> Self {
26427 self.inner.sgprs_per_simd = sgprs_per_simd;
26428 self
26429 }
26430 pub fn min_sgpr_allocation(mut self, min_sgpr_allocation: u32) -> Self {
26431 self.inner.min_sgpr_allocation = min_sgpr_allocation;
26432 self
26433 }
26434 pub fn max_sgpr_allocation(mut self, max_sgpr_allocation: u32) -> Self {
26435 self.inner.max_sgpr_allocation = max_sgpr_allocation;
26436 self
26437 }
26438 pub fn sgpr_allocation_granularity(mut self, sgpr_allocation_granularity: u32) -> Self {
26439 self.inner.sgpr_allocation_granularity = sgpr_allocation_granularity;
26440 self
26441 }
26442 pub fn vgprs_per_simd(mut self, vgprs_per_simd: u32) -> Self {
26443 self.inner.vgprs_per_simd = vgprs_per_simd;
26444 self
26445 }
26446 pub fn min_vgpr_allocation(mut self, min_vgpr_allocation: u32) -> Self {
26447 self.inner.min_vgpr_allocation = min_vgpr_allocation;
26448 self
26449 }
26450 pub fn max_vgpr_allocation(mut self, max_vgpr_allocation: u32) -> Self {
26451 self.inner.max_vgpr_allocation = max_vgpr_allocation;
26452 self
26453 }
26454 pub fn vgpr_allocation_granularity(mut self, vgpr_allocation_granularity: u32) -> Self {
26455 self.inner.vgpr_allocation_granularity = vgpr_allocation_granularity;
26456 self
26457 }
26458 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26459 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26460 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
26461 pub fn build(self) -> PhysicalDeviceShaderCorePropertiesAMD {
26462 self.inner
26463 }
26464}
26465#[repr(C)]
26466#[cfg_attr(feature = "debug", derive(Debug))]
26467#[derive(Copy, Clone)]
26468#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderCoreProperties2AMD.html>"]
26469pub struct PhysicalDeviceShaderCoreProperties2AMD {
26470 pub s_type: StructureType,
26471 pub p_next: *mut c_void,
26472 pub shader_core_features: ShaderCorePropertiesFlagsAMD,
26473 pub active_compute_unit_count: u32,
26474}
26475impl ::std::default::Default for PhysicalDeviceShaderCoreProperties2AMD {
26476 fn default() -> Self {
26477 Self {
26478 s_type: StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD,
26479 p_next: ::std::ptr::null_mut(),
26480 shader_core_features: ShaderCorePropertiesFlagsAMD::default(),
26481 active_compute_unit_count: u32::default(),
26482 }
26483 }
26484}
26485impl PhysicalDeviceShaderCoreProperties2AMD {
26486 pub fn builder<'a>() -> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
26487 PhysicalDeviceShaderCoreProperties2AMDBuilder {
26488 inner: Self::default(),
26489 marker: ::std::marker::PhantomData,
26490 }
26491 }
26492}
26493#[repr(transparent)]
26494pub struct PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
26495 inner: PhysicalDeviceShaderCoreProperties2AMD,
26496 marker: ::std::marker::PhantomData<&'a ()>,
26497}
26498unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCoreProperties2AMDBuilder<'_> {}
26499unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCoreProperties2AMD {}
26500impl<'a> ::std::ops::Deref for PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
26501 type Target = PhysicalDeviceShaderCoreProperties2AMD;
26502 fn deref(&self) -> &Self::Target {
26503 &self.inner
26504 }
26505}
26506impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
26507 fn deref_mut(&mut self) -> &mut Self::Target {
26508 &mut self.inner
26509 }
26510}
26511impl<'a> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
26512 pub fn shader_core_features(
26513 mut self,
26514 shader_core_features: ShaderCorePropertiesFlagsAMD,
26515 ) -> Self {
26516 self.inner.shader_core_features = shader_core_features;
26517 self
26518 }
26519 pub fn active_compute_unit_count(mut self, active_compute_unit_count: u32) -> Self {
26520 self.inner.active_compute_unit_count = active_compute_unit_count;
26521 self
26522 }
26523 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26524 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26525 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
26526 pub fn build(self) -> PhysicalDeviceShaderCoreProperties2AMD {
26527 self.inner
26528 }
26529}
26530#[repr(C)]
26531#[cfg_attr(feature = "debug", derive(Debug))]
26532#[derive(Copy, Clone)]
26533#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationConservativeStateCreateInfoEXT.html>"]
26534pub struct PipelineRasterizationConservativeStateCreateInfoEXT {
26535 pub s_type: StructureType,
26536 pub p_next: *const c_void,
26537 pub flags: PipelineRasterizationConservativeStateCreateFlagsEXT,
26538 pub conservative_rasterization_mode: ConservativeRasterizationModeEXT,
26539 pub extra_primitive_overestimation_size: f32,
26540}
26541impl ::std::default::Default for PipelineRasterizationConservativeStateCreateInfoEXT {
26542 fn default() -> Self {
26543 Self {
26544 s_type: StructureType::PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT,
26545 p_next: ::std::ptr::null(),
26546 flags: PipelineRasterizationConservativeStateCreateFlagsEXT::default(),
26547 conservative_rasterization_mode: ConservativeRasterizationModeEXT::default(),
26548 extra_primitive_overestimation_size: f32::default(),
26549 }
26550 }
26551}
26552impl PipelineRasterizationConservativeStateCreateInfoEXT {
26553 pub fn builder<'a>() -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
26554 PipelineRasterizationConservativeStateCreateInfoEXTBuilder {
26555 inner: Self::default(),
26556 marker: ::std::marker::PhantomData,
26557 }
26558 }
26559}
26560#[repr(transparent)]
26561pub struct PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
26562 inner: PipelineRasterizationConservativeStateCreateInfoEXT,
26563 marker: ::std::marker::PhantomData<&'a ()>,
26564}
26565unsafe impl ExtendsPipelineRasterizationStateCreateInfo
26566 for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'_>
26567{
26568}
26569unsafe impl ExtendsPipelineRasterizationStateCreateInfo
26570 for PipelineRasterizationConservativeStateCreateInfoEXT
26571{
26572}
26573impl<'a> ::std::ops::Deref for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
26574 type Target = PipelineRasterizationConservativeStateCreateInfoEXT;
26575 fn deref(&self) -> &Self::Target {
26576 &self.inner
26577 }
26578}
26579impl<'a> ::std::ops::DerefMut for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
26580 fn deref_mut(&mut self) -> &mut Self::Target {
26581 &mut self.inner
26582 }
26583}
26584impl<'a> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
26585 pub fn flags(mut self, flags: PipelineRasterizationConservativeStateCreateFlagsEXT) -> Self {
26586 self.inner.flags = flags;
26587 self
26588 }
26589 pub fn conservative_rasterization_mode(
26590 mut self,
26591 conservative_rasterization_mode: ConservativeRasterizationModeEXT,
26592 ) -> Self {
26593 self.inner.conservative_rasterization_mode = conservative_rasterization_mode;
26594 self
26595 }
26596 pub fn extra_primitive_overestimation_size(
26597 mut self,
26598 extra_primitive_overestimation_size: f32,
26599 ) -> Self {
26600 self.inner.extra_primitive_overestimation_size = extra_primitive_overestimation_size;
26601 self
26602 }
26603 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26604 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26605 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
26606 pub fn build(self) -> PipelineRasterizationConservativeStateCreateInfoEXT {
26607 self.inner
26608 }
26609}
26610#[repr(C)]
26611#[cfg_attr(feature = "debug", derive(Debug))]
26612#[derive(Copy, Clone)]
26613#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDescriptorIndexingFeatures.html>"]
26614pub struct PhysicalDeviceDescriptorIndexingFeatures {
26615 pub s_type: StructureType,
26616 pub p_next: *mut c_void,
26617 pub shader_input_attachment_array_dynamic_indexing: Bool32,
26618 pub shader_uniform_texel_buffer_array_dynamic_indexing: Bool32,
26619 pub shader_storage_texel_buffer_array_dynamic_indexing: Bool32,
26620 pub shader_uniform_buffer_array_non_uniform_indexing: Bool32,
26621 pub shader_sampled_image_array_non_uniform_indexing: Bool32,
26622 pub shader_storage_buffer_array_non_uniform_indexing: Bool32,
26623 pub shader_storage_image_array_non_uniform_indexing: Bool32,
26624 pub shader_input_attachment_array_non_uniform_indexing: Bool32,
26625 pub shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32,
26626 pub shader_storage_texel_buffer_array_non_uniform_indexing: Bool32,
26627 pub descriptor_binding_uniform_buffer_update_after_bind: Bool32,
26628 pub descriptor_binding_sampled_image_update_after_bind: Bool32,
26629 pub descriptor_binding_storage_image_update_after_bind: Bool32,
26630 pub descriptor_binding_storage_buffer_update_after_bind: Bool32,
26631 pub descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32,
26632 pub descriptor_binding_storage_texel_buffer_update_after_bind: Bool32,
26633 pub descriptor_binding_update_unused_while_pending: Bool32,
26634 pub descriptor_binding_partially_bound: Bool32,
26635 pub descriptor_binding_variable_descriptor_count: Bool32,
26636 pub runtime_descriptor_array: Bool32,
26637}
26638impl ::std::default::Default for PhysicalDeviceDescriptorIndexingFeatures {
26639 fn default() -> Self {
26640 Self {
26641 s_type: StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES,
26642 p_next: ::std::ptr::null_mut(),
26643 shader_input_attachment_array_dynamic_indexing: Bool32::default(),
26644 shader_uniform_texel_buffer_array_dynamic_indexing: Bool32::default(),
26645 shader_storage_texel_buffer_array_dynamic_indexing: Bool32::default(),
26646 shader_uniform_buffer_array_non_uniform_indexing: Bool32::default(),
26647 shader_sampled_image_array_non_uniform_indexing: Bool32::default(),
26648 shader_storage_buffer_array_non_uniform_indexing: Bool32::default(),
26649 shader_storage_image_array_non_uniform_indexing: Bool32::default(),
26650 shader_input_attachment_array_non_uniform_indexing: Bool32::default(),
26651 shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32::default(),
26652 shader_storage_texel_buffer_array_non_uniform_indexing: Bool32::default(),
26653 descriptor_binding_uniform_buffer_update_after_bind: Bool32::default(),
26654 descriptor_binding_sampled_image_update_after_bind: Bool32::default(),
26655 descriptor_binding_storage_image_update_after_bind: Bool32::default(),
26656 descriptor_binding_storage_buffer_update_after_bind: Bool32::default(),
26657 descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32::default(),
26658 descriptor_binding_storage_texel_buffer_update_after_bind: Bool32::default(),
26659 descriptor_binding_update_unused_while_pending: Bool32::default(),
26660 descriptor_binding_partially_bound: Bool32::default(),
26661 descriptor_binding_variable_descriptor_count: Bool32::default(),
26662 runtime_descriptor_array: Bool32::default(),
26663 }
26664 }
26665}
26666impl PhysicalDeviceDescriptorIndexingFeatures {
26667 pub fn builder<'a>() -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
26668 PhysicalDeviceDescriptorIndexingFeaturesBuilder {
26669 inner: Self::default(),
26670 marker: ::std::marker::PhantomData,
26671 }
26672 }
26673}
26674#[repr(transparent)]
26675pub struct PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
26676 inner: PhysicalDeviceDescriptorIndexingFeatures,
26677 marker: ::std::marker::PhantomData<&'a ()>,
26678}
26679unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'_> {}
26680unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorIndexingFeatures {}
26681unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'_> {}
26682unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorIndexingFeatures {}
26683impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
26684 type Target = PhysicalDeviceDescriptorIndexingFeatures;
26685 fn deref(&self) -> &Self::Target {
26686 &self.inner
26687 }
26688}
26689impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
26690 fn deref_mut(&mut self) -> &mut Self::Target {
26691 &mut self.inner
26692 }
26693}
26694impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
26695 pub fn shader_input_attachment_array_dynamic_indexing(
26696 mut self,
26697 shader_input_attachment_array_dynamic_indexing: bool,
26698 ) -> Self {
26699 self.inner.shader_input_attachment_array_dynamic_indexing =
26700 shader_input_attachment_array_dynamic_indexing.into();
26701 self
26702 }
26703 pub fn shader_uniform_texel_buffer_array_dynamic_indexing(
26704 mut self,
26705 shader_uniform_texel_buffer_array_dynamic_indexing: bool,
26706 ) -> Self {
26707 self.inner
26708 .shader_uniform_texel_buffer_array_dynamic_indexing =
26709 shader_uniform_texel_buffer_array_dynamic_indexing.into();
26710 self
26711 }
26712 pub fn shader_storage_texel_buffer_array_dynamic_indexing(
26713 mut self,
26714 shader_storage_texel_buffer_array_dynamic_indexing: bool,
26715 ) -> Self {
26716 self.inner
26717 .shader_storage_texel_buffer_array_dynamic_indexing =
26718 shader_storage_texel_buffer_array_dynamic_indexing.into();
26719 self
26720 }
26721 pub fn shader_uniform_buffer_array_non_uniform_indexing(
26722 mut self,
26723 shader_uniform_buffer_array_non_uniform_indexing: bool,
26724 ) -> Self {
26725 self.inner.shader_uniform_buffer_array_non_uniform_indexing =
26726 shader_uniform_buffer_array_non_uniform_indexing.into();
26727 self
26728 }
26729 pub fn shader_sampled_image_array_non_uniform_indexing(
26730 mut self,
26731 shader_sampled_image_array_non_uniform_indexing: bool,
26732 ) -> Self {
26733 self.inner.shader_sampled_image_array_non_uniform_indexing =
26734 shader_sampled_image_array_non_uniform_indexing.into();
26735 self
26736 }
26737 pub fn shader_storage_buffer_array_non_uniform_indexing(
26738 mut self,
26739 shader_storage_buffer_array_non_uniform_indexing: bool,
26740 ) -> Self {
26741 self.inner.shader_storage_buffer_array_non_uniform_indexing =
26742 shader_storage_buffer_array_non_uniform_indexing.into();
26743 self
26744 }
26745 pub fn shader_storage_image_array_non_uniform_indexing(
26746 mut self,
26747 shader_storage_image_array_non_uniform_indexing: bool,
26748 ) -> Self {
26749 self.inner.shader_storage_image_array_non_uniform_indexing =
26750 shader_storage_image_array_non_uniform_indexing.into();
26751 self
26752 }
26753 pub fn shader_input_attachment_array_non_uniform_indexing(
26754 mut self,
26755 shader_input_attachment_array_non_uniform_indexing: bool,
26756 ) -> Self {
26757 self.inner
26758 .shader_input_attachment_array_non_uniform_indexing =
26759 shader_input_attachment_array_non_uniform_indexing.into();
26760 self
26761 }
26762 pub fn shader_uniform_texel_buffer_array_non_uniform_indexing(
26763 mut self,
26764 shader_uniform_texel_buffer_array_non_uniform_indexing: bool,
26765 ) -> Self {
26766 self.inner
26767 .shader_uniform_texel_buffer_array_non_uniform_indexing =
26768 shader_uniform_texel_buffer_array_non_uniform_indexing.into();
26769 self
26770 }
26771 pub fn shader_storage_texel_buffer_array_non_uniform_indexing(
26772 mut self,
26773 shader_storage_texel_buffer_array_non_uniform_indexing: bool,
26774 ) -> Self {
26775 self.inner
26776 .shader_storage_texel_buffer_array_non_uniform_indexing =
26777 shader_storage_texel_buffer_array_non_uniform_indexing.into();
26778 self
26779 }
26780 pub fn descriptor_binding_uniform_buffer_update_after_bind(
26781 mut self,
26782 descriptor_binding_uniform_buffer_update_after_bind: bool,
26783 ) -> Self {
26784 self.inner
26785 .descriptor_binding_uniform_buffer_update_after_bind =
26786 descriptor_binding_uniform_buffer_update_after_bind.into();
26787 self
26788 }
26789 pub fn descriptor_binding_sampled_image_update_after_bind(
26790 mut self,
26791 descriptor_binding_sampled_image_update_after_bind: bool,
26792 ) -> Self {
26793 self.inner
26794 .descriptor_binding_sampled_image_update_after_bind =
26795 descriptor_binding_sampled_image_update_after_bind.into();
26796 self
26797 }
26798 pub fn descriptor_binding_storage_image_update_after_bind(
26799 mut self,
26800 descriptor_binding_storage_image_update_after_bind: bool,
26801 ) -> Self {
26802 self.inner
26803 .descriptor_binding_storage_image_update_after_bind =
26804 descriptor_binding_storage_image_update_after_bind.into();
26805 self
26806 }
26807 pub fn descriptor_binding_storage_buffer_update_after_bind(
26808 mut self,
26809 descriptor_binding_storage_buffer_update_after_bind: bool,
26810 ) -> Self {
26811 self.inner
26812 .descriptor_binding_storage_buffer_update_after_bind =
26813 descriptor_binding_storage_buffer_update_after_bind.into();
26814 self
26815 }
26816 pub fn descriptor_binding_uniform_texel_buffer_update_after_bind(
26817 mut self,
26818 descriptor_binding_uniform_texel_buffer_update_after_bind: bool,
26819 ) -> Self {
26820 self.inner
26821 .descriptor_binding_uniform_texel_buffer_update_after_bind =
26822 descriptor_binding_uniform_texel_buffer_update_after_bind.into();
26823 self
26824 }
26825 pub fn descriptor_binding_storage_texel_buffer_update_after_bind(
26826 mut self,
26827 descriptor_binding_storage_texel_buffer_update_after_bind: bool,
26828 ) -> Self {
26829 self.inner
26830 .descriptor_binding_storage_texel_buffer_update_after_bind =
26831 descriptor_binding_storage_texel_buffer_update_after_bind.into();
26832 self
26833 }
26834 pub fn descriptor_binding_update_unused_while_pending(
26835 mut self,
26836 descriptor_binding_update_unused_while_pending: bool,
26837 ) -> Self {
26838 self.inner.descriptor_binding_update_unused_while_pending =
26839 descriptor_binding_update_unused_while_pending.into();
26840 self
26841 }
26842 pub fn descriptor_binding_partially_bound(
26843 mut self,
26844 descriptor_binding_partially_bound: bool,
26845 ) -> Self {
26846 self.inner.descriptor_binding_partially_bound = descriptor_binding_partially_bound.into();
26847 self
26848 }
26849 pub fn descriptor_binding_variable_descriptor_count(
26850 mut self,
26851 descriptor_binding_variable_descriptor_count: bool,
26852 ) -> Self {
26853 self.inner.descriptor_binding_variable_descriptor_count =
26854 descriptor_binding_variable_descriptor_count.into();
26855 self
26856 }
26857 pub fn runtime_descriptor_array(mut self, runtime_descriptor_array: bool) -> Self {
26858 self.inner.runtime_descriptor_array = runtime_descriptor_array.into();
26859 self
26860 }
26861 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26862 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26863 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
26864 pub fn build(self) -> PhysicalDeviceDescriptorIndexingFeatures {
26865 self.inner
26866 }
26867}
26868#[repr(C)]
26869#[cfg_attr(feature = "debug", derive(Debug))]
26870#[derive(Copy, Clone)]
26871#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDescriptorIndexingProperties.html>"]
26872pub struct PhysicalDeviceDescriptorIndexingProperties {
26873 pub s_type: StructureType,
26874 pub p_next: *mut c_void,
26875 pub max_update_after_bind_descriptors_in_all_pools: u32,
26876 pub shader_uniform_buffer_array_non_uniform_indexing_native: Bool32,
26877 pub shader_sampled_image_array_non_uniform_indexing_native: Bool32,
26878 pub shader_storage_buffer_array_non_uniform_indexing_native: Bool32,
26879 pub shader_storage_image_array_non_uniform_indexing_native: Bool32,
26880 pub shader_input_attachment_array_non_uniform_indexing_native: Bool32,
26881 pub robust_buffer_access_update_after_bind: Bool32,
26882 pub quad_divergent_implicit_lod: Bool32,
26883 pub max_per_stage_descriptor_update_after_bind_samplers: u32,
26884 pub max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
26885 pub max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
26886 pub max_per_stage_descriptor_update_after_bind_sampled_images: u32,
26887 pub max_per_stage_descriptor_update_after_bind_storage_images: u32,
26888 pub max_per_stage_descriptor_update_after_bind_input_attachments: u32,
26889 pub max_per_stage_update_after_bind_resources: u32,
26890 pub max_descriptor_set_update_after_bind_samplers: u32,
26891 pub max_descriptor_set_update_after_bind_uniform_buffers: u32,
26892 pub max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
26893 pub max_descriptor_set_update_after_bind_storage_buffers: u32,
26894 pub max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
26895 pub max_descriptor_set_update_after_bind_sampled_images: u32,
26896 pub max_descriptor_set_update_after_bind_storage_images: u32,
26897 pub max_descriptor_set_update_after_bind_input_attachments: u32,
26898}
26899impl ::std::default::Default for PhysicalDeviceDescriptorIndexingProperties {
26900 fn default() -> Self {
26901 Self {
26902 s_type: StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES,
26903 p_next: ::std::ptr::null_mut(),
26904 max_update_after_bind_descriptors_in_all_pools: u32::default(),
26905 shader_uniform_buffer_array_non_uniform_indexing_native: Bool32::default(),
26906 shader_sampled_image_array_non_uniform_indexing_native: Bool32::default(),
26907 shader_storage_buffer_array_non_uniform_indexing_native: Bool32::default(),
26908 shader_storage_image_array_non_uniform_indexing_native: Bool32::default(),
26909 shader_input_attachment_array_non_uniform_indexing_native: Bool32::default(),
26910 robust_buffer_access_update_after_bind: Bool32::default(),
26911 quad_divergent_implicit_lod: Bool32::default(),
26912 max_per_stage_descriptor_update_after_bind_samplers: u32::default(),
26913 max_per_stage_descriptor_update_after_bind_uniform_buffers: u32::default(),
26914 max_per_stage_descriptor_update_after_bind_storage_buffers: u32::default(),
26915 max_per_stage_descriptor_update_after_bind_sampled_images: u32::default(),
26916 max_per_stage_descriptor_update_after_bind_storage_images: u32::default(),
26917 max_per_stage_descriptor_update_after_bind_input_attachments: u32::default(),
26918 max_per_stage_update_after_bind_resources: u32::default(),
26919 max_descriptor_set_update_after_bind_samplers: u32::default(),
26920 max_descriptor_set_update_after_bind_uniform_buffers: u32::default(),
26921 max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32::default(),
26922 max_descriptor_set_update_after_bind_storage_buffers: u32::default(),
26923 max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32::default(),
26924 max_descriptor_set_update_after_bind_sampled_images: u32::default(),
26925 max_descriptor_set_update_after_bind_storage_images: u32::default(),
26926 max_descriptor_set_update_after_bind_input_attachments: u32::default(),
26927 }
26928 }
26929}
26930impl PhysicalDeviceDescriptorIndexingProperties {
26931 pub fn builder<'a>() -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
26932 PhysicalDeviceDescriptorIndexingPropertiesBuilder {
26933 inner: Self::default(),
26934 marker: ::std::marker::PhantomData,
26935 }
26936 }
26937}
26938#[repr(transparent)]
26939pub struct PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
26940 inner: PhysicalDeviceDescriptorIndexingProperties,
26941 marker: ::std::marker::PhantomData<&'a ()>,
26942}
26943unsafe impl ExtendsPhysicalDeviceProperties2
26944 for PhysicalDeviceDescriptorIndexingPropertiesBuilder<'_>
26945{
26946}
26947unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDescriptorIndexingProperties {}
26948impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
26949 type Target = PhysicalDeviceDescriptorIndexingProperties;
26950 fn deref(&self) -> &Self::Target {
26951 &self.inner
26952 }
26953}
26954impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
26955 fn deref_mut(&mut self) -> &mut Self::Target {
26956 &mut self.inner
26957 }
26958}
26959impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
26960 pub fn max_update_after_bind_descriptors_in_all_pools(
26961 mut self,
26962 max_update_after_bind_descriptors_in_all_pools: u32,
26963 ) -> Self {
26964 self.inner.max_update_after_bind_descriptors_in_all_pools =
26965 max_update_after_bind_descriptors_in_all_pools;
26966 self
26967 }
26968 pub fn shader_uniform_buffer_array_non_uniform_indexing_native(
26969 mut self,
26970 shader_uniform_buffer_array_non_uniform_indexing_native: bool,
26971 ) -> Self {
26972 self.inner
26973 .shader_uniform_buffer_array_non_uniform_indexing_native =
26974 shader_uniform_buffer_array_non_uniform_indexing_native.into();
26975 self
26976 }
26977 pub fn shader_sampled_image_array_non_uniform_indexing_native(
26978 mut self,
26979 shader_sampled_image_array_non_uniform_indexing_native: bool,
26980 ) -> Self {
26981 self.inner
26982 .shader_sampled_image_array_non_uniform_indexing_native =
26983 shader_sampled_image_array_non_uniform_indexing_native.into();
26984 self
26985 }
26986 pub fn shader_storage_buffer_array_non_uniform_indexing_native(
26987 mut self,
26988 shader_storage_buffer_array_non_uniform_indexing_native: bool,
26989 ) -> Self {
26990 self.inner
26991 .shader_storage_buffer_array_non_uniform_indexing_native =
26992 shader_storage_buffer_array_non_uniform_indexing_native.into();
26993 self
26994 }
26995 pub fn shader_storage_image_array_non_uniform_indexing_native(
26996 mut self,
26997 shader_storage_image_array_non_uniform_indexing_native: bool,
26998 ) -> Self {
26999 self.inner
27000 .shader_storage_image_array_non_uniform_indexing_native =
27001 shader_storage_image_array_non_uniform_indexing_native.into();
27002 self
27003 }
27004 pub fn shader_input_attachment_array_non_uniform_indexing_native(
27005 mut self,
27006 shader_input_attachment_array_non_uniform_indexing_native: bool,
27007 ) -> Self {
27008 self.inner
27009 .shader_input_attachment_array_non_uniform_indexing_native =
27010 shader_input_attachment_array_non_uniform_indexing_native.into();
27011 self
27012 }
27013 pub fn robust_buffer_access_update_after_bind(
27014 mut self,
27015 robust_buffer_access_update_after_bind: bool,
27016 ) -> Self {
27017 self.inner.robust_buffer_access_update_after_bind =
27018 robust_buffer_access_update_after_bind.into();
27019 self
27020 }
27021 pub fn quad_divergent_implicit_lod(mut self, quad_divergent_implicit_lod: bool) -> Self {
27022 self.inner.quad_divergent_implicit_lod = quad_divergent_implicit_lod.into();
27023 self
27024 }
27025 pub fn max_per_stage_descriptor_update_after_bind_samplers(
27026 mut self,
27027 max_per_stage_descriptor_update_after_bind_samplers: u32,
27028 ) -> Self {
27029 self.inner
27030 .max_per_stage_descriptor_update_after_bind_samplers =
27031 max_per_stage_descriptor_update_after_bind_samplers;
27032 self
27033 }
27034 pub fn max_per_stage_descriptor_update_after_bind_uniform_buffers(
27035 mut self,
27036 max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
27037 ) -> Self {
27038 self.inner
27039 .max_per_stage_descriptor_update_after_bind_uniform_buffers =
27040 max_per_stage_descriptor_update_after_bind_uniform_buffers;
27041 self
27042 }
27043 pub fn max_per_stage_descriptor_update_after_bind_storage_buffers(
27044 mut self,
27045 max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
27046 ) -> Self {
27047 self.inner
27048 .max_per_stage_descriptor_update_after_bind_storage_buffers =
27049 max_per_stage_descriptor_update_after_bind_storage_buffers;
27050 self
27051 }
27052 pub fn max_per_stage_descriptor_update_after_bind_sampled_images(
27053 mut self,
27054 max_per_stage_descriptor_update_after_bind_sampled_images: u32,
27055 ) -> Self {
27056 self.inner
27057 .max_per_stage_descriptor_update_after_bind_sampled_images =
27058 max_per_stage_descriptor_update_after_bind_sampled_images;
27059 self
27060 }
27061 pub fn max_per_stage_descriptor_update_after_bind_storage_images(
27062 mut self,
27063 max_per_stage_descriptor_update_after_bind_storage_images: u32,
27064 ) -> Self {
27065 self.inner
27066 .max_per_stage_descriptor_update_after_bind_storage_images =
27067 max_per_stage_descriptor_update_after_bind_storage_images;
27068 self
27069 }
27070 pub fn max_per_stage_descriptor_update_after_bind_input_attachments(
27071 mut self,
27072 max_per_stage_descriptor_update_after_bind_input_attachments: u32,
27073 ) -> Self {
27074 self.inner
27075 .max_per_stage_descriptor_update_after_bind_input_attachments =
27076 max_per_stage_descriptor_update_after_bind_input_attachments;
27077 self
27078 }
27079 pub fn max_per_stage_update_after_bind_resources(
27080 mut self,
27081 max_per_stage_update_after_bind_resources: u32,
27082 ) -> Self {
27083 self.inner.max_per_stage_update_after_bind_resources =
27084 max_per_stage_update_after_bind_resources;
27085 self
27086 }
27087 pub fn max_descriptor_set_update_after_bind_samplers(
27088 mut self,
27089 max_descriptor_set_update_after_bind_samplers: u32,
27090 ) -> Self {
27091 self.inner.max_descriptor_set_update_after_bind_samplers =
27092 max_descriptor_set_update_after_bind_samplers;
27093 self
27094 }
27095 pub fn max_descriptor_set_update_after_bind_uniform_buffers(
27096 mut self,
27097 max_descriptor_set_update_after_bind_uniform_buffers: u32,
27098 ) -> Self {
27099 self.inner
27100 .max_descriptor_set_update_after_bind_uniform_buffers =
27101 max_descriptor_set_update_after_bind_uniform_buffers;
27102 self
27103 }
27104 pub fn max_descriptor_set_update_after_bind_uniform_buffers_dynamic(
27105 mut self,
27106 max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
27107 ) -> Self {
27108 self.inner
27109 .max_descriptor_set_update_after_bind_uniform_buffers_dynamic =
27110 max_descriptor_set_update_after_bind_uniform_buffers_dynamic;
27111 self
27112 }
27113 pub fn max_descriptor_set_update_after_bind_storage_buffers(
27114 mut self,
27115 max_descriptor_set_update_after_bind_storage_buffers: u32,
27116 ) -> Self {
27117 self.inner
27118 .max_descriptor_set_update_after_bind_storage_buffers =
27119 max_descriptor_set_update_after_bind_storage_buffers;
27120 self
27121 }
27122 pub fn max_descriptor_set_update_after_bind_storage_buffers_dynamic(
27123 mut self,
27124 max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
27125 ) -> Self {
27126 self.inner
27127 .max_descriptor_set_update_after_bind_storage_buffers_dynamic =
27128 max_descriptor_set_update_after_bind_storage_buffers_dynamic;
27129 self
27130 }
27131 pub fn max_descriptor_set_update_after_bind_sampled_images(
27132 mut self,
27133 max_descriptor_set_update_after_bind_sampled_images: u32,
27134 ) -> Self {
27135 self.inner
27136 .max_descriptor_set_update_after_bind_sampled_images =
27137 max_descriptor_set_update_after_bind_sampled_images;
27138 self
27139 }
27140 pub fn max_descriptor_set_update_after_bind_storage_images(
27141 mut self,
27142 max_descriptor_set_update_after_bind_storage_images: u32,
27143 ) -> Self {
27144 self.inner
27145 .max_descriptor_set_update_after_bind_storage_images =
27146 max_descriptor_set_update_after_bind_storage_images;
27147 self
27148 }
27149 pub fn max_descriptor_set_update_after_bind_input_attachments(
27150 mut self,
27151 max_descriptor_set_update_after_bind_input_attachments: u32,
27152 ) -> Self {
27153 self.inner
27154 .max_descriptor_set_update_after_bind_input_attachments =
27155 max_descriptor_set_update_after_bind_input_attachments;
27156 self
27157 }
27158 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27159 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27160 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
27161 pub fn build(self) -> PhysicalDeviceDescriptorIndexingProperties {
27162 self.inner
27163 }
27164}
27165#[repr(C)]
27166#[cfg_attr(feature = "debug", derive(Debug))]
27167#[derive(Copy, Clone)]
27168#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutBindingFlagsCreateInfo.html>"]
27169pub struct DescriptorSetLayoutBindingFlagsCreateInfo {
27170 pub s_type: StructureType,
27171 pub p_next: *const c_void,
27172 pub binding_count: u32,
27173 pub p_binding_flags: *const DescriptorBindingFlags,
27174}
27175impl ::std::default::Default for DescriptorSetLayoutBindingFlagsCreateInfo {
27176 fn default() -> Self {
27177 Self {
27178 s_type: StructureType::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO,
27179 p_next: ::std::ptr::null(),
27180 binding_count: u32::default(),
27181 p_binding_flags: ::std::ptr::null(),
27182 }
27183 }
27184}
27185impl DescriptorSetLayoutBindingFlagsCreateInfo {
27186 pub fn builder<'a>() -> DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
27187 DescriptorSetLayoutBindingFlagsCreateInfoBuilder {
27188 inner: Self::default(),
27189 marker: ::std::marker::PhantomData,
27190 }
27191 }
27192}
27193#[repr(transparent)]
27194pub struct DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
27195 inner: DescriptorSetLayoutBindingFlagsCreateInfo,
27196 marker: ::std::marker::PhantomData<&'a ()>,
27197}
27198unsafe impl ExtendsDescriptorSetLayoutCreateInfo
27199 for DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'_>
27200{
27201}
27202unsafe impl ExtendsDescriptorSetLayoutCreateInfo for DescriptorSetLayoutBindingFlagsCreateInfo {}
27203impl<'a> ::std::ops::Deref for DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
27204 type Target = DescriptorSetLayoutBindingFlagsCreateInfo;
27205 fn deref(&self) -> &Self::Target {
27206 &self.inner
27207 }
27208}
27209impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
27210 fn deref_mut(&mut self) -> &mut Self::Target {
27211 &mut self.inner
27212 }
27213}
27214impl<'a> DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
27215 pub fn binding_flags(mut self, binding_flags: &'a [DescriptorBindingFlags]) -> Self {
27216 self.inner.binding_count = binding_flags.len() as _;
27217 self.inner.p_binding_flags = binding_flags.as_ptr();
27218 self
27219 }
27220 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27221 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27222 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
27223 pub fn build(self) -> DescriptorSetLayoutBindingFlagsCreateInfo {
27224 self.inner
27225 }
27226}
27227#[repr(C)]
27228#[cfg_attr(feature = "debug", derive(Debug))]
27229#[derive(Copy, Clone)]
27230#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetVariableDescriptorCountAllocateInfo.html>"]
27231pub struct DescriptorSetVariableDescriptorCountAllocateInfo {
27232 pub s_type: StructureType,
27233 pub p_next: *const c_void,
27234 pub descriptor_set_count: u32,
27235 pub p_descriptor_counts: *const u32,
27236}
27237impl ::std::default::Default for DescriptorSetVariableDescriptorCountAllocateInfo {
27238 fn default() -> Self {
27239 Self {
27240 s_type: StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO,
27241 p_next: ::std::ptr::null(),
27242 descriptor_set_count: u32::default(),
27243 p_descriptor_counts: ::std::ptr::null(),
27244 }
27245 }
27246}
27247impl DescriptorSetVariableDescriptorCountAllocateInfo {
27248 pub fn builder<'a>() -> DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
27249 DescriptorSetVariableDescriptorCountAllocateInfoBuilder {
27250 inner: Self::default(),
27251 marker: ::std::marker::PhantomData,
27252 }
27253 }
27254}
27255#[repr(transparent)]
27256pub struct DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
27257 inner: DescriptorSetVariableDescriptorCountAllocateInfo,
27258 marker: ::std::marker::PhantomData<&'a ()>,
27259}
27260unsafe impl ExtendsDescriptorSetAllocateInfo
27261 for DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'_>
27262{
27263}
27264unsafe impl ExtendsDescriptorSetAllocateInfo for DescriptorSetVariableDescriptorCountAllocateInfo {}
27265impl<'a> ::std::ops::Deref for DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
27266 type Target = DescriptorSetVariableDescriptorCountAllocateInfo;
27267 fn deref(&self) -> &Self::Target {
27268 &self.inner
27269 }
27270}
27271impl<'a> ::std::ops::DerefMut for DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
27272 fn deref_mut(&mut self) -> &mut Self::Target {
27273 &mut self.inner
27274 }
27275}
27276impl<'a> DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
27277 pub fn descriptor_counts(mut self, descriptor_counts: &'a [u32]) -> Self {
27278 self.inner.descriptor_set_count = descriptor_counts.len() as _;
27279 self.inner.p_descriptor_counts = descriptor_counts.as_ptr();
27280 self
27281 }
27282 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27283 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27284 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
27285 pub fn build(self) -> DescriptorSetVariableDescriptorCountAllocateInfo {
27286 self.inner
27287 }
27288}
27289#[repr(C)]
27290#[cfg_attr(feature = "debug", derive(Debug))]
27291#[derive(Copy, Clone)]
27292#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetVariableDescriptorCountLayoutSupport.html>"]
27293pub struct DescriptorSetVariableDescriptorCountLayoutSupport {
27294 pub s_type: StructureType,
27295 pub p_next: *mut c_void,
27296 pub max_variable_descriptor_count: u32,
27297}
27298impl ::std::default::Default for DescriptorSetVariableDescriptorCountLayoutSupport {
27299 fn default() -> Self {
27300 Self {
27301 s_type: StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT,
27302 p_next: ::std::ptr::null_mut(),
27303 max_variable_descriptor_count: u32::default(),
27304 }
27305 }
27306}
27307impl DescriptorSetVariableDescriptorCountLayoutSupport {
27308 pub fn builder<'a>() -> DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
27309 DescriptorSetVariableDescriptorCountLayoutSupportBuilder {
27310 inner: Self::default(),
27311 marker: ::std::marker::PhantomData,
27312 }
27313 }
27314}
27315#[repr(transparent)]
27316pub struct DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
27317 inner: DescriptorSetVariableDescriptorCountLayoutSupport,
27318 marker: ::std::marker::PhantomData<&'a ()>,
27319}
27320unsafe impl ExtendsDescriptorSetLayoutSupport
27321 for DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'_>
27322{
27323}
27324unsafe impl ExtendsDescriptorSetLayoutSupport
27325 for DescriptorSetVariableDescriptorCountLayoutSupport
27326{
27327}
27328impl<'a> ::std::ops::Deref for DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
27329 type Target = DescriptorSetVariableDescriptorCountLayoutSupport;
27330 fn deref(&self) -> &Self::Target {
27331 &self.inner
27332 }
27333}
27334impl<'a> ::std::ops::DerefMut for DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
27335 fn deref_mut(&mut self) -> &mut Self::Target {
27336 &mut self.inner
27337 }
27338}
27339impl<'a> DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
27340 pub fn max_variable_descriptor_count(mut self, max_variable_descriptor_count: u32) -> Self {
27341 self.inner.max_variable_descriptor_count = max_variable_descriptor_count;
27342 self
27343 }
27344 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27345 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27346 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
27347 pub fn build(self) -> DescriptorSetVariableDescriptorCountLayoutSupport {
27348 self.inner
27349 }
27350}
27351#[repr(C)]
27352#[cfg_attr(feature = "debug", derive(Debug))]
27353#[derive(Copy, Clone)]
27354#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentDescription2.html>"]
27355pub struct AttachmentDescription2 {
27356 pub s_type: StructureType,
27357 pub p_next: *const c_void,
27358 pub flags: AttachmentDescriptionFlags,
27359 pub format: Format,
27360 pub samples: SampleCountFlags,
27361 pub load_op: AttachmentLoadOp,
27362 pub store_op: AttachmentStoreOp,
27363 pub stencil_load_op: AttachmentLoadOp,
27364 pub stencil_store_op: AttachmentStoreOp,
27365 pub initial_layout: ImageLayout,
27366 pub final_layout: ImageLayout,
27367}
27368impl ::std::default::Default for AttachmentDescription2 {
27369 fn default() -> Self {
27370 Self {
27371 s_type: StructureType::ATTACHMENT_DESCRIPTION_2,
27372 p_next: ::std::ptr::null(),
27373 flags: AttachmentDescriptionFlags::default(),
27374 format: Format::default(),
27375 samples: SampleCountFlags::default(),
27376 load_op: AttachmentLoadOp::default(),
27377 store_op: AttachmentStoreOp::default(),
27378 stencil_load_op: AttachmentLoadOp::default(),
27379 stencil_store_op: AttachmentStoreOp::default(),
27380 initial_layout: ImageLayout::default(),
27381 final_layout: ImageLayout::default(),
27382 }
27383 }
27384}
27385impl AttachmentDescription2 {
27386 pub fn builder<'a>() -> AttachmentDescription2Builder<'a> {
27387 AttachmentDescription2Builder {
27388 inner: Self::default(),
27389 marker: ::std::marker::PhantomData,
27390 }
27391 }
27392}
27393#[repr(transparent)]
27394pub struct AttachmentDescription2Builder<'a> {
27395 inner: AttachmentDescription2,
27396 marker: ::std::marker::PhantomData<&'a ()>,
27397}
27398pub unsafe trait ExtendsAttachmentDescription2 {}
27399impl<'a> ::std::ops::Deref for AttachmentDescription2Builder<'a> {
27400 type Target = AttachmentDescription2;
27401 fn deref(&self) -> &Self::Target {
27402 &self.inner
27403 }
27404}
27405impl<'a> ::std::ops::DerefMut for AttachmentDescription2Builder<'a> {
27406 fn deref_mut(&mut self) -> &mut Self::Target {
27407 &mut self.inner
27408 }
27409}
27410impl<'a> AttachmentDescription2Builder<'a> {
27411 pub fn flags(mut self, flags: AttachmentDescriptionFlags) -> Self {
27412 self.inner.flags = flags;
27413 self
27414 }
27415 pub fn format(mut self, format: Format) -> Self {
27416 self.inner.format = format;
27417 self
27418 }
27419 pub fn samples(mut self, samples: SampleCountFlags) -> Self {
27420 self.inner.samples = samples;
27421 self
27422 }
27423 pub fn load_op(mut self, load_op: AttachmentLoadOp) -> Self {
27424 self.inner.load_op = load_op;
27425 self
27426 }
27427 pub fn store_op(mut self, store_op: AttachmentStoreOp) -> Self {
27428 self.inner.store_op = store_op;
27429 self
27430 }
27431 pub fn stencil_load_op(mut self, stencil_load_op: AttachmentLoadOp) -> Self {
27432 self.inner.stencil_load_op = stencil_load_op;
27433 self
27434 }
27435 pub fn stencil_store_op(mut self, stencil_store_op: AttachmentStoreOp) -> Self {
27436 self.inner.stencil_store_op = stencil_store_op;
27437 self
27438 }
27439 pub fn initial_layout(mut self, initial_layout: ImageLayout) -> Self {
27440 self.inner.initial_layout = initial_layout;
27441 self
27442 }
27443 pub fn final_layout(mut self, final_layout: ImageLayout) -> Self {
27444 self.inner.final_layout = final_layout;
27445 self
27446 }
27447 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
27448 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
27449 #[doc = r" valid extension structs can be pushed into the chain."]
27450 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
27451 #[doc = r" chain will look like `A -> D -> B -> C`."]
27452 pub fn push_next<T: ExtendsAttachmentDescription2>(mut self, next: &'a mut T) -> Self {
27453 unsafe {
27454 let next_ptr = <*const T>::cast(next);
27455 let last_next = ptr_chain_iter(next).last().unwrap();
27456 (*last_next).p_next = self.inner.p_next as _;
27457 self.inner.p_next = next_ptr;
27458 }
27459 self
27460 }
27461 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27462 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27463 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
27464 pub fn build(self) -> AttachmentDescription2 {
27465 self.inner
27466 }
27467}
27468#[repr(C)]
27469#[cfg_attr(feature = "debug", derive(Debug))]
27470#[derive(Copy, Clone)]
27471#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentReference2.html>"]
27472pub struct AttachmentReference2 {
27473 pub s_type: StructureType,
27474 pub p_next: *const c_void,
27475 pub attachment: u32,
27476 pub layout: ImageLayout,
27477 pub aspect_mask: ImageAspectFlags,
27478}
27479impl ::std::default::Default for AttachmentReference2 {
27480 fn default() -> Self {
27481 Self {
27482 s_type: StructureType::ATTACHMENT_REFERENCE_2,
27483 p_next: ::std::ptr::null(),
27484 attachment: u32::default(),
27485 layout: ImageLayout::default(),
27486 aspect_mask: ImageAspectFlags::default(),
27487 }
27488 }
27489}
27490impl AttachmentReference2 {
27491 pub fn builder<'a>() -> AttachmentReference2Builder<'a> {
27492 AttachmentReference2Builder {
27493 inner: Self::default(),
27494 marker: ::std::marker::PhantomData,
27495 }
27496 }
27497}
27498#[repr(transparent)]
27499pub struct AttachmentReference2Builder<'a> {
27500 inner: AttachmentReference2,
27501 marker: ::std::marker::PhantomData<&'a ()>,
27502}
27503pub unsafe trait ExtendsAttachmentReference2 {}
27504impl<'a> ::std::ops::Deref for AttachmentReference2Builder<'a> {
27505 type Target = AttachmentReference2;
27506 fn deref(&self) -> &Self::Target {
27507 &self.inner
27508 }
27509}
27510impl<'a> ::std::ops::DerefMut for AttachmentReference2Builder<'a> {
27511 fn deref_mut(&mut self) -> &mut Self::Target {
27512 &mut self.inner
27513 }
27514}
27515impl<'a> AttachmentReference2Builder<'a> {
27516 pub fn attachment(mut self, attachment: u32) -> Self {
27517 self.inner.attachment = attachment;
27518 self
27519 }
27520 pub fn layout(mut self, layout: ImageLayout) -> Self {
27521 self.inner.layout = layout;
27522 self
27523 }
27524 pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self {
27525 self.inner.aspect_mask = aspect_mask;
27526 self
27527 }
27528 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
27529 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
27530 #[doc = r" valid extension structs can be pushed into the chain."]
27531 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
27532 #[doc = r" chain will look like `A -> D -> B -> C`."]
27533 pub fn push_next<T: ExtendsAttachmentReference2>(mut self, next: &'a mut T) -> Self {
27534 unsafe {
27535 let next_ptr = <*const T>::cast(next);
27536 let last_next = ptr_chain_iter(next).last().unwrap();
27537 (*last_next).p_next = self.inner.p_next as _;
27538 self.inner.p_next = next_ptr;
27539 }
27540 self
27541 }
27542 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27543 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27544 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
27545 pub fn build(self) -> AttachmentReference2 {
27546 self.inner
27547 }
27548}
27549#[repr(C)]
27550#[cfg_attr(feature = "debug", derive(Debug))]
27551#[derive(Copy, Clone)]
27552#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDescription2.html>"]
27553pub struct SubpassDescription2 {
27554 pub s_type: StructureType,
27555 pub p_next: *const c_void,
27556 pub flags: SubpassDescriptionFlags,
27557 pub pipeline_bind_point: PipelineBindPoint,
27558 pub view_mask: u32,
27559 pub input_attachment_count: u32,
27560 pub p_input_attachments: *const AttachmentReference2,
27561 pub color_attachment_count: u32,
27562 pub p_color_attachments: *const AttachmentReference2,
27563 pub p_resolve_attachments: *const AttachmentReference2,
27564 pub p_depth_stencil_attachment: *const AttachmentReference2,
27565 pub preserve_attachment_count: u32,
27566 pub p_preserve_attachments: *const u32,
27567}
27568impl ::std::default::Default for SubpassDescription2 {
27569 fn default() -> Self {
27570 Self {
27571 s_type: StructureType::SUBPASS_DESCRIPTION_2,
27572 p_next: ::std::ptr::null(),
27573 flags: SubpassDescriptionFlags::default(),
27574 pipeline_bind_point: PipelineBindPoint::default(),
27575 view_mask: u32::default(),
27576 input_attachment_count: u32::default(),
27577 p_input_attachments: ::std::ptr::null(),
27578 color_attachment_count: u32::default(),
27579 p_color_attachments: ::std::ptr::null(),
27580 p_resolve_attachments: ::std::ptr::null(),
27581 p_depth_stencil_attachment: ::std::ptr::null(),
27582 preserve_attachment_count: u32::default(),
27583 p_preserve_attachments: ::std::ptr::null(),
27584 }
27585 }
27586}
27587impl SubpassDescription2 {
27588 pub fn builder<'a>() -> SubpassDescription2Builder<'a> {
27589 SubpassDescription2Builder {
27590 inner: Self::default(),
27591 marker: ::std::marker::PhantomData,
27592 }
27593 }
27594}
27595#[repr(transparent)]
27596pub struct SubpassDescription2Builder<'a> {
27597 inner: SubpassDescription2,
27598 marker: ::std::marker::PhantomData<&'a ()>,
27599}
27600pub unsafe trait ExtendsSubpassDescription2 {}
27601impl<'a> ::std::ops::Deref for SubpassDescription2Builder<'a> {
27602 type Target = SubpassDescription2;
27603 fn deref(&self) -> &Self::Target {
27604 &self.inner
27605 }
27606}
27607impl<'a> ::std::ops::DerefMut for SubpassDescription2Builder<'a> {
27608 fn deref_mut(&mut self) -> &mut Self::Target {
27609 &mut self.inner
27610 }
27611}
27612impl<'a> SubpassDescription2Builder<'a> {
27613 pub fn flags(mut self, flags: SubpassDescriptionFlags) -> Self {
27614 self.inner.flags = flags;
27615 self
27616 }
27617 pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self {
27618 self.inner.pipeline_bind_point = pipeline_bind_point;
27619 self
27620 }
27621 pub fn view_mask(mut self, view_mask: u32) -> Self {
27622 self.inner.view_mask = view_mask;
27623 self
27624 }
27625 pub fn input_attachments(mut self, input_attachments: &'a [AttachmentReference2]) -> Self {
27626 self.inner.input_attachment_count = input_attachments.len() as _;
27627 self.inner.p_input_attachments = input_attachments.as_ptr();
27628 self
27629 }
27630 pub fn color_attachments(mut self, color_attachments: &'a [AttachmentReference2]) -> Self {
27631 self.inner.color_attachment_count = color_attachments.len() as _;
27632 self.inner.p_color_attachments = color_attachments.as_ptr();
27633 self
27634 }
27635 pub fn resolve_attachments(mut self, resolve_attachments: &'a [AttachmentReference2]) -> Self {
27636 self.inner.color_attachment_count = resolve_attachments.len() as _;
27637 self.inner.p_resolve_attachments = resolve_attachments.as_ptr();
27638 self
27639 }
27640 pub fn depth_stencil_attachment(
27641 mut self,
27642 depth_stencil_attachment: &'a AttachmentReference2,
27643 ) -> Self {
27644 self.inner.p_depth_stencil_attachment = depth_stencil_attachment;
27645 self
27646 }
27647 pub fn preserve_attachments(mut self, preserve_attachments: &'a [u32]) -> Self {
27648 self.inner.preserve_attachment_count = preserve_attachments.len() as _;
27649 self.inner.p_preserve_attachments = preserve_attachments.as_ptr();
27650 self
27651 }
27652 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
27653 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
27654 #[doc = r" valid extension structs can be pushed into the chain."]
27655 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
27656 #[doc = r" chain will look like `A -> D -> B -> C`."]
27657 pub fn push_next<T: ExtendsSubpassDescription2>(mut self, next: &'a mut T) -> Self {
27658 unsafe {
27659 let next_ptr = <*const T>::cast(next);
27660 let last_next = ptr_chain_iter(next).last().unwrap();
27661 (*last_next).p_next = self.inner.p_next as _;
27662 self.inner.p_next = next_ptr;
27663 }
27664 self
27665 }
27666 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27667 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27668 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
27669 pub fn build(self) -> SubpassDescription2 {
27670 self.inner
27671 }
27672}
27673#[repr(C)]
27674#[cfg_attr(feature = "debug", derive(Debug))]
27675#[derive(Copy, Clone)]
27676#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDependency2.html>"]
27677pub struct SubpassDependency2 {
27678 pub s_type: StructureType,
27679 pub p_next: *const c_void,
27680 pub src_subpass: u32,
27681 pub dst_subpass: u32,
27682 pub src_stage_mask: PipelineStageFlags,
27683 pub dst_stage_mask: PipelineStageFlags,
27684 pub src_access_mask: AccessFlags,
27685 pub dst_access_mask: AccessFlags,
27686 pub dependency_flags: DependencyFlags,
27687 pub view_offset: i32,
27688}
27689impl ::std::default::Default for SubpassDependency2 {
27690 fn default() -> Self {
27691 Self {
27692 s_type: StructureType::SUBPASS_DEPENDENCY_2,
27693 p_next: ::std::ptr::null(),
27694 src_subpass: u32::default(),
27695 dst_subpass: u32::default(),
27696 src_stage_mask: PipelineStageFlags::default(),
27697 dst_stage_mask: PipelineStageFlags::default(),
27698 src_access_mask: AccessFlags::default(),
27699 dst_access_mask: AccessFlags::default(),
27700 dependency_flags: DependencyFlags::default(),
27701 view_offset: i32::default(),
27702 }
27703 }
27704}
27705impl SubpassDependency2 {
27706 pub fn builder<'a>() -> SubpassDependency2Builder<'a> {
27707 SubpassDependency2Builder {
27708 inner: Self::default(),
27709 marker: ::std::marker::PhantomData,
27710 }
27711 }
27712}
27713#[repr(transparent)]
27714pub struct SubpassDependency2Builder<'a> {
27715 inner: SubpassDependency2,
27716 marker: ::std::marker::PhantomData<&'a ()>,
27717}
27718pub unsafe trait ExtendsSubpassDependency2 {}
27719impl<'a> ::std::ops::Deref for SubpassDependency2Builder<'a> {
27720 type Target = SubpassDependency2;
27721 fn deref(&self) -> &Self::Target {
27722 &self.inner
27723 }
27724}
27725impl<'a> ::std::ops::DerefMut for SubpassDependency2Builder<'a> {
27726 fn deref_mut(&mut self) -> &mut Self::Target {
27727 &mut self.inner
27728 }
27729}
27730impl<'a> SubpassDependency2Builder<'a> {
27731 pub fn src_subpass(mut self, src_subpass: u32) -> Self {
27732 self.inner.src_subpass = src_subpass;
27733 self
27734 }
27735 pub fn dst_subpass(mut self, dst_subpass: u32) -> Self {
27736 self.inner.dst_subpass = dst_subpass;
27737 self
27738 }
27739 pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags) -> Self {
27740 self.inner.src_stage_mask = src_stage_mask;
27741 self
27742 }
27743 pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags) -> Self {
27744 self.inner.dst_stage_mask = dst_stage_mask;
27745 self
27746 }
27747 pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self {
27748 self.inner.src_access_mask = src_access_mask;
27749 self
27750 }
27751 pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self {
27752 self.inner.dst_access_mask = dst_access_mask;
27753 self
27754 }
27755 pub fn dependency_flags(mut self, dependency_flags: DependencyFlags) -> Self {
27756 self.inner.dependency_flags = dependency_flags;
27757 self
27758 }
27759 pub fn view_offset(mut self, view_offset: i32) -> Self {
27760 self.inner.view_offset = view_offset;
27761 self
27762 }
27763 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
27764 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
27765 #[doc = r" valid extension structs can be pushed into the chain."]
27766 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
27767 #[doc = r" chain will look like `A -> D -> B -> C`."]
27768 pub fn push_next<T: ExtendsSubpassDependency2>(mut self, next: &'a mut T) -> Self {
27769 unsafe {
27770 let next_ptr = <*const T>::cast(next);
27771 let last_next = ptr_chain_iter(next).last().unwrap();
27772 (*last_next).p_next = self.inner.p_next as _;
27773 self.inner.p_next = next_ptr;
27774 }
27775 self
27776 }
27777 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27778 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27779 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
27780 pub fn build(self) -> SubpassDependency2 {
27781 self.inner
27782 }
27783}
27784#[repr(C)]
27785#[cfg_attr(feature = "debug", derive(Debug))]
27786#[derive(Copy, Clone)]
27787#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassCreateInfo2.html>"]
27788pub struct RenderPassCreateInfo2 {
27789 pub s_type: StructureType,
27790 pub p_next: *const c_void,
27791 pub flags: RenderPassCreateFlags,
27792 pub attachment_count: u32,
27793 pub p_attachments: *const AttachmentDescription2,
27794 pub subpass_count: u32,
27795 pub p_subpasses: *const SubpassDescription2,
27796 pub dependency_count: u32,
27797 pub p_dependencies: *const SubpassDependency2,
27798 pub correlated_view_mask_count: u32,
27799 pub p_correlated_view_masks: *const u32,
27800}
27801impl ::std::default::Default for RenderPassCreateInfo2 {
27802 fn default() -> Self {
27803 Self {
27804 s_type: StructureType::RENDER_PASS_CREATE_INFO_2,
27805 p_next: ::std::ptr::null(),
27806 flags: RenderPassCreateFlags::default(),
27807 attachment_count: u32::default(),
27808 p_attachments: ::std::ptr::null(),
27809 subpass_count: u32::default(),
27810 p_subpasses: ::std::ptr::null(),
27811 dependency_count: u32::default(),
27812 p_dependencies: ::std::ptr::null(),
27813 correlated_view_mask_count: u32::default(),
27814 p_correlated_view_masks: ::std::ptr::null(),
27815 }
27816 }
27817}
27818impl RenderPassCreateInfo2 {
27819 pub fn builder<'a>() -> RenderPassCreateInfo2Builder<'a> {
27820 RenderPassCreateInfo2Builder {
27821 inner: Self::default(),
27822 marker: ::std::marker::PhantomData,
27823 }
27824 }
27825}
27826#[repr(transparent)]
27827pub struct RenderPassCreateInfo2Builder<'a> {
27828 inner: RenderPassCreateInfo2,
27829 marker: ::std::marker::PhantomData<&'a ()>,
27830}
27831pub unsafe trait ExtendsRenderPassCreateInfo2 {}
27832impl<'a> ::std::ops::Deref for RenderPassCreateInfo2Builder<'a> {
27833 type Target = RenderPassCreateInfo2;
27834 fn deref(&self) -> &Self::Target {
27835 &self.inner
27836 }
27837}
27838impl<'a> ::std::ops::DerefMut for RenderPassCreateInfo2Builder<'a> {
27839 fn deref_mut(&mut self) -> &mut Self::Target {
27840 &mut self.inner
27841 }
27842}
27843impl<'a> RenderPassCreateInfo2Builder<'a> {
27844 pub fn flags(mut self, flags: RenderPassCreateFlags) -> Self {
27845 self.inner.flags = flags;
27846 self
27847 }
27848 pub fn attachments(mut self, attachments: &'a [AttachmentDescription2]) -> Self {
27849 self.inner.attachment_count = attachments.len() as _;
27850 self.inner.p_attachments = attachments.as_ptr();
27851 self
27852 }
27853 pub fn subpasses(mut self, subpasses: &'a [SubpassDescription2]) -> Self {
27854 self.inner.subpass_count = subpasses.len() as _;
27855 self.inner.p_subpasses = subpasses.as_ptr();
27856 self
27857 }
27858 pub fn dependencies(mut self, dependencies: &'a [SubpassDependency2]) -> Self {
27859 self.inner.dependency_count = dependencies.len() as _;
27860 self.inner.p_dependencies = dependencies.as_ptr();
27861 self
27862 }
27863 pub fn correlated_view_masks(mut self, correlated_view_masks: &'a [u32]) -> Self {
27864 self.inner.correlated_view_mask_count = correlated_view_masks.len() as _;
27865 self.inner.p_correlated_view_masks = correlated_view_masks.as_ptr();
27866 self
27867 }
27868 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
27869 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
27870 #[doc = r" valid extension structs can be pushed into the chain."]
27871 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
27872 #[doc = r" chain will look like `A -> D -> B -> C`."]
27873 pub fn push_next<T: ExtendsRenderPassCreateInfo2>(mut self, next: &'a mut T) -> Self {
27874 unsafe {
27875 let next_ptr = <*const T>::cast(next);
27876 let last_next = ptr_chain_iter(next).last().unwrap();
27877 (*last_next).p_next = self.inner.p_next as _;
27878 self.inner.p_next = next_ptr;
27879 }
27880 self
27881 }
27882 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27883 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27884 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
27885 pub fn build(self) -> RenderPassCreateInfo2 {
27886 self.inner
27887 }
27888}
27889#[repr(C)]
27890#[cfg_attr(feature = "debug", derive(Debug))]
27891#[derive(Copy, Clone)]
27892#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassBeginInfo.html>"]
27893pub struct SubpassBeginInfo {
27894 pub s_type: StructureType,
27895 pub p_next: *const c_void,
27896 pub contents: SubpassContents,
27897}
27898impl ::std::default::Default for SubpassBeginInfo {
27899 fn default() -> Self {
27900 Self {
27901 s_type: StructureType::SUBPASS_BEGIN_INFO,
27902 p_next: ::std::ptr::null(),
27903 contents: SubpassContents::default(),
27904 }
27905 }
27906}
27907impl SubpassBeginInfo {
27908 pub fn builder<'a>() -> SubpassBeginInfoBuilder<'a> {
27909 SubpassBeginInfoBuilder {
27910 inner: Self::default(),
27911 marker: ::std::marker::PhantomData,
27912 }
27913 }
27914}
27915#[repr(transparent)]
27916pub struct SubpassBeginInfoBuilder<'a> {
27917 inner: SubpassBeginInfo,
27918 marker: ::std::marker::PhantomData<&'a ()>,
27919}
27920impl<'a> ::std::ops::Deref for SubpassBeginInfoBuilder<'a> {
27921 type Target = SubpassBeginInfo;
27922 fn deref(&self) -> &Self::Target {
27923 &self.inner
27924 }
27925}
27926impl<'a> ::std::ops::DerefMut for SubpassBeginInfoBuilder<'a> {
27927 fn deref_mut(&mut self) -> &mut Self::Target {
27928 &mut self.inner
27929 }
27930}
27931impl<'a> SubpassBeginInfoBuilder<'a> {
27932 pub fn contents(mut self, contents: SubpassContents) -> Self {
27933 self.inner.contents = contents;
27934 self
27935 }
27936 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27937 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27938 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
27939 pub fn build(self) -> SubpassBeginInfo {
27940 self.inner
27941 }
27942}
27943#[repr(C)]
27944#[cfg_attr(feature = "debug", derive(Debug))]
27945#[derive(Copy, Clone)]
27946#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassEndInfo.html>"]
27947pub struct SubpassEndInfo {
27948 pub s_type: StructureType,
27949 pub p_next: *const c_void,
27950}
27951impl ::std::default::Default for SubpassEndInfo {
27952 fn default() -> Self {
27953 Self {
27954 s_type: StructureType::SUBPASS_END_INFO,
27955 p_next: ::std::ptr::null(),
27956 }
27957 }
27958}
27959impl SubpassEndInfo {
27960 pub fn builder<'a>() -> SubpassEndInfoBuilder<'a> {
27961 SubpassEndInfoBuilder {
27962 inner: Self::default(),
27963 marker: ::std::marker::PhantomData,
27964 }
27965 }
27966}
27967#[repr(transparent)]
27968pub struct SubpassEndInfoBuilder<'a> {
27969 inner: SubpassEndInfo,
27970 marker: ::std::marker::PhantomData<&'a ()>,
27971}
27972pub unsafe trait ExtendsSubpassEndInfo {}
27973impl<'a> ::std::ops::Deref for SubpassEndInfoBuilder<'a> {
27974 type Target = SubpassEndInfo;
27975 fn deref(&self) -> &Self::Target {
27976 &self.inner
27977 }
27978}
27979impl<'a> ::std::ops::DerefMut for SubpassEndInfoBuilder<'a> {
27980 fn deref_mut(&mut self) -> &mut Self::Target {
27981 &mut self.inner
27982 }
27983}
27984impl<'a> SubpassEndInfoBuilder<'a> {
27985 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
27986 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
27987 #[doc = r" valid extension structs can be pushed into the chain."]
27988 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
27989 #[doc = r" chain will look like `A -> D -> B -> C`."]
27990 pub fn push_next<T: ExtendsSubpassEndInfo>(mut self, next: &'a mut T) -> Self {
27991 unsafe {
27992 let next_ptr = <*const T>::cast(next);
27993 let last_next = ptr_chain_iter(next).last().unwrap();
27994 (*last_next).p_next = self.inner.p_next as _;
27995 self.inner.p_next = next_ptr;
27996 }
27997 self
27998 }
27999 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28000 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28001 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28002 pub fn build(self) -> SubpassEndInfo {
28003 self.inner
28004 }
28005}
28006#[repr(C)]
28007#[cfg_attr(feature = "debug", derive(Debug))]
28008#[derive(Copy, Clone)]
28009#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTimelineSemaphoreFeatures.html>"]
28010pub struct PhysicalDeviceTimelineSemaphoreFeatures {
28011 pub s_type: StructureType,
28012 pub p_next: *mut c_void,
28013 pub timeline_semaphore: Bool32,
28014}
28015impl ::std::default::Default for PhysicalDeviceTimelineSemaphoreFeatures {
28016 fn default() -> Self {
28017 Self {
28018 s_type: StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES,
28019 p_next: ::std::ptr::null_mut(),
28020 timeline_semaphore: Bool32::default(),
28021 }
28022 }
28023}
28024impl PhysicalDeviceTimelineSemaphoreFeatures {
28025 pub fn builder<'a>() -> PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
28026 PhysicalDeviceTimelineSemaphoreFeaturesBuilder {
28027 inner: Self::default(),
28028 marker: ::std::marker::PhantomData,
28029 }
28030 }
28031}
28032#[repr(transparent)]
28033pub struct PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
28034 inner: PhysicalDeviceTimelineSemaphoreFeatures,
28035 marker: ::std::marker::PhantomData<&'a ()>,
28036}
28037unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'_> {}
28038unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTimelineSemaphoreFeatures {}
28039unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'_> {}
28040unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTimelineSemaphoreFeatures {}
28041impl<'a> ::std::ops::Deref for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
28042 type Target = PhysicalDeviceTimelineSemaphoreFeatures;
28043 fn deref(&self) -> &Self::Target {
28044 &self.inner
28045 }
28046}
28047impl<'a> ::std::ops::DerefMut for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
28048 fn deref_mut(&mut self) -> &mut Self::Target {
28049 &mut self.inner
28050 }
28051}
28052impl<'a> PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
28053 pub fn timeline_semaphore(mut self, timeline_semaphore: bool) -> Self {
28054 self.inner.timeline_semaphore = timeline_semaphore.into();
28055 self
28056 }
28057 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28058 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28059 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28060 pub fn build(self) -> PhysicalDeviceTimelineSemaphoreFeatures {
28061 self.inner
28062 }
28063}
28064#[repr(C)]
28065#[cfg_attr(feature = "debug", derive(Debug))]
28066#[derive(Copy, Clone)]
28067#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTimelineSemaphoreProperties.html>"]
28068pub struct PhysicalDeviceTimelineSemaphoreProperties {
28069 pub s_type: StructureType,
28070 pub p_next: *mut c_void,
28071 pub max_timeline_semaphore_value_difference: u64,
28072}
28073impl ::std::default::Default for PhysicalDeviceTimelineSemaphoreProperties {
28074 fn default() -> Self {
28075 Self {
28076 s_type: StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES,
28077 p_next: ::std::ptr::null_mut(),
28078 max_timeline_semaphore_value_difference: u64::default(),
28079 }
28080 }
28081}
28082impl PhysicalDeviceTimelineSemaphoreProperties {
28083 pub fn builder<'a>() -> PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
28084 PhysicalDeviceTimelineSemaphorePropertiesBuilder {
28085 inner: Self::default(),
28086 marker: ::std::marker::PhantomData,
28087 }
28088 }
28089}
28090#[repr(transparent)]
28091pub struct PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
28092 inner: PhysicalDeviceTimelineSemaphoreProperties,
28093 marker: ::std::marker::PhantomData<&'a ()>,
28094}
28095unsafe impl ExtendsPhysicalDeviceProperties2
28096 for PhysicalDeviceTimelineSemaphorePropertiesBuilder<'_>
28097{
28098}
28099unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTimelineSemaphoreProperties {}
28100impl<'a> ::std::ops::Deref for PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
28101 type Target = PhysicalDeviceTimelineSemaphoreProperties;
28102 fn deref(&self) -> &Self::Target {
28103 &self.inner
28104 }
28105}
28106impl<'a> ::std::ops::DerefMut for PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
28107 fn deref_mut(&mut self) -> &mut Self::Target {
28108 &mut self.inner
28109 }
28110}
28111impl<'a> PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
28112 pub fn max_timeline_semaphore_value_difference(
28113 mut self,
28114 max_timeline_semaphore_value_difference: u64,
28115 ) -> Self {
28116 self.inner.max_timeline_semaphore_value_difference =
28117 max_timeline_semaphore_value_difference;
28118 self
28119 }
28120 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28121 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28122 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28123 pub fn build(self) -> PhysicalDeviceTimelineSemaphoreProperties {
28124 self.inner
28125 }
28126}
28127#[repr(C)]
28128#[cfg_attr(feature = "debug", derive(Debug))]
28129#[derive(Copy, Clone)]
28130#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreTypeCreateInfo.html>"]
28131pub struct SemaphoreTypeCreateInfo {
28132 pub s_type: StructureType,
28133 pub p_next: *const c_void,
28134 pub semaphore_type: SemaphoreType,
28135 pub initial_value: u64,
28136}
28137impl ::std::default::Default for SemaphoreTypeCreateInfo {
28138 fn default() -> Self {
28139 Self {
28140 s_type: StructureType::SEMAPHORE_TYPE_CREATE_INFO,
28141 p_next: ::std::ptr::null(),
28142 semaphore_type: SemaphoreType::default(),
28143 initial_value: u64::default(),
28144 }
28145 }
28146}
28147impl SemaphoreTypeCreateInfo {
28148 pub fn builder<'a>() -> SemaphoreTypeCreateInfoBuilder<'a> {
28149 SemaphoreTypeCreateInfoBuilder {
28150 inner: Self::default(),
28151 marker: ::std::marker::PhantomData,
28152 }
28153 }
28154}
28155#[repr(transparent)]
28156pub struct SemaphoreTypeCreateInfoBuilder<'a> {
28157 inner: SemaphoreTypeCreateInfo,
28158 marker: ::std::marker::PhantomData<&'a ()>,
28159}
28160unsafe impl ExtendsSemaphoreCreateInfo for SemaphoreTypeCreateInfoBuilder<'_> {}
28161unsafe impl ExtendsSemaphoreCreateInfo for SemaphoreTypeCreateInfo {}
28162unsafe impl ExtendsPhysicalDeviceExternalSemaphoreInfo for SemaphoreTypeCreateInfoBuilder<'_> {}
28163unsafe impl ExtendsPhysicalDeviceExternalSemaphoreInfo for SemaphoreTypeCreateInfo {}
28164impl<'a> ::std::ops::Deref for SemaphoreTypeCreateInfoBuilder<'a> {
28165 type Target = SemaphoreTypeCreateInfo;
28166 fn deref(&self) -> &Self::Target {
28167 &self.inner
28168 }
28169}
28170impl<'a> ::std::ops::DerefMut for SemaphoreTypeCreateInfoBuilder<'a> {
28171 fn deref_mut(&mut self) -> &mut Self::Target {
28172 &mut self.inner
28173 }
28174}
28175impl<'a> SemaphoreTypeCreateInfoBuilder<'a> {
28176 pub fn semaphore_type(mut self, semaphore_type: SemaphoreType) -> Self {
28177 self.inner.semaphore_type = semaphore_type;
28178 self
28179 }
28180 pub fn initial_value(mut self, initial_value: u64) -> Self {
28181 self.inner.initial_value = initial_value;
28182 self
28183 }
28184 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28185 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28186 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28187 pub fn build(self) -> SemaphoreTypeCreateInfo {
28188 self.inner
28189 }
28190}
28191#[repr(C)]
28192#[cfg_attr(feature = "debug", derive(Debug))]
28193#[derive(Copy, Clone)]
28194#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkTimelineSemaphoreSubmitInfo.html>"]
28195pub struct TimelineSemaphoreSubmitInfo {
28196 pub s_type: StructureType,
28197 pub p_next: *const c_void,
28198 pub wait_semaphore_value_count: u32,
28199 pub p_wait_semaphore_values: *const u64,
28200 pub signal_semaphore_value_count: u32,
28201 pub p_signal_semaphore_values: *const u64,
28202}
28203impl ::std::default::Default for TimelineSemaphoreSubmitInfo {
28204 fn default() -> Self {
28205 Self {
28206 s_type: StructureType::TIMELINE_SEMAPHORE_SUBMIT_INFO,
28207 p_next: ::std::ptr::null(),
28208 wait_semaphore_value_count: u32::default(),
28209 p_wait_semaphore_values: ::std::ptr::null(),
28210 signal_semaphore_value_count: u32::default(),
28211 p_signal_semaphore_values: ::std::ptr::null(),
28212 }
28213 }
28214}
28215impl TimelineSemaphoreSubmitInfo {
28216 pub fn builder<'a>() -> TimelineSemaphoreSubmitInfoBuilder<'a> {
28217 TimelineSemaphoreSubmitInfoBuilder {
28218 inner: Self::default(),
28219 marker: ::std::marker::PhantomData,
28220 }
28221 }
28222}
28223#[repr(transparent)]
28224pub struct TimelineSemaphoreSubmitInfoBuilder<'a> {
28225 inner: TimelineSemaphoreSubmitInfo,
28226 marker: ::std::marker::PhantomData<&'a ()>,
28227}
28228unsafe impl ExtendsSubmitInfo for TimelineSemaphoreSubmitInfoBuilder<'_> {}
28229unsafe impl ExtendsSubmitInfo for TimelineSemaphoreSubmitInfo {}
28230unsafe impl ExtendsBindSparseInfo for TimelineSemaphoreSubmitInfoBuilder<'_> {}
28231unsafe impl ExtendsBindSparseInfo for TimelineSemaphoreSubmitInfo {}
28232impl<'a> ::std::ops::Deref for TimelineSemaphoreSubmitInfoBuilder<'a> {
28233 type Target = TimelineSemaphoreSubmitInfo;
28234 fn deref(&self) -> &Self::Target {
28235 &self.inner
28236 }
28237}
28238impl<'a> ::std::ops::DerefMut for TimelineSemaphoreSubmitInfoBuilder<'a> {
28239 fn deref_mut(&mut self) -> &mut Self::Target {
28240 &mut self.inner
28241 }
28242}
28243impl<'a> TimelineSemaphoreSubmitInfoBuilder<'a> {
28244 pub fn wait_semaphore_values(mut self, wait_semaphore_values: &'a [u64]) -> Self {
28245 self.inner.wait_semaphore_value_count = wait_semaphore_values.len() as _;
28246 self.inner.p_wait_semaphore_values = wait_semaphore_values.as_ptr();
28247 self
28248 }
28249 pub fn signal_semaphore_values(mut self, signal_semaphore_values: &'a [u64]) -> Self {
28250 self.inner.signal_semaphore_value_count = signal_semaphore_values.len() as _;
28251 self.inner.p_signal_semaphore_values = signal_semaphore_values.as_ptr();
28252 self
28253 }
28254 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28255 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28256 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28257 pub fn build(self) -> TimelineSemaphoreSubmitInfo {
28258 self.inner
28259 }
28260}
28261#[repr(C)]
28262#[cfg_attr(feature = "debug", derive(Debug))]
28263#[derive(Copy, Clone)]
28264#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreWaitInfo.html>"]
28265pub struct SemaphoreWaitInfo {
28266 pub s_type: StructureType,
28267 pub p_next: *const c_void,
28268 pub flags: SemaphoreWaitFlags,
28269 pub semaphore_count: u32,
28270 pub p_semaphores: *const Semaphore,
28271 pub p_values: *const u64,
28272}
28273impl ::std::default::Default for SemaphoreWaitInfo {
28274 fn default() -> Self {
28275 Self {
28276 s_type: StructureType::SEMAPHORE_WAIT_INFO,
28277 p_next: ::std::ptr::null(),
28278 flags: SemaphoreWaitFlags::default(),
28279 semaphore_count: u32::default(),
28280 p_semaphores: ::std::ptr::null(),
28281 p_values: ::std::ptr::null(),
28282 }
28283 }
28284}
28285impl SemaphoreWaitInfo {
28286 pub fn builder<'a>() -> SemaphoreWaitInfoBuilder<'a> {
28287 SemaphoreWaitInfoBuilder {
28288 inner: Self::default(),
28289 marker: ::std::marker::PhantomData,
28290 }
28291 }
28292}
28293#[repr(transparent)]
28294pub struct SemaphoreWaitInfoBuilder<'a> {
28295 inner: SemaphoreWaitInfo,
28296 marker: ::std::marker::PhantomData<&'a ()>,
28297}
28298impl<'a> ::std::ops::Deref for SemaphoreWaitInfoBuilder<'a> {
28299 type Target = SemaphoreWaitInfo;
28300 fn deref(&self) -> &Self::Target {
28301 &self.inner
28302 }
28303}
28304impl<'a> ::std::ops::DerefMut for SemaphoreWaitInfoBuilder<'a> {
28305 fn deref_mut(&mut self) -> &mut Self::Target {
28306 &mut self.inner
28307 }
28308}
28309impl<'a> SemaphoreWaitInfoBuilder<'a> {
28310 pub fn flags(mut self, flags: SemaphoreWaitFlags) -> Self {
28311 self.inner.flags = flags;
28312 self
28313 }
28314 pub fn semaphores(mut self, semaphores: &'a [Semaphore]) -> Self {
28315 self.inner.semaphore_count = semaphores.len() as _;
28316 self.inner.p_semaphores = semaphores.as_ptr();
28317 self
28318 }
28319 pub fn values(mut self, values: &'a [u64]) -> Self {
28320 self.inner.semaphore_count = values.len() as _;
28321 self.inner.p_values = values.as_ptr();
28322 self
28323 }
28324 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28325 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28326 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28327 pub fn build(self) -> SemaphoreWaitInfo {
28328 self.inner
28329 }
28330}
28331#[repr(C)]
28332#[cfg_attr(feature = "debug", derive(Debug))]
28333#[derive(Copy, Clone)]
28334#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreSignalInfo.html>"]
28335pub struct SemaphoreSignalInfo {
28336 pub s_type: StructureType,
28337 pub p_next: *const c_void,
28338 pub semaphore: Semaphore,
28339 pub value: u64,
28340}
28341impl ::std::default::Default for SemaphoreSignalInfo {
28342 fn default() -> Self {
28343 Self {
28344 s_type: StructureType::SEMAPHORE_SIGNAL_INFO,
28345 p_next: ::std::ptr::null(),
28346 semaphore: Semaphore::default(),
28347 value: u64::default(),
28348 }
28349 }
28350}
28351impl SemaphoreSignalInfo {
28352 pub fn builder<'a>() -> SemaphoreSignalInfoBuilder<'a> {
28353 SemaphoreSignalInfoBuilder {
28354 inner: Self::default(),
28355 marker: ::std::marker::PhantomData,
28356 }
28357 }
28358}
28359#[repr(transparent)]
28360pub struct SemaphoreSignalInfoBuilder<'a> {
28361 inner: SemaphoreSignalInfo,
28362 marker: ::std::marker::PhantomData<&'a ()>,
28363}
28364impl<'a> ::std::ops::Deref for SemaphoreSignalInfoBuilder<'a> {
28365 type Target = SemaphoreSignalInfo;
28366 fn deref(&self) -> &Self::Target {
28367 &self.inner
28368 }
28369}
28370impl<'a> ::std::ops::DerefMut for SemaphoreSignalInfoBuilder<'a> {
28371 fn deref_mut(&mut self) -> &mut Self::Target {
28372 &mut self.inner
28373 }
28374}
28375impl<'a> SemaphoreSignalInfoBuilder<'a> {
28376 pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
28377 self.inner.semaphore = semaphore;
28378 self
28379 }
28380 pub fn value(mut self, value: u64) -> Self {
28381 self.inner.value = value;
28382 self
28383 }
28384 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28385 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28386 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28387 pub fn build(self) -> SemaphoreSignalInfo {
28388 self.inner
28389 }
28390}
28391#[repr(C)]
28392#[cfg_attr(feature = "debug", derive(Debug))]
28393#[derive(Copy, Clone, Default)]
28394#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVertexInputBindingDivisorDescriptionEXT.html>"]
28395pub struct VertexInputBindingDivisorDescriptionEXT {
28396 pub binding: u32,
28397 pub divisor: u32,
28398}
28399impl VertexInputBindingDivisorDescriptionEXT {
28400 pub fn builder<'a>() -> VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
28401 VertexInputBindingDivisorDescriptionEXTBuilder {
28402 inner: Self::default(),
28403 marker: ::std::marker::PhantomData,
28404 }
28405 }
28406}
28407#[repr(transparent)]
28408pub struct VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
28409 inner: VertexInputBindingDivisorDescriptionEXT,
28410 marker: ::std::marker::PhantomData<&'a ()>,
28411}
28412impl<'a> ::std::ops::Deref for VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
28413 type Target = VertexInputBindingDivisorDescriptionEXT;
28414 fn deref(&self) -> &Self::Target {
28415 &self.inner
28416 }
28417}
28418impl<'a> ::std::ops::DerefMut for VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
28419 fn deref_mut(&mut self) -> &mut Self::Target {
28420 &mut self.inner
28421 }
28422}
28423impl<'a> VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
28424 pub fn binding(mut self, binding: u32) -> Self {
28425 self.inner.binding = binding;
28426 self
28427 }
28428 pub fn divisor(mut self, divisor: u32) -> Self {
28429 self.inner.divisor = divisor;
28430 self
28431 }
28432 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28433 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28434 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28435 pub fn build(self) -> VertexInputBindingDivisorDescriptionEXT {
28436 self.inner
28437 }
28438}
28439#[repr(C)]
28440#[cfg_attr(feature = "debug", derive(Debug))]
28441#[derive(Copy, Clone)]
28442#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineVertexInputDivisorStateCreateInfoEXT.html>"]
28443pub struct PipelineVertexInputDivisorStateCreateInfoEXT {
28444 pub s_type: StructureType,
28445 pub p_next: *const c_void,
28446 pub vertex_binding_divisor_count: u32,
28447 pub p_vertex_binding_divisors: *const VertexInputBindingDivisorDescriptionEXT,
28448}
28449impl ::std::default::Default for PipelineVertexInputDivisorStateCreateInfoEXT {
28450 fn default() -> Self {
28451 Self {
28452 s_type: StructureType::PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT,
28453 p_next: ::std::ptr::null(),
28454 vertex_binding_divisor_count: u32::default(),
28455 p_vertex_binding_divisors: ::std::ptr::null(),
28456 }
28457 }
28458}
28459impl PipelineVertexInputDivisorStateCreateInfoEXT {
28460 pub fn builder<'a>() -> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
28461 PipelineVertexInputDivisorStateCreateInfoEXTBuilder {
28462 inner: Self::default(),
28463 marker: ::std::marker::PhantomData,
28464 }
28465 }
28466}
28467#[repr(transparent)]
28468pub struct PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
28469 inner: PipelineVertexInputDivisorStateCreateInfoEXT,
28470 marker: ::std::marker::PhantomData<&'a ()>,
28471}
28472unsafe impl ExtendsPipelineVertexInputStateCreateInfo
28473 for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'_>
28474{
28475}
28476unsafe impl ExtendsPipelineVertexInputStateCreateInfo
28477 for PipelineVertexInputDivisorStateCreateInfoEXT
28478{
28479}
28480impl<'a> ::std::ops::Deref for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
28481 type Target = PipelineVertexInputDivisorStateCreateInfoEXT;
28482 fn deref(&self) -> &Self::Target {
28483 &self.inner
28484 }
28485}
28486impl<'a> ::std::ops::DerefMut for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
28487 fn deref_mut(&mut self) -> &mut Self::Target {
28488 &mut self.inner
28489 }
28490}
28491impl<'a> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
28492 pub fn vertex_binding_divisors(
28493 mut self,
28494 vertex_binding_divisors: &'a [VertexInputBindingDivisorDescriptionEXT],
28495 ) -> Self {
28496 self.inner.vertex_binding_divisor_count = vertex_binding_divisors.len() as _;
28497 self.inner.p_vertex_binding_divisors = vertex_binding_divisors.as_ptr();
28498 self
28499 }
28500 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28501 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28502 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28503 pub fn build(self) -> PipelineVertexInputDivisorStateCreateInfoEXT {
28504 self.inner
28505 }
28506}
28507#[repr(C)]
28508#[cfg_attr(feature = "debug", derive(Debug))]
28509#[derive(Copy, Clone)]
28510#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT.html>"]
28511pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
28512 pub s_type: StructureType,
28513 pub p_next: *mut c_void,
28514 pub max_vertex_attrib_divisor: u32,
28515}
28516impl ::std::default::Default for PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
28517 fn default() -> Self {
28518 Self {
28519 s_type: StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT,
28520 p_next: ::std::ptr::null_mut(),
28521 max_vertex_attrib_divisor: u32::default(),
28522 }
28523 }
28524}
28525impl PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
28526 pub fn builder<'a>() -> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
28527 PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder {
28528 inner: Self::default(),
28529 marker: ::std::marker::PhantomData,
28530 }
28531 }
28532}
28533#[repr(transparent)]
28534pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
28535 inner: PhysicalDeviceVertexAttributeDivisorPropertiesEXT,
28536 marker: ::std::marker::PhantomData<&'a ()>,
28537}
28538unsafe impl ExtendsPhysicalDeviceProperties2
28539 for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'_>
28540{
28541}
28542unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVertexAttributeDivisorPropertiesEXT {}
28543impl<'a> ::std::ops::Deref for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
28544 type Target = PhysicalDeviceVertexAttributeDivisorPropertiesEXT;
28545 fn deref(&self) -> &Self::Target {
28546 &self.inner
28547 }
28548}
28549impl<'a> ::std::ops::DerefMut for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
28550 fn deref_mut(&mut self) -> &mut Self::Target {
28551 &mut self.inner
28552 }
28553}
28554impl<'a> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
28555 pub fn max_vertex_attrib_divisor(mut self, max_vertex_attrib_divisor: u32) -> Self {
28556 self.inner.max_vertex_attrib_divisor = max_vertex_attrib_divisor;
28557 self
28558 }
28559 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28560 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28561 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28562 pub fn build(self) -> PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
28563 self.inner
28564 }
28565}
28566#[repr(C)]
28567#[cfg_attr(feature = "debug", derive(Debug))]
28568#[derive(Copy, Clone)]
28569#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePCIBusInfoPropertiesEXT.html>"]
28570pub struct PhysicalDevicePCIBusInfoPropertiesEXT {
28571 pub s_type: StructureType,
28572 pub p_next: *mut c_void,
28573 pub pci_domain: u32,
28574 pub pci_bus: u32,
28575 pub pci_device: u32,
28576 pub pci_function: u32,
28577}
28578impl ::std::default::Default for PhysicalDevicePCIBusInfoPropertiesEXT {
28579 fn default() -> Self {
28580 Self {
28581 s_type: StructureType::PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT,
28582 p_next: ::std::ptr::null_mut(),
28583 pci_domain: u32::default(),
28584 pci_bus: u32::default(),
28585 pci_device: u32::default(),
28586 pci_function: u32::default(),
28587 }
28588 }
28589}
28590impl PhysicalDevicePCIBusInfoPropertiesEXT {
28591 pub fn builder<'a>() -> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
28592 PhysicalDevicePCIBusInfoPropertiesEXTBuilder {
28593 inner: Self::default(),
28594 marker: ::std::marker::PhantomData,
28595 }
28596 }
28597}
28598#[repr(transparent)]
28599pub struct PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
28600 inner: PhysicalDevicePCIBusInfoPropertiesEXT,
28601 marker: ::std::marker::PhantomData<&'a ()>,
28602}
28603unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'_> {}
28604unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePCIBusInfoPropertiesEXT {}
28605impl<'a> ::std::ops::Deref for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
28606 type Target = PhysicalDevicePCIBusInfoPropertiesEXT;
28607 fn deref(&self) -> &Self::Target {
28608 &self.inner
28609 }
28610}
28611impl<'a> ::std::ops::DerefMut for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
28612 fn deref_mut(&mut self) -> &mut Self::Target {
28613 &mut self.inner
28614 }
28615}
28616impl<'a> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
28617 pub fn pci_domain(mut self, pci_domain: u32) -> Self {
28618 self.inner.pci_domain = pci_domain;
28619 self
28620 }
28621 pub fn pci_bus(mut self, pci_bus: u32) -> Self {
28622 self.inner.pci_bus = pci_bus;
28623 self
28624 }
28625 pub fn pci_device(mut self, pci_device: u32) -> Self {
28626 self.inner.pci_device = pci_device;
28627 self
28628 }
28629 pub fn pci_function(mut self, pci_function: u32) -> Self {
28630 self.inner.pci_function = pci_function;
28631 self
28632 }
28633 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28634 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28635 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28636 pub fn build(self) -> PhysicalDevicePCIBusInfoPropertiesEXT {
28637 self.inner
28638 }
28639}
28640#[repr(C)]
28641#[cfg_attr(feature = "debug", derive(Debug))]
28642#[derive(Copy, Clone)]
28643#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportAndroidHardwareBufferInfoANDROID.html>"]
28644pub struct ImportAndroidHardwareBufferInfoANDROID {
28645 pub s_type: StructureType,
28646 pub p_next: *const c_void,
28647 pub buffer: *mut AHardwareBuffer,
28648}
28649impl ::std::default::Default for ImportAndroidHardwareBufferInfoANDROID {
28650 fn default() -> Self {
28651 Self {
28652 s_type: StructureType::IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
28653 p_next: ::std::ptr::null(),
28654 buffer: ::std::ptr::null_mut(),
28655 }
28656 }
28657}
28658impl ImportAndroidHardwareBufferInfoANDROID {
28659 pub fn builder<'a>() -> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
28660 ImportAndroidHardwareBufferInfoANDROIDBuilder {
28661 inner: Self::default(),
28662 marker: ::std::marker::PhantomData,
28663 }
28664 }
28665}
28666#[repr(transparent)]
28667pub struct ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
28668 inner: ImportAndroidHardwareBufferInfoANDROID,
28669 marker: ::std::marker::PhantomData<&'a ()>,
28670}
28671unsafe impl ExtendsMemoryAllocateInfo for ImportAndroidHardwareBufferInfoANDROIDBuilder<'_> {}
28672unsafe impl ExtendsMemoryAllocateInfo for ImportAndroidHardwareBufferInfoANDROID {}
28673impl<'a> ::std::ops::Deref for ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
28674 type Target = ImportAndroidHardwareBufferInfoANDROID;
28675 fn deref(&self) -> &Self::Target {
28676 &self.inner
28677 }
28678}
28679impl<'a> ::std::ops::DerefMut for ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
28680 fn deref_mut(&mut self) -> &mut Self::Target {
28681 &mut self.inner
28682 }
28683}
28684impl<'a> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
28685 pub fn buffer(mut self, buffer: *mut AHardwareBuffer) -> Self {
28686 self.inner.buffer = buffer;
28687 self
28688 }
28689 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28690 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28691 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28692 pub fn build(self) -> ImportAndroidHardwareBufferInfoANDROID {
28693 self.inner
28694 }
28695}
28696#[repr(C)]
28697#[cfg_attr(feature = "debug", derive(Debug))]
28698#[derive(Copy, Clone)]
28699#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAndroidHardwareBufferUsageANDROID.html>"]
28700pub struct AndroidHardwareBufferUsageANDROID {
28701 pub s_type: StructureType,
28702 pub p_next: *mut c_void,
28703 pub android_hardware_buffer_usage: u64,
28704}
28705impl ::std::default::Default for AndroidHardwareBufferUsageANDROID {
28706 fn default() -> Self {
28707 Self {
28708 s_type: StructureType::ANDROID_HARDWARE_BUFFER_USAGE_ANDROID,
28709 p_next: ::std::ptr::null_mut(),
28710 android_hardware_buffer_usage: u64::default(),
28711 }
28712 }
28713}
28714impl AndroidHardwareBufferUsageANDROID {
28715 pub fn builder<'a>() -> AndroidHardwareBufferUsageANDROIDBuilder<'a> {
28716 AndroidHardwareBufferUsageANDROIDBuilder {
28717 inner: Self::default(),
28718 marker: ::std::marker::PhantomData,
28719 }
28720 }
28721}
28722#[repr(transparent)]
28723pub struct AndroidHardwareBufferUsageANDROIDBuilder<'a> {
28724 inner: AndroidHardwareBufferUsageANDROID,
28725 marker: ::std::marker::PhantomData<&'a ()>,
28726}
28727unsafe impl ExtendsImageFormatProperties2 for AndroidHardwareBufferUsageANDROIDBuilder<'_> {}
28728unsafe impl ExtendsImageFormatProperties2 for AndroidHardwareBufferUsageANDROID {}
28729impl<'a> ::std::ops::Deref for AndroidHardwareBufferUsageANDROIDBuilder<'a> {
28730 type Target = AndroidHardwareBufferUsageANDROID;
28731 fn deref(&self) -> &Self::Target {
28732 &self.inner
28733 }
28734}
28735impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferUsageANDROIDBuilder<'a> {
28736 fn deref_mut(&mut self) -> &mut Self::Target {
28737 &mut self.inner
28738 }
28739}
28740impl<'a> AndroidHardwareBufferUsageANDROIDBuilder<'a> {
28741 pub fn android_hardware_buffer_usage(mut self, android_hardware_buffer_usage: u64) -> Self {
28742 self.inner.android_hardware_buffer_usage = android_hardware_buffer_usage;
28743 self
28744 }
28745 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28746 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28747 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28748 pub fn build(self) -> AndroidHardwareBufferUsageANDROID {
28749 self.inner
28750 }
28751}
28752#[repr(C)]
28753#[cfg_attr(feature = "debug", derive(Debug))]
28754#[derive(Copy, Clone)]
28755#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAndroidHardwareBufferPropertiesANDROID.html>"]
28756pub struct AndroidHardwareBufferPropertiesANDROID {
28757 pub s_type: StructureType,
28758 pub p_next: *mut c_void,
28759 pub allocation_size: DeviceSize,
28760 pub memory_type_bits: u32,
28761}
28762impl ::std::default::Default for AndroidHardwareBufferPropertiesANDROID {
28763 fn default() -> Self {
28764 Self {
28765 s_type: StructureType::ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID,
28766 p_next: ::std::ptr::null_mut(),
28767 allocation_size: DeviceSize::default(),
28768 memory_type_bits: u32::default(),
28769 }
28770 }
28771}
28772impl AndroidHardwareBufferPropertiesANDROID {
28773 pub fn builder<'a>() -> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
28774 AndroidHardwareBufferPropertiesANDROIDBuilder {
28775 inner: Self::default(),
28776 marker: ::std::marker::PhantomData,
28777 }
28778 }
28779}
28780#[repr(transparent)]
28781pub struct AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
28782 inner: AndroidHardwareBufferPropertiesANDROID,
28783 marker: ::std::marker::PhantomData<&'a ()>,
28784}
28785pub unsafe trait ExtendsAndroidHardwareBufferPropertiesANDROID {}
28786impl<'a> ::std::ops::Deref for AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
28787 type Target = AndroidHardwareBufferPropertiesANDROID;
28788 fn deref(&self) -> &Self::Target {
28789 &self.inner
28790 }
28791}
28792impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
28793 fn deref_mut(&mut self) -> &mut Self::Target {
28794 &mut self.inner
28795 }
28796}
28797impl<'a> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
28798 pub fn allocation_size(mut self, allocation_size: DeviceSize) -> Self {
28799 self.inner.allocation_size = allocation_size;
28800 self
28801 }
28802 pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self {
28803 self.inner.memory_type_bits = memory_type_bits;
28804 self
28805 }
28806 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
28807 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
28808 #[doc = r" valid extension structs can be pushed into the chain."]
28809 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
28810 #[doc = r" chain will look like `A -> D -> B -> C`."]
28811 pub fn push_next<T: ExtendsAndroidHardwareBufferPropertiesANDROID>(
28812 mut self,
28813 next: &'a mut T,
28814 ) -> Self {
28815 unsafe {
28816 let next_ptr = <*mut T>::cast(next);
28817 let last_next = ptr_chain_iter(next).last().unwrap();
28818 (*last_next).p_next = self.inner.p_next as _;
28819 self.inner.p_next = next_ptr;
28820 }
28821 self
28822 }
28823 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28824 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28825 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28826 pub fn build(self) -> AndroidHardwareBufferPropertiesANDROID {
28827 self.inner
28828 }
28829}
28830#[repr(C)]
28831#[cfg_attr(feature = "debug", derive(Debug))]
28832#[derive(Copy, Clone)]
28833#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryGetAndroidHardwareBufferInfoANDROID.html>"]
28834pub struct MemoryGetAndroidHardwareBufferInfoANDROID {
28835 pub s_type: StructureType,
28836 pub p_next: *const c_void,
28837 pub memory: DeviceMemory,
28838}
28839impl ::std::default::Default for MemoryGetAndroidHardwareBufferInfoANDROID {
28840 fn default() -> Self {
28841 Self {
28842 s_type: StructureType::MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
28843 p_next: ::std::ptr::null(),
28844 memory: DeviceMemory::default(),
28845 }
28846 }
28847}
28848impl MemoryGetAndroidHardwareBufferInfoANDROID {
28849 pub fn builder<'a>() -> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
28850 MemoryGetAndroidHardwareBufferInfoANDROIDBuilder {
28851 inner: Self::default(),
28852 marker: ::std::marker::PhantomData,
28853 }
28854 }
28855}
28856#[repr(transparent)]
28857pub struct MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
28858 inner: MemoryGetAndroidHardwareBufferInfoANDROID,
28859 marker: ::std::marker::PhantomData<&'a ()>,
28860}
28861impl<'a> ::std::ops::Deref for MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
28862 type Target = MemoryGetAndroidHardwareBufferInfoANDROID;
28863 fn deref(&self) -> &Self::Target {
28864 &self.inner
28865 }
28866}
28867impl<'a> ::std::ops::DerefMut for MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
28868 fn deref_mut(&mut self) -> &mut Self::Target {
28869 &mut self.inner
28870 }
28871}
28872impl<'a> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
28873 pub fn memory(mut self, memory: DeviceMemory) -> Self {
28874 self.inner.memory = memory;
28875 self
28876 }
28877 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28878 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28879 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28880 pub fn build(self) -> MemoryGetAndroidHardwareBufferInfoANDROID {
28881 self.inner
28882 }
28883}
28884#[repr(C)]
28885#[cfg_attr(feature = "debug", derive(Debug))]
28886#[derive(Copy, Clone)]
28887#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAndroidHardwareBufferFormatPropertiesANDROID.html>"]
28888pub struct AndroidHardwareBufferFormatPropertiesANDROID {
28889 pub s_type: StructureType,
28890 pub p_next: *mut c_void,
28891 pub format: Format,
28892 pub external_format: u64,
28893 pub format_features: FormatFeatureFlags,
28894 pub sampler_ycbcr_conversion_components: ComponentMapping,
28895 pub suggested_ycbcr_model: SamplerYcbcrModelConversion,
28896 pub suggested_ycbcr_range: SamplerYcbcrRange,
28897 pub suggested_x_chroma_offset: ChromaLocation,
28898 pub suggested_y_chroma_offset: ChromaLocation,
28899}
28900impl ::std::default::Default for AndroidHardwareBufferFormatPropertiesANDROID {
28901 fn default() -> Self {
28902 Self {
28903 s_type: StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID,
28904 p_next: ::std::ptr::null_mut(),
28905 format: Format::default(),
28906 external_format: u64::default(),
28907 format_features: FormatFeatureFlags::default(),
28908 sampler_ycbcr_conversion_components: ComponentMapping::default(),
28909 suggested_ycbcr_model: SamplerYcbcrModelConversion::default(),
28910 suggested_ycbcr_range: SamplerYcbcrRange::default(),
28911 suggested_x_chroma_offset: ChromaLocation::default(),
28912 suggested_y_chroma_offset: ChromaLocation::default(),
28913 }
28914 }
28915}
28916impl AndroidHardwareBufferFormatPropertiesANDROID {
28917 pub fn builder<'a>() -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
28918 AndroidHardwareBufferFormatPropertiesANDROIDBuilder {
28919 inner: Self::default(),
28920 marker: ::std::marker::PhantomData,
28921 }
28922 }
28923}
28924#[repr(transparent)]
28925pub struct AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
28926 inner: AndroidHardwareBufferFormatPropertiesANDROID,
28927 marker: ::std::marker::PhantomData<&'a ()>,
28928}
28929unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID
28930 for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'_>
28931{
28932}
28933unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID
28934 for AndroidHardwareBufferFormatPropertiesANDROID
28935{
28936}
28937impl<'a> ::std::ops::Deref for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
28938 type Target = AndroidHardwareBufferFormatPropertiesANDROID;
28939 fn deref(&self) -> &Self::Target {
28940 &self.inner
28941 }
28942}
28943impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
28944 fn deref_mut(&mut self) -> &mut Self::Target {
28945 &mut self.inner
28946 }
28947}
28948impl<'a> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
28949 pub fn format(mut self, format: Format) -> Self {
28950 self.inner.format = format;
28951 self
28952 }
28953 pub fn external_format(mut self, external_format: u64) -> Self {
28954 self.inner.external_format = external_format;
28955 self
28956 }
28957 pub fn format_features(mut self, format_features: FormatFeatureFlags) -> Self {
28958 self.inner.format_features = format_features;
28959 self
28960 }
28961 pub fn sampler_ycbcr_conversion_components(
28962 mut self,
28963 sampler_ycbcr_conversion_components: ComponentMapping,
28964 ) -> Self {
28965 self.inner.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components;
28966 self
28967 }
28968 pub fn suggested_ycbcr_model(
28969 mut self,
28970 suggested_ycbcr_model: SamplerYcbcrModelConversion,
28971 ) -> Self {
28972 self.inner.suggested_ycbcr_model = suggested_ycbcr_model;
28973 self
28974 }
28975 pub fn suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self {
28976 self.inner.suggested_ycbcr_range = suggested_ycbcr_range;
28977 self
28978 }
28979 pub fn suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self {
28980 self.inner.suggested_x_chroma_offset = suggested_x_chroma_offset;
28981 self
28982 }
28983 pub fn suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self {
28984 self.inner.suggested_y_chroma_offset = suggested_y_chroma_offset;
28985 self
28986 }
28987 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28988 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28989 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28990 pub fn build(self) -> AndroidHardwareBufferFormatPropertiesANDROID {
28991 self.inner
28992 }
28993}
28994#[repr(C)]
28995#[cfg_attr(feature = "debug", derive(Debug))]
28996#[derive(Copy, Clone)]
28997#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferInheritanceConditionalRenderingInfoEXT.html>"]
28998pub struct CommandBufferInheritanceConditionalRenderingInfoEXT {
28999 pub s_type: StructureType,
29000 pub p_next: *const c_void,
29001 pub conditional_rendering_enable: Bool32,
29002}
29003impl ::std::default::Default for CommandBufferInheritanceConditionalRenderingInfoEXT {
29004 fn default() -> Self {
29005 Self {
29006 s_type: StructureType::COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT,
29007 p_next: ::std::ptr::null(),
29008 conditional_rendering_enable: Bool32::default(),
29009 }
29010 }
29011}
29012impl CommandBufferInheritanceConditionalRenderingInfoEXT {
29013 pub fn builder<'a>() -> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
29014 CommandBufferInheritanceConditionalRenderingInfoEXTBuilder {
29015 inner: Self::default(),
29016 marker: ::std::marker::PhantomData,
29017 }
29018 }
29019}
29020#[repr(transparent)]
29021pub struct CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
29022 inner: CommandBufferInheritanceConditionalRenderingInfoEXT,
29023 marker: ::std::marker::PhantomData<&'a ()>,
29024}
29025unsafe impl ExtendsCommandBufferInheritanceInfo
29026 for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'_>
29027{
29028}
29029unsafe impl ExtendsCommandBufferInheritanceInfo
29030 for CommandBufferInheritanceConditionalRenderingInfoEXT
29031{
29032}
29033impl<'a> ::std::ops::Deref for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
29034 type Target = CommandBufferInheritanceConditionalRenderingInfoEXT;
29035 fn deref(&self) -> &Self::Target {
29036 &self.inner
29037 }
29038}
29039impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
29040 fn deref_mut(&mut self) -> &mut Self::Target {
29041 &mut self.inner
29042 }
29043}
29044impl<'a> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
29045 pub fn conditional_rendering_enable(mut self, conditional_rendering_enable: bool) -> Self {
29046 self.inner.conditional_rendering_enable = conditional_rendering_enable.into();
29047 self
29048 }
29049 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29050 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29051 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
29052 pub fn build(self) -> CommandBufferInheritanceConditionalRenderingInfoEXT {
29053 self.inner
29054 }
29055}
29056#[repr(C)]
29057#[cfg_attr(feature = "debug", derive(Debug))]
29058#[derive(Copy, Clone)]
29059#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalFormatANDROID.html>"]
29060pub struct ExternalFormatANDROID {
29061 pub s_type: StructureType,
29062 pub p_next: *mut c_void,
29063 pub external_format: u64,
29064}
29065impl ::std::default::Default for ExternalFormatANDROID {
29066 fn default() -> Self {
29067 Self {
29068 s_type: StructureType::EXTERNAL_FORMAT_ANDROID,
29069 p_next: ::std::ptr::null_mut(),
29070 external_format: u64::default(),
29071 }
29072 }
29073}
29074impl ExternalFormatANDROID {
29075 pub fn builder<'a>() -> ExternalFormatANDROIDBuilder<'a> {
29076 ExternalFormatANDROIDBuilder {
29077 inner: Self::default(),
29078 marker: ::std::marker::PhantomData,
29079 }
29080 }
29081}
29082#[repr(transparent)]
29083pub struct ExternalFormatANDROIDBuilder<'a> {
29084 inner: ExternalFormatANDROID,
29085 marker: ::std::marker::PhantomData<&'a ()>,
29086}
29087unsafe impl ExtendsImageCreateInfo for ExternalFormatANDROIDBuilder<'_> {}
29088unsafe impl ExtendsImageCreateInfo for ExternalFormatANDROID {}
29089unsafe impl ExtendsSamplerYcbcrConversionCreateInfo for ExternalFormatANDROIDBuilder<'_> {}
29090unsafe impl ExtendsSamplerYcbcrConversionCreateInfo for ExternalFormatANDROID {}
29091impl<'a> ::std::ops::Deref for ExternalFormatANDROIDBuilder<'a> {
29092 type Target = ExternalFormatANDROID;
29093 fn deref(&self) -> &Self::Target {
29094 &self.inner
29095 }
29096}
29097impl<'a> ::std::ops::DerefMut for ExternalFormatANDROIDBuilder<'a> {
29098 fn deref_mut(&mut self) -> &mut Self::Target {
29099 &mut self.inner
29100 }
29101}
29102impl<'a> ExternalFormatANDROIDBuilder<'a> {
29103 pub fn external_format(mut self, external_format: u64) -> Self {
29104 self.inner.external_format = external_format;
29105 self
29106 }
29107 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29108 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29109 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
29110 pub fn build(self) -> ExternalFormatANDROID {
29111 self.inner
29112 }
29113}
29114#[repr(C)]
29115#[cfg_attr(feature = "debug", derive(Debug))]
29116#[derive(Copy, Clone)]
29117#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevice8BitStorageFeatures.html>"]
29118pub struct PhysicalDevice8BitStorageFeatures {
29119 pub s_type: StructureType,
29120 pub p_next: *mut c_void,
29121 pub storage_buffer8_bit_access: Bool32,
29122 pub uniform_and_storage_buffer8_bit_access: Bool32,
29123 pub storage_push_constant8: Bool32,
29124}
29125impl ::std::default::Default for PhysicalDevice8BitStorageFeatures {
29126 fn default() -> Self {
29127 Self {
29128 s_type: StructureType::PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES,
29129 p_next: ::std::ptr::null_mut(),
29130 storage_buffer8_bit_access: Bool32::default(),
29131 uniform_and_storage_buffer8_bit_access: Bool32::default(),
29132 storage_push_constant8: Bool32::default(),
29133 }
29134 }
29135}
29136impl PhysicalDevice8BitStorageFeatures {
29137 pub fn builder<'a>() -> PhysicalDevice8BitStorageFeaturesBuilder<'a> {
29138 PhysicalDevice8BitStorageFeaturesBuilder {
29139 inner: Self::default(),
29140 marker: ::std::marker::PhantomData,
29141 }
29142 }
29143}
29144#[repr(transparent)]
29145pub struct PhysicalDevice8BitStorageFeaturesBuilder<'a> {
29146 inner: PhysicalDevice8BitStorageFeatures,
29147 marker: ::std::marker::PhantomData<&'a ()>,
29148}
29149unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice8BitStorageFeaturesBuilder<'_> {}
29150unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice8BitStorageFeatures {}
29151unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice8BitStorageFeaturesBuilder<'_> {}
29152unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice8BitStorageFeatures {}
29153impl<'a> ::std::ops::Deref for PhysicalDevice8BitStorageFeaturesBuilder<'a> {
29154 type Target = PhysicalDevice8BitStorageFeatures;
29155 fn deref(&self) -> &Self::Target {
29156 &self.inner
29157 }
29158}
29159impl<'a> ::std::ops::DerefMut for PhysicalDevice8BitStorageFeaturesBuilder<'a> {
29160 fn deref_mut(&mut self) -> &mut Self::Target {
29161 &mut self.inner
29162 }
29163}
29164impl<'a> PhysicalDevice8BitStorageFeaturesBuilder<'a> {
29165 pub fn storage_buffer8_bit_access(mut self, storage_buffer8_bit_access: bool) -> Self {
29166 self.inner.storage_buffer8_bit_access = storage_buffer8_bit_access.into();
29167 self
29168 }
29169 pub fn uniform_and_storage_buffer8_bit_access(
29170 mut self,
29171 uniform_and_storage_buffer8_bit_access: bool,
29172 ) -> Self {
29173 self.inner.uniform_and_storage_buffer8_bit_access =
29174 uniform_and_storage_buffer8_bit_access.into();
29175 self
29176 }
29177 pub fn storage_push_constant8(mut self, storage_push_constant8: bool) -> Self {
29178 self.inner.storage_push_constant8 = storage_push_constant8.into();
29179 self
29180 }
29181 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29182 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29183 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
29184 pub fn build(self) -> PhysicalDevice8BitStorageFeatures {
29185 self.inner
29186 }
29187}
29188#[repr(C)]
29189#[cfg_attr(feature = "debug", derive(Debug))]
29190#[derive(Copy, Clone)]
29191#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceConditionalRenderingFeaturesEXT.html>"]
29192pub struct PhysicalDeviceConditionalRenderingFeaturesEXT {
29193 pub s_type: StructureType,
29194 pub p_next: *mut c_void,
29195 pub conditional_rendering: Bool32,
29196 pub inherited_conditional_rendering: Bool32,
29197}
29198impl ::std::default::Default for PhysicalDeviceConditionalRenderingFeaturesEXT {
29199 fn default() -> Self {
29200 Self {
29201 s_type: StructureType::PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT,
29202 p_next: ::std::ptr::null_mut(),
29203 conditional_rendering: Bool32::default(),
29204 inherited_conditional_rendering: Bool32::default(),
29205 }
29206 }
29207}
29208impl PhysicalDeviceConditionalRenderingFeaturesEXT {
29209 pub fn builder<'a>() -> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
29210 PhysicalDeviceConditionalRenderingFeaturesEXTBuilder {
29211 inner: Self::default(),
29212 marker: ::std::marker::PhantomData,
29213 }
29214 }
29215}
29216#[repr(transparent)]
29217pub struct PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
29218 inner: PhysicalDeviceConditionalRenderingFeaturesEXT,
29219 marker: ::std::marker::PhantomData<&'a ()>,
29220}
29221unsafe impl ExtendsPhysicalDeviceFeatures2
29222 for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'_>
29223{
29224}
29225unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceConditionalRenderingFeaturesEXT {}
29226unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'_> {}
29227unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceConditionalRenderingFeaturesEXT {}
29228impl<'a> ::std::ops::Deref for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
29229 type Target = PhysicalDeviceConditionalRenderingFeaturesEXT;
29230 fn deref(&self) -> &Self::Target {
29231 &self.inner
29232 }
29233}
29234impl<'a> ::std::ops::DerefMut for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
29235 fn deref_mut(&mut self) -> &mut Self::Target {
29236 &mut self.inner
29237 }
29238}
29239impl<'a> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
29240 pub fn conditional_rendering(mut self, conditional_rendering: bool) -> Self {
29241 self.inner.conditional_rendering = conditional_rendering.into();
29242 self
29243 }
29244 pub fn inherited_conditional_rendering(
29245 mut self,
29246 inherited_conditional_rendering: bool,
29247 ) -> Self {
29248 self.inner.inherited_conditional_rendering = inherited_conditional_rendering.into();
29249 self
29250 }
29251 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29252 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29253 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
29254 pub fn build(self) -> PhysicalDeviceConditionalRenderingFeaturesEXT {
29255 self.inner
29256 }
29257}
29258#[repr(C)]
29259#[cfg_attr(feature = "debug", derive(Debug))]
29260#[derive(Copy, Clone)]
29261#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkanMemoryModelFeatures.html>"]
29262pub struct PhysicalDeviceVulkanMemoryModelFeatures {
29263 pub s_type: StructureType,
29264 pub p_next: *mut c_void,
29265 pub vulkan_memory_model: Bool32,
29266 pub vulkan_memory_model_device_scope: Bool32,
29267 pub vulkan_memory_model_availability_visibility_chains: Bool32,
29268}
29269impl ::std::default::Default for PhysicalDeviceVulkanMemoryModelFeatures {
29270 fn default() -> Self {
29271 Self {
29272 s_type: StructureType::PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES,
29273 p_next: ::std::ptr::null_mut(),
29274 vulkan_memory_model: Bool32::default(),
29275 vulkan_memory_model_device_scope: Bool32::default(),
29276 vulkan_memory_model_availability_visibility_chains: Bool32::default(),
29277 }
29278 }
29279}
29280impl PhysicalDeviceVulkanMemoryModelFeatures {
29281 pub fn builder<'a>() -> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
29282 PhysicalDeviceVulkanMemoryModelFeaturesBuilder {
29283 inner: Self::default(),
29284 marker: ::std::marker::PhantomData,
29285 }
29286 }
29287}
29288#[repr(transparent)]
29289pub struct PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
29290 inner: PhysicalDeviceVulkanMemoryModelFeatures,
29291 marker: ::std::marker::PhantomData<&'a ()>,
29292}
29293unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'_> {}
29294unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkanMemoryModelFeatures {}
29295unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'_> {}
29296unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkanMemoryModelFeatures {}
29297impl<'a> ::std::ops::Deref for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
29298 type Target = PhysicalDeviceVulkanMemoryModelFeatures;
29299 fn deref(&self) -> &Self::Target {
29300 &self.inner
29301 }
29302}
29303impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
29304 fn deref_mut(&mut self) -> &mut Self::Target {
29305 &mut self.inner
29306 }
29307}
29308impl<'a> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
29309 pub fn vulkan_memory_model(mut self, vulkan_memory_model: bool) -> Self {
29310 self.inner.vulkan_memory_model = vulkan_memory_model.into();
29311 self
29312 }
29313 pub fn vulkan_memory_model_device_scope(
29314 mut self,
29315 vulkan_memory_model_device_scope: bool,
29316 ) -> Self {
29317 self.inner.vulkan_memory_model_device_scope = vulkan_memory_model_device_scope.into();
29318 self
29319 }
29320 pub fn vulkan_memory_model_availability_visibility_chains(
29321 mut self,
29322 vulkan_memory_model_availability_visibility_chains: bool,
29323 ) -> Self {
29324 self.inner
29325 .vulkan_memory_model_availability_visibility_chains =
29326 vulkan_memory_model_availability_visibility_chains.into();
29327 self
29328 }
29329 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29330 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29331 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
29332 pub fn build(self) -> PhysicalDeviceVulkanMemoryModelFeatures {
29333 self.inner
29334 }
29335}
29336#[repr(C)]
29337#[cfg_attr(feature = "debug", derive(Debug))]
29338#[derive(Copy, Clone)]
29339#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderAtomicInt64Features.html>"]
29340pub struct PhysicalDeviceShaderAtomicInt64Features {
29341 pub s_type: StructureType,
29342 pub p_next: *mut c_void,
29343 pub shader_buffer_int64_atomics: Bool32,
29344 pub shader_shared_int64_atomics: Bool32,
29345}
29346impl ::std::default::Default for PhysicalDeviceShaderAtomicInt64Features {
29347 fn default() -> Self {
29348 Self {
29349 s_type: StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES,
29350 p_next: ::std::ptr::null_mut(),
29351 shader_buffer_int64_atomics: Bool32::default(),
29352 shader_shared_int64_atomics: Bool32::default(),
29353 }
29354 }
29355}
29356impl PhysicalDeviceShaderAtomicInt64Features {
29357 pub fn builder<'a>() -> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
29358 PhysicalDeviceShaderAtomicInt64FeaturesBuilder {
29359 inner: Self::default(),
29360 marker: ::std::marker::PhantomData,
29361 }
29362 }
29363}
29364#[repr(transparent)]
29365pub struct PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
29366 inner: PhysicalDeviceShaderAtomicInt64Features,
29367 marker: ::std::marker::PhantomData<&'a ()>,
29368}
29369unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'_> {}
29370unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicInt64Features {}
29371unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'_> {}
29372unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicInt64Features {}
29373impl<'a> ::std::ops::Deref for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
29374 type Target = PhysicalDeviceShaderAtomicInt64Features;
29375 fn deref(&self) -> &Self::Target {
29376 &self.inner
29377 }
29378}
29379impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
29380 fn deref_mut(&mut self) -> &mut Self::Target {
29381 &mut self.inner
29382 }
29383}
29384impl<'a> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
29385 pub fn shader_buffer_int64_atomics(mut self, shader_buffer_int64_atomics: bool) -> Self {
29386 self.inner.shader_buffer_int64_atomics = shader_buffer_int64_atomics.into();
29387 self
29388 }
29389 pub fn shader_shared_int64_atomics(mut self, shader_shared_int64_atomics: bool) -> Self {
29390 self.inner.shader_shared_int64_atomics = shader_shared_int64_atomics.into();
29391 self
29392 }
29393 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29394 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29395 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
29396 pub fn build(self) -> PhysicalDeviceShaderAtomicInt64Features {
29397 self.inner
29398 }
29399}
29400#[repr(C)]
29401#[cfg_attr(feature = "debug", derive(Debug))]
29402#[derive(Copy, Clone)]
29403#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.html>"]
29404pub struct PhysicalDeviceShaderAtomicFloatFeaturesEXT {
29405 pub s_type: StructureType,
29406 pub p_next: *mut c_void,
29407 pub shader_buffer_float32_atomics: Bool32,
29408 pub shader_buffer_float32_atomic_add: Bool32,
29409 pub shader_buffer_float64_atomics: Bool32,
29410 pub shader_buffer_float64_atomic_add: Bool32,
29411 pub shader_shared_float32_atomics: Bool32,
29412 pub shader_shared_float32_atomic_add: Bool32,
29413 pub shader_shared_float64_atomics: Bool32,
29414 pub shader_shared_float64_atomic_add: Bool32,
29415 pub shader_image_float32_atomics: Bool32,
29416 pub shader_image_float32_atomic_add: Bool32,
29417 pub sparse_image_float32_atomics: Bool32,
29418 pub sparse_image_float32_atomic_add: Bool32,
29419}
29420impl ::std::default::Default for PhysicalDeviceShaderAtomicFloatFeaturesEXT {
29421 fn default() -> Self {
29422 Self {
29423 s_type: StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT,
29424 p_next: ::std::ptr::null_mut(),
29425 shader_buffer_float32_atomics: Bool32::default(),
29426 shader_buffer_float32_atomic_add: Bool32::default(),
29427 shader_buffer_float64_atomics: Bool32::default(),
29428 shader_buffer_float64_atomic_add: Bool32::default(),
29429 shader_shared_float32_atomics: Bool32::default(),
29430 shader_shared_float32_atomic_add: Bool32::default(),
29431 shader_shared_float64_atomics: Bool32::default(),
29432 shader_shared_float64_atomic_add: Bool32::default(),
29433 shader_image_float32_atomics: Bool32::default(),
29434 shader_image_float32_atomic_add: Bool32::default(),
29435 sparse_image_float32_atomics: Bool32::default(),
29436 sparse_image_float32_atomic_add: Bool32::default(),
29437 }
29438 }
29439}
29440impl PhysicalDeviceShaderAtomicFloatFeaturesEXT {
29441 pub fn builder<'a>() -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
29442 PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder {
29443 inner: Self::default(),
29444 marker: ::std::marker::PhantomData,
29445 }
29446 }
29447}
29448#[repr(transparent)]
29449pub struct PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
29450 inner: PhysicalDeviceShaderAtomicFloatFeaturesEXT,
29451 marker: ::std::marker::PhantomData<&'a ()>,
29452}
29453unsafe impl ExtendsPhysicalDeviceFeatures2
29454 for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'_>
29455{
29456}
29457unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicFloatFeaturesEXT {}
29458unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'_> {}
29459unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloatFeaturesEXT {}
29460impl<'a> ::std::ops::Deref for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
29461 type Target = PhysicalDeviceShaderAtomicFloatFeaturesEXT;
29462 fn deref(&self) -> &Self::Target {
29463 &self.inner
29464 }
29465}
29466impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
29467 fn deref_mut(&mut self) -> &mut Self::Target {
29468 &mut self.inner
29469 }
29470}
29471impl<'a> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
29472 pub fn shader_buffer_float32_atomics(mut self, shader_buffer_float32_atomics: bool) -> Self {
29473 self.inner.shader_buffer_float32_atomics = shader_buffer_float32_atomics.into();
29474 self
29475 }
29476 pub fn shader_buffer_float32_atomic_add(
29477 mut self,
29478 shader_buffer_float32_atomic_add: bool,
29479 ) -> Self {
29480 self.inner.shader_buffer_float32_atomic_add = shader_buffer_float32_atomic_add.into();
29481 self
29482 }
29483 pub fn shader_buffer_float64_atomics(mut self, shader_buffer_float64_atomics: bool) -> Self {
29484 self.inner.shader_buffer_float64_atomics = shader_buffer_float64_atomics.into();
29485 self
29486 }
29487 pub fn shader_buffer_float64_atomic_add(
29488 mut self,
29489 shader_buffer_float64_atomic_add: bool,
29490 ) -> Self {
29491 self.inner.shader_buffer_float64_atomic_add = shader_buffer_float64_atomic_add.into();
29492 self
29493 }
29494 pub fn shader_shared_float32_atomics(mut self, shader_shared_float32_atomics: bool) -> Self {
29495 self.inner.shader_shared_float32_atomics = shader_shared_float32_atomics.into();
29496 self
29497 }
29498 pub fn shader_shared_float32_atomic_add(
29499 mut self,
29500 shader_shared_float32_atomic_add: bool,
29501 ) -> Self {
29502 self.inner.shader_shared_float32_atomic_add = shader_shared_float32_atomic_add.into();
29503 self
29504 }
29505 pub fn shader_shared_float64_atomics(mut self, shader_shared_float64_atomics: bool) -> Self {
29506 self.inner.shader_shared_float64_atomics = shader_shared_float64_atomics.into();
29507 self
29508 }
29509 pub fn shader_shared_float64_atomic_add(
29510 mut self,
29511 shader_shared_float64_atomic_add: bool,
29512 ) -> Self {
29513 self.inner.shader_shared_float64_atomic_add = shader_shared_float64_atomic_add.into();
29514 self
29515 }
29516 pub fn shader_image_float32_atomics(mut self, shader_image_float32_atomics: bool) -> Self {
29517 self.inner.shader_image_float32_atomics = shader_image_float32_atomics.into();
29518 self
29519 }
29520 pub fn shader_image_float32_atomic_add(
29521 mut self,
29522 shader_image_float32_atomic_add: bool,
29523 ) -> Self {
29524 self.inner.shader_image_float32_atomic_add = shader_image_float32_atomic_add.into();
29525 self
29526 }
29527 pub fn sparse_image_float32_atomics(mut self, sparse_image_float32_atomics: bool) -> Self {
29528 self.inner.sparse_image_float32_atomics = sparse_image_float32_atomics.into();
29529 self
29530 }
29531 pub fn sparse_image_float32_atomic_add(
29532 mut self,
29533 sparse_image_float32_atomic_add: bool,
29534 ) -> Self {
29535 self.inner.sparse_image_float32_atomic_add = sparse_image_float32_atomic_add.into();
29536 self
29537 }
29538 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29539 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29540 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
29541 pub fn build(self) -> PhysicalDeviceShaderAtomicFloatFeaturesEXT {
29542 self.inner
29543 }
29544}
29545#[repr(C)]
29546#[cfg_attr(feature = "debug", derive(Debug))]
29547#[derive(Copy, Clone)]
29548#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.html>"]
29549pub struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
29550 pub s_type: StructureType,
29551 pub p_next: *mut c_void,
29552 pub shader_buffer_float16_atomics: Bool32,
29553 pub shader_buffer_float16_atomic_add: Bool32,
29554 pub shader_buffer_float16_atomic_min_max: Bool32,
29555 pub shader_buffer_float32_atomic_min_max: Bool32,
29556 pub shader_buffer_float64_atomic_min_max: Bool32,
29557 pub shader_shared_float16_atomics: Bool32,
29558 pub shader_shared_float16_atomic_add: Bool32,
29559 pub shader_shared_float16_atomic_min_max: Bool32,
29560 pub shader_shared_float32_atomic_min_max: Bool32,
29561 pub shader_shared_float64_atomic_min_max: Bool32,
29562 pub shader_image_float32_atomic_min_max: Bool32,
29563 pub sparse_image_float32_atomic_min_max: Bool32,
29564}
29565impl ::std::default::Default for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
29566 fn default() -> Self {
29567 Self {
29568 s_type: StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT,
29569 p_next: ::std::ptr::null_mut(),
29570 shader_buffer_float16_atomics: Bool32::default(),
29571 shader_buffer_float16_atomic_add: Bool32::default(),
29572 shader_buffer_float16_atomic_min_max: Bool32::default(),
29573 shader_buffer_float32_atomic_min_max: Bool32::default(),
29574 shader_buffer_float64_atomic_min_max: Bool32::default(),
29575 shader_shared_float16_atomics: Bool32::default(),
29576 shader_shared_float16_atomic_add: Bool32::default(),
29577 shader_shared_float16_atomic_min_max: Bool32::default(),
29578 shader_shared_float32_atomic_min_max: Bool32::default(),
29579 shader_shared_float64_atomic_min_max: Bool32::default(),
29580 shader_image_float32_atomic_min_max: Bool32::default(),
29581 sparse_image_float32_atomic_min_max: Bool32::default(),
29582 }
29583 }
29584}
29585impl PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
29586 pub fn builder<'a>() -> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
29587 PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder {
29588 inner: Self::default(),
29589 marker: ::std::marker::PhantomData,
29590 }
29591 }
29592}
29593#[repr(transparent)]
29594pub struct PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
29595 inner: PhysicalDeviceShaderAtomicFloat2FeaturesEXT,
29596 marker: ::std::marker::PhantomData<&'a ()>,
29597}
29598unsafe impl ExtendsPhysicalDeviceFeatures2
29599 for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'_>
29600{
29601}
29602unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {}
29603unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'_> {}
29604unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {}
29605impl<'a> ::std::ops::Deref for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
29606 type Target = PhysicalDeviceShaderAtomicFloat2FeaturesEXT;
29607 fn deref(&self) -> &Self::Target {
29608 &self.inner
29609 }
29610}
29611impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
29612 fn deref_mut(&mut self) -> &mut Self::Target {
29613 &mut self.inner
29614 }
29615}
29616impl<'a> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
29617 pub fn shader_buffer_float16_atomics(mut self, shader_buffer_float16_atomics: bool) -> Self {
29618 self.inner.shader_buffer_float16_atomics = shader_buffer_float16_atomics.into();
29619 self
29620 }
29621 pub fn shader_buffer_float16_atomic_add(
29622 mut self,
29623 shader_buffer_float16_atomic_add: bool,
29624 ) -> Self {
29625 self.inner.shader_buffer_float16_atomic_add = shader_buffer_float16_atomic_add.into();
29626 self
29627 }
29628 pub fn shader_buffer_float16_atomic_min_max(
29629 mut self,
29630 shader_buffer_float16_atomic_min_max: bool,
29631 ) -> Self {
29632 self.inner.shader_buffer_float16_atomic_min_max =
29633 shader_buffer_float16_atomic_min_max.into();
29634 self
29635 }
29636 pub fn shader_buffer_float32_atomic_min_max(
29637 mut self,
29638 shader_buffer_float32_atomic_min_max: bool,
29639 ) -> Self {
29640 self.inner.shader_buffer_float32_atomic_min_max =
29641 shader_buffer_float32_atomic_min_max.into();
29642 self
29643 }
29644 pub fn shader_buffer_float64_atomic_min_max(
29645 mut self,
29646 shader_buffer_float64_atomic_min_max: bool,
29647 ) -> Self {
29648 self.inner.shader_buffer_float64_atomic_min_max =
29649 shader_buffer_float64_atomic_min_max.into();
29650 self
29651 }
29652 pub fn shader_shared_float16_atomics(mut self, shader_shared_float16_atomics: bool) -> Self {
29653 self.inner.shader_shared_float16_atomics = shader_shared_float16_atomics.into();
29654 self
29655 }
29656 pub fn shader_shared_float16_atomic_add(
29657 mut self,
29658 shader_shared_float16_atomic_add: bool,
29659 ) -> Self {
29660 self.inner.shader_shared_float16_atomic_add = shader_shared_float16_atomic_add.into();
29661 self
29662 }
29663 pub fn shader_shared_float16_atomic_min_max(
29664 mut self,
29665 shader_shared_float16_atomic_min_max: bool,
29666 ) -> Self {
29667 self.inner.shader_shared_float16_atomic_min_max =
29668 shader_shared_float16_atomic_min_max.into();
29669 self
29670 }
29671 pub fn shader_shared_float32_atomic_min_max(
29672 mut self,
29673 shader_shared_float32_atomic_min_max: bool,
29674 ) -> Self {
29675 self.inner.shader_shared_float32_atomic_min_max =
29676 shader_shared_float32_atomic_min_max.into();
29677 self
29678 }
29679 pub fn shader_shared_float64_atomic_min_max(
29680 mut self,
29681 shader_shared_float64_atomic_min_max: bool,
29682 ) -> Self {
29683 self.inner.shader_shared_float64_atomic_min_max =
29684 shader_shared_float64_atomic_min_max.into();
29685 self
29686 }
29687 pub fn shader_image_float32_atomic_min_max(
29688 mut self,
29689 shader_image_float32_atomic_min_max: bool,
29690 ) -> Self {
29691 self.inner.shader_image_float32_atomic_min_max = shader_image_float32_atomic_min_max.into();
29692 self
29693 }
29694 pub fn sparse_image_float32_atomic_min_max(
29695 mut self,
29696 sparse_image_float32_atomic_min_max: bool,
29697 ) -> Self {
29698 self.inner.sparse_image_float32_atomic_min_max = sparse_image_float32_atomic_min_max.into();
29699 self
29700 }
29701 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29702 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29703 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
29704 pub fn build(self) -> PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
29705 self.inner
29706 }
29707}
29708#[repr(C)]
29709#[cfg_attr(feature = "debug", derive(Debug))]
29710#[derive(Copy, Clone)]
29711#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT.html>"]
29712pub struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
29713 pub s_type: StructureType,
29714 pub p_next: *mut c_void,
29715 pub vertex_attribute_instance_rate_divisor: Bool32,
29716 pub vertex_attribute_instance_rate_zero_divisor: Bool32,
29717}
29718impl ::std::default::Default for PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
29719 fn default() -> Self {
29720 Self {
29721 s_type: StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT,
29722 p_next: ::std::ptr::null_mut(),
29723 vertex_attribute_instance_rate_divisor: Bool32::default(),
29724 vertex_attribute_instance_rate_zero_divisor: Bool32::default(),
29725 }
29726 }
29727}
29728impl PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
29729 pub fn builder<'a>() -> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
29730 PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder {
29731 inner: Self::default(),
29732 marker: ::std::marker::PhantomData,
29733 }
29734 }
29735}
29736#[repr(transparent)]
29737pub struct PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
29738 inner: PhysicalDeviceVertexAttributeDivisorFeaturesEXT,
29739 marker: ::std::marker::PhantomData<&'a ()>,
29740}
29741unsafe impl ExtendsPhysicalDeviceFeatures2
29742 for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'_>
29743{
29744}
29745unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVertexAttributeDivisorFeaturesEXT {}
29746unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'_> {}
29747unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexAttributeDivisorFeaturesEXT {}
29748impl<'a> ::std::ops::Deref for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
29749 type Target = PhysicalDeviceVertexAttributeDivisorFeaturesEXT;
29750 fn deref(&self) -> &Self::Target {
29751 &self.inner
29752 }
29753}
29754impl<'a> ::std::ops::DerefMut for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
29755 fn deref_mut(&mut self) -> &mut Self::Target {
29756 &mut self.inner
29757 }
29758}
29759impl<'a> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
29760 pub fn vertex_attribute_instance_rate_divisor(
29761 mut self,
29762 vertex_attribute_instance_rate_divisor: bool,
29763 ) -> Self {
29764 self.inner.vertex_attribute_instance_rate_divisor =
29765 vertex_attribute_instance_rate_divisor.into();
29766 self
29767 }
29768 pub fn vertex_attribute_instance_rate_zero_divisor(
29769 mut self,
29770 vertex_attribute_instance_rate_zero_divisor: bool,
29771 ) -> Self {
29772 self.inner.vertex_attribute_instance_rate_zero_divisor =
29773 vertex_attribute_instance_rate_zero_divisor.into();
29774 self
29775 }
29776 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29777 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29778 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
29779 pub fn build(self) -> PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
29780 self.inner
29781 }
29782}
29783#[repr(C)]
29784#[cfg_attr(feature = "debug", derive(Debug))]
29785#[derive(Copy, Clone)]
29786#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyCheckpointPropertiesNV.html>"]
29787pub struct QueueFamilyCheckpointPropertiesNV {
29788 pub s_type: StructureType,
29789 pub p_next: *mut c_void,
29790 pub checkpoint_execution_stage_mask: PipelineStageFlags,
29791}
29792impl ::std::default::Default for QueueFamilyCheckpointPropertiesNV {
29793 fn default() -> Self {
29794 Self {
29795 s_type: StructureType::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV,
29796 p_next: ::std::ptr::null_mut(),
29797 checkpoint_execution_stage_mask: PipelineStageFlags::default(),
29798 }
29799 }
29800}
29801impl QueueFamilyCheckpointPropertiesNV {
29802 pub fn builder<'a>() -> QueueFamilyCheckpointPropertiesNVBuilder<'a> {
29803 QueueFamilyCheckpointPropertiesNVBuilder {
29804 inner: Self::default(),
29805 marker: ::std::marker::PhantomData,
29806 }
29807 }
29808}
29809#[repr(transparent)]
29810pub struct QueueFamilyCheckpointPropertiesNVBuilder<'a> {
29811 inner: QueueFamilyCheckpointPropertiesNV,
29812 marker: ::std::marker::PhantomData<&'a ()>,
29813}
29814unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointPropertiesNVBuilder<'_> {}
29815unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointPropertiesNV {}
29816impl<'a> ::std::ops::Deref for QueueFamilyCheckpointPropertiesNVBuilder<'a> {
29817 type Target = QueueFamilyCheckpointPropertiesNV;
29818 fn deref(&self) -> &Self::Target {
29819 &self.inner
29820 }
29821}
29822impl<'a> ::std::ops::DerefMut for QueueFamilyCheckpointPropertiesNVBuilder<'a> {
29823 fn deref_mut(&mut self) -> &mut Self::Target {
29824 &mut self.inner
29825 }
29826}
29827impl<'a> QueueFamilyCheckpointPropertiesNVBuilder<'a> {
29828 pub fn checkpoint_execution_stage_mask(
29829 mut self,
29830 checkpoint_execution_stage_mask: PipelineStageFlags,
29831 ) -> Self {
29832 self.inner.checkpoint_execution_stage_mask = checkpoint_execution_stage_mask;
29833 self
29834 }
29835 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29836 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29837 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
29838 pub fn build(self) -> QueueFamilyCheckpointPropertiesNV {
29839 self.inner
29840 }
29841}
29842#[repr(C)]
29843#[cfg_attr(feature = "debug", derive(Debug))]
29844#[derive(Copy, Clone)]
29845#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCheckpointDataNV.html>"]
29846pub struct CheckpointDataNV {
29847 pub s_type: StructureType,
29848 pub p_next: *mut c_void,
29849 pub stage: PipelineStageFlags,
29850 pub p_checkpoint_marker: *mut c_void,
29851}
29852impl ::std::default::Default for CheckpointDataNV {
29853 fn default() -> Self {
29854 Self {
29855 s_type: StructureType::CHECKPOINT_DATA_NV,
29856 p_next: ::std::ptr::null_mut(),
29857 stage: PipelineStageFlags::default(),
29858 p_checkpoint_marker: ::std::ptr::null_mut(),
29859 }
29860 }
29861}
29862impl CheckpointDataNV {
29863 pub fn builder<'a>() -> CheckpointDataNVBuilder<'a> {
29864 CheckpointDataNVBuilder {
29865 inner: Self::default(),
29866 marker: ::std::marker::PhantomData,
29867 }
29868 }
29869}
29870#[repr(transparent)]
29871pub struct CheckpointDataNVBuilder<'a> {
29872 inner: CheckpointDataNV,
29873 marker: ::std::marker::PhantomData<&'a ()>,
29874}
29875impl<'a> ::std::ops::Deref for CheckpointDataNVBuilder<'a> {
29876 type Target = CheckpointDataNV;
29877 fn deref(&self) -> &Self::Target {
29878 &self.inner
29879 }
29880}
29881impl<'a> ::std::ops::DerefMut for CheckpointDataNVBuilder<'a> {
29882 fn deref_mut(&mut self) -> &mut Self::Target {
29883 &mut self.inner
29884 }
29885}
29886impl<'a> CheckpointDataNVBuilder<'a> {
29887 pub fn stage(mut self, stage: PipelineStageFlags) -> Self {
29888 self.inner.stage = stage;
29889 self
29890 }
29891 pub fn checkpoint_marker(mut self, checkpoint_marker: *mut c_void) -> Self {
29892 self.inner.p_checkpoint_marker = checkpoint_marker;
29893 self
29894 }
29895 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29896 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29897 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
29898 pub fn build(self) -> CheckpointDataNV {
29899 self.inner
29900 }
29901}
29902#[repr(C)]
29903#[cfg_attr(feature = "debug", derive(Debug))]
29904#[derive(Copy, Clone)]
29905#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDepthStencilResolveProperties.html>"]
29906pub struct PhysicalDeviceDepthStencilResolveProperties {
29907 pub s_type: StructureType,
29908 pub p_next: *mut c_void,
29909 pub supported_depth_resolve_modes: ResolveModeFlags,
29910 pub supported_stencil_resolve_modes: ResolveModeFlags,
29911 pub independent_resolve_none: Bool32,
29912 pub independent_resolve: Bool32,
29913}
29914impl ::std::default::Default for PhysicalDeviceDepthStencilResolveProperties {
29915 fn default() -> Self {
29916 Self {
29917 s_type: StructureType::PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES,
29918 p_next: ::std::ptr::null_mut(),
29919 supported_depth_resolve_modes: ResolveModeFlags::default(),
29920 supported_stencil_resolve_modes: ResolveModeFlags::default(),
29921 independent_resolve_none: Bool32::default(),
29922 independent_resolve: Bool32::default(),
29923 }
29924 }
29925}
29926impl PhysicalDeviceDepthStencilResolveProperties {
29927 pub fn builder<'a>() -> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
29928 PhysicalDeviceDepthStencilResolvePropertiesBuilder {
29929 inner: Self::default(),
29930 marker: ::std::marker::PhantomData,
29931 }
29932 }
29933}
29934#[repr(transparent)]
29935pub struct PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
29936 inner: PhysicalDeviceDepthStencilResolveProperties,
29937 marker: ::std::marker::PhantomData<&'a ()>,
29938}
29939unsafe impl ExtendsPhysicalDeviceProperties2
29940 for PhysicalDeviceDepthStencilResolvePropertiesBuilder<'_>
29941{
29942}
29943unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDepthStencilResolveProperties {}
29944impl<'a> ::std::ops::Deref for PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
29945 type Target = PhysicalDeviceDepthStencilResolveProperties;
29946 fn deref(&self) -> &Self::Target {
29947 &self.inner
29948 }
29949}
29950impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
29951 fn deref_mut(&mut self) -> &mut Self::Target {
29952 &mut self.inner
29953 }
29954}
29955impl<'a> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
29956 pub fn supported_depth_resolve_modes(
29957 mut self,
29958 supported_depth_resolve_modes: ResolveModeFlags,
29959 ) -> Self {
29960 self.inner.supported_depth_resolve_modes = supported_depth_resolve_modes;
29961 self
29962 }
29963 pub fn supported_stencil_resolve_modes(
29964 mut self,
29965 supported_stencil_resolve_modes: ResolveModeFlags,
29966 ) -> Self {
29967 self.inner.supported_stencil_resolve_modes = supported_stencil_resolve_modes;
29968 self
29969 }
29970 pub fn independent_resolve_none(mut self, independent_resolve_none: bool) -> Self {
29971 self.inner.independent_resolve_none = independent_resolve_none.into();
29972 self
29973 }
29974 pub fn independent_resolve(mut self, independent_resolve: bool) -> Self {
29975 self.inner.independent_resolve = independent_resolve.into();
29976 self
29977 }
29978 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29979 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29980 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
29981 pub fn build(self) -> PhysicalDeviceDepthStencilResolveProperties {
29982 self.inner
29983 }
29984}
29985#[repr(C)]
29986#[cfg_attr(feature = "debug", derive(Debug))]
29987#[derive(Copy, Clone)]
29988#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDescriptionDepthStencilResolve.html>"]
29989pub struct SubpassDescriptionDepthStencilResolve {
29990 pub s_type: StructureType,
29991 pub p_next: *const c_void,
29992 pub depth_resolve_mode: ResolveModeFlags,
29993 pub stencil_resolve_mode: ResolveModeFlags,
29994 pub p_depth_stencil_resolve_attachment: *const AttachmentReference2,
29995}
29996impl ::std::default::Default for SubpassDescriptionDepthStencilResolve {
29997 fn default() -> Self {
29998 Self {
29999 s_type: StructureType::SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE,
30000 p_next: ::std::ptr::null(),
30001 depth_resolve_mode: ResolveModeFlags::default(),
30002 stencil_resolve_mode: ResolveModeFlags::default(),
30003 p_depth_stencil_resolve_attachment: ::std::ptr::null(),
30004 }
30005 }
30006}
30007impl SubpassDescriptionDepthStencilResolve {
30008 pub fn builder<'a>() -> SubpassDescriptionDepthStencilResolveBuilder<'a> {
30009 SubpassDescriptionDepthStencilResolveBuilder {
30010 inner: Self::default(),
30011 marker: ::std::marker::PhantomData,
30012 }
30013 }
30014}
30015#[repr(transparent)]
30016pub struct SubpassDescriptionDepthStencilResolveBuilder<'a> {
30017 inner: SubpassDescriptionDepthStencilResolve,
30018 marker: ::std::marker::PhantomData<&'a ()>,
30019}
30020unsafe impl ExtendsSubpassDescription2 for SubpassDescriptionDepthStencilResolveBuilder<'_> {}
30021unsafe impl ExtendsSubpassDescription2 for SubpassDescriptionDepthStencilResolve {}
30022impl<'a> ::std::ops::Deref for SubpassDescriptionDepthStencilResolveBuilder<'a> {
30023 type Target = SubpassDescriptionDepthStencilResolve;
30024 fn deref(&self) -> &Self::Target {
30025 &self.inner
30026 }
30027}
30028impl<'a> ::std::ops::DerefMut for SubpassDescriptionDepthStencilResolveBuilder<'a> {
30029 fn deref_mut(&mut self) -> &mut Self::Target {
30030 &mut self.inner
30031 }
30032}
30033impl<'a> SubpassDescriptionDepthStencilResolveBuilder<'a> {
30034 pub fn depth_resolve_mode(mut self, depth_resolve_mode: ResolveModeFlags) -> Self {
30035 self.inner.depth_resolve_mode = depth_resolve_mode;
30036 self
30037 }
30038 pub fn stencil_resolve_mode(mut self, stencil_resolve_mode: ResolveModeFlags) -> Self {
30039 self.inner.stencil_resolve_mode = stencil_resolve_mode;
30040 self
30041 }
30042 pub fn depth_stencil_resolve_attachment(
30043 mut self,
30044 depth_stencil_resolve_attachment: &'a AttachmentReference2,
30045 ) -> Self {
30046 self.inner.p_depth_stencil_resolve_attachment = depth_stencil_resolve_attachment;
30047 self
30048 }
30049 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30050 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30051 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
30052 pub fn build(self) -> SubpassDescriptionDepthStencilResolve {
30053 self.inner
30054 }
30055}
30056#[repr(C)]
30057#[cfg_attr(feature = "debug", derive(Debug))]
30058#[derive(Copy, Clone)]
30059#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewASTCDecodeModeEXT.html>"]
30060pub struct ImageViewASTCDecodeModeEXT {
30061 pub s_type: StructureType,
30062 pub p_next: *const c_void,
30063 pub decode_mode: Format,
30064}
30065impl ::std::default::Default for ImageViewASTCDecodeModeEXT {
30066 fn default() -> Self {
30067 Self {
30068 s_type: StructureType::IMAGE_VIEW_ASTC_DECODE_MODE_EXT,
30069 p_next: ::std::ptr::null(),
30070 decode_mode: Format::default(),
30071 }
30072 }
30073}
30074impl ImageViewASTCDecodeModeEXT {
30075 pub fn builder<'a>() -> ImageViewASTCDecodeModeEXTBuilder<'a> {
30076 ImageViewASTCDecodeModeEXTBuilder {
30077 inner: Self::default(),
30078 marker: ::std::marker::PhantomData,
30079 }
30080 }
30081}
30082#[repr(transparent)]
30083pub struct ImageViewASTCDecodeModeEXTBuilder<'a> {
30084 inner: ImageViewASTCDecodeModeEXT,
30085 marker: ::std::marker::PhantomData<&'a ()>,
30086}
30087unsafe impl ExtendsImageViewCreateInfo for ImageViewASTCDecodeModeEXTBuilder<'_> {}
30088unsafe impl ExtendsImageViewCreateInfo for ImageViewASTCDecodeModeEXT {}
30089impl<'a> ::std::ops::Deref for ImageViewASTCDecodeModeEXTBuilder<'a> {
30090 type Target = ImageViewASTCDecodeModeEXT;
30091 fn deref(&self) -> &Self::Target {
30092 &self.inner
30093 }
30094}
30095impl<'a> ::std::ops::DerefMut for ImageViewASTCDecodeModeEXTBuilder<'a> {
30096 fn deref_mut(&mut self) -> &mut Self::Target {
30097 &mut self.inner
30098 }
30099}
30100impl<'a> ImageViewASTCDecodeModeEXTBuilder<'a> {
30101 pub fn decode_mode(mut self, decode_mode: Format) -> Self {
30102 self.inner.decode_mode = decode_mode;
30103 self
30104 }
30105 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30106 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30107 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
30108 pub fn build(self) -> ImageViewASTCDecodeModeEXT {
30109 self.inner
30110 }
30111}
30112#[repr(C)]
30113#[cfg_attr(feature = "debug", derive(Debug))]
30114#[derive(Copy, Clone)]
30115#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceASTCDecodeFeaturesEXT.html>"]
30116pub struct PhysicalDeviceASTCDecodeFeaturesEXT {
30117 pub s_type: StructureType,
30118 pub p_next: *mut c_void,
30119 pub decode_mode_shared_exponent: Bool32,
30120}
30121impl ::std::default::Default for PhysicalDeviceASTCDecodeFeaturesEXT {
30122 fn default() -> Self {
30123 Self {
30124 s_type: StructureType::PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT,
30125 p_next: ::std::ptr::null_mut(),
30126 decode_mode_shared_exponent: Bool32::default(),
30127 }
30128 }
30129}
30130impl PhysicalDeviceASTCDecodeFeaturesEXT {
30131 pub fn builder<'a>() -> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
30132 PhysicalDeviceASTCDecodeFeaturesEXTBuilder {
30133 inner: Self::default(),
30134 marker: ::std::marker::PhantomData,
30135 }
30136 }
30137}
30138#[repr(transparent)]
30139pub struct PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
30140 inner: PhysicalDeviceASTCDecodeFeaturesEXT,
30141 marker: ::std::marker::PhantomData<&'a ()>,
30142}
30143unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'_> {}
30144unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceASTCDecodeFeaturesEXT {}
30145unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'_> {}
30146unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceASTCDecodeFeaturesEXT {}
30147impl<'a> ::std::ops::Deref for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
30148 type Target = PhysicalDeviceASTCDecodeFeaturesEXT;
30149 fn deref(&self) -> &Self::Target {
30150 &self.inner
30151 }
30152}
30153impl<'a> ::std::ops::DerefMut for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
30154 fn deref_mut(&mut self) -> &mut Self::Target {
30155 &mut self.inner
30156 }
30157}
30158impl<'a> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
30159 pub fn decode_mode_shared_exponent(mut self, decode_mode_shared_exponent: bool) -> Self {
30160 self.inner.decode_mode_shared_exponent = decode_mode_shared_exponent.into();
30161 self
30162 }
30163 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30164 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30165 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
30166 pub fn build(self) -> PhysicalDeviceASTCDecodeFeaturesEXT {
30167 self.inner
30168 }
30169}
30170#[repr(C)]
30171#[cfg_attr(feature = "debug", derive(Debug))]
30172#[derive(Copy, Clone)]
30173#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTransformFeedbackFeaturesEXT.html>"]
30174pub struct PhysicalDeviceTransformFeedbackFeaturesEXT {
30175 pub s_type: StructureType,
30176 pub p_next: *mut c_void,
30177 pub transform_feedback: Bool32,
30178 pub geometry_streams: Bool32,
30179}
30180impl ::std::default::Default for PhysicalDeviceTransformFeedbackFeaturesEXT {
30181 fn default() -> Self {
30182 Self {
30183 s_type: StructureType::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT,
30184 p_next: ::std::ptr::null_mut(),
30185 transform_feedback: Bool32::default(),
30186 geometry_streams: Bool32::default(),
30187 }
30188 }
30189}
30190impl PhysicalDeviceTransformFeedbackFeaturesEXT {
30191 pub fn builder<'a>() -> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
30192 PhysicalDeviceTransformFeedbackFeaturesEXTBuilder {
30193 inner: Self::default(),
30194 marker: ::std::marker::PhantomData,
30195 }
30196 }
30197}
30198#[repr(transparent)]
30199pub struct PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
30200 inner: PhysicalDeviceTransformFeedbackFeaturesEXT,
30201 marker: ::std::marker::PhantomData<&'a ()>,
30202}
30203unsafe impl ExtendsPhysicalDeviceFeatures2
30204 for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'_>
30205{
30206}
30207unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTransformFeedbackFeaturesEXT {}
30208unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'_> {}
30209unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTransformFeedbackFeaturesEXT {}
30210impl<'a> ::std::ops::Deref for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
30211 type Target = PhysicalDeviceTransformFeedbackFeaturesEXT;
30212 fn deref(&self) -> &Self::Target {
30213 &self.inner
30214 }
30215}
30216impl<'a> ::std::ops::DerefMut for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
30217 fn deref_mut(&mut self) -> &mut Self::Target {
30218 &mut self.inner
30219 }
30220}
30221impl<'a> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
30222 pub fn transform_feedback(mut self, transform_feedback: bool) -> Self {
30223 self.inner.transform_feedback = transform_feedback.into();
30224 self
30225 }
30226 pub fn geometry_streams(mut self, geometry_streams: bool) -> Self {
30227 self.inner.geometry_streams = geometry_streams.into();
30228 self
30229 }
30230 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30231 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30232 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
30233 pub fn build(self) -> PhysicalDeviceTransformFeedbackFeaturesEXT {
30234 self.inner
30235 }
30236}
30237#[repr(C)]
30238#[cfg_attr(feature = "debug", derive(Debug))]
30239#[derive(Copy, Clone)]
30240#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTransformFeedbackPropertiesEXT.html>"]
30241pub struct PhysicalDeviceTransformFeedbackPropertiesEXT {
30242 pub s_type: StructureType,
30243 pub p_next: *mut c_void,
30244 pub max_transform_feedback_streams: u32,
30245 pub max_transform_feedback_buffers: u32,
30246 pub max_transform_feedback_buffer_size: DeviceSize,
30247 pub max_transform_feedback_stream_data_size: u32,
30248 pub max_transform_feedback_buffer_data_size: u32,
30249 pub max_transform_feedback_buffer_data_stride: u32,
30250 pub transform_feedback_queries: Bool32,
30251 pub transform_feedback_streams_lines_triangles: Bool32,
30252 pub transform_feedback_rasterization_stream_select: Bool32,
30253 pub transform_feedback_draw: Bool32,
30254}
30255impl ::std::default::Default for PhysicalDeviceTransformFeedbackPropertiesEXT {
30256 fn default() -> Self {
30257 Self {
30258 s_type: StructureType::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT,
30259 p_next: ::std::ptr::null_mut(),
30260 max_transform_feedback_streams: u32::default(),
30261 max_transform_feedback_buffers: u32::default(),
30262 max_transform_feedback_buffer_size: DeviceSize::default(),
30263 max_transform_feedback_stream_data_size: u32::default(),
30264 max_transform_feedback_buffer_data_size: u32::default(),
30265 max_transform_feedback_buffer_data_stride: u32::default(),
30266 transform_feedback_queries: Bool32::default(),
30267 transform_feedback_streams_lines_triangles: Bool32::default(),
30268 transform_feedback_rasterization_stream_select: Bool32::default(),
30269 transform_feedback_draw: Bool32::default(),
30270 }
30271 }
30272}
30273impl PhysicalDeviceTransformFeedbackPropertiesEXT {
30274 pub fn builder<'a>() -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
30275 PhysicalDeviceTransformFeedbackPropertiesEXTBuilder {
30276 inner: Self::default(),
30277 marker: ::std::marker::PhantomData,
30278 }
30279 }
30280}
30281#[repr(transparent)]
30282pub struct PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
30283 inner: PhysicalDeviceTransformFeedbackPropertiesEXT,
30284 marker: ::std::marker::PhantomData<&'a ()>,
30285}
30286unsafe impl ExtendsPhysicalDeviceProperties2
30287 for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'_>
30288{
30289}
30290unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTransformFeedbackPropertiesEXT {}
30291impl<'a> ::std::ops::Deref for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
30292 type Target = PhysicalDeviceTransformFeedbackPropertiesEXT;
30293 fn deref(&self) -> &Self::Target {
30294 &self.inner
30295 }
30296}
30297impl<'a> ::std::ops::DerefMut for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
30298 fn deref_mut(&mut self) -> &mut Self::Target {
30299 &mut self.inner
30300 }
30301}
30302impl<'a> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
30303 pub fn max_transform_feedback_streams(mut self, max_transform_feedback_streams: u32) -> Self {
30304 self.inner.max_transform_feedback_streams = max_transform_feedback_streams;
30305 self
30306 }
30307 pub fn max_transform_feedback_buffers(mut self, max_transform_feedback_buffers: u32) -> Self {
30308 self.inner.max_transform_feedback_buffers = max_transform_feedback_buffers;
30309 self
30310 }
30311 pub fn max_transform_feedback_buffer_size(
30312 mut self,
30313 max_transform_feedback_buffer_size: DeviceSize,
30314 ) -> Self {
30315 self.inner.max_transform_feedback_buffer_size = max_transform_feedback_buffer_size;
30316 self
30317 }
30318 pub fn max_transform_feedback_stream_data_size(
30319 mut self,
30320 max_transform_feedback_stream_data_size: u32,
30321 ) -> Self {
30322 self.inner.max_transform_feedback_stream_data_size =
30323 max_transform_feedback_stream_data_size;
30324 self
30325 }
30326 pub fn max_transform_feedback_buffer_data_size(
30327 mut self,
30328 max_transform_feedback_buffer_data_size: u32,
30329 ) -> Self {
30330 self.inner.max_transform_feedback_buffer_data_size =
30331 max_transform_feedback_buffer_data_size;
30332 self
30333 }
30334 pub fn max_transform_feedback_buffer_data_stride(
30335 mut self,
30336 max_transform_feedback_buffer_data_stride: u32,
30337 ) -> Self {
30338 self.inner.max_transform_feedback_buffer_data_stride =
30339 max_transform_feedback_buffer_data_stride;
30340 self
30341 }
30342 pub fn transform_feedback_queries(mut self, transform_feedback_queries: bool) -> Self {
30343 self.inner.transform_feedback_queries = transform_feedback_queries.into();
30344 self
30345 }
30346 pub fn transform_feedback_streams_lines_triangles(
30347 mut self,
30348 transform_feedback_streams_lines_triangles: bool,
30349 ) -> Self {
30350 self.inner.transform_feedback_streams_lines_triangles =
30351 transform_feedback_streams_lines_triangles.into();
30352 self
30353 }
30354 pub fn transform_feedback_rasterization_stream_select(
30355 mut self,
30356 transform_feedback_rasterization_stream_select: bool,
30357 ) -> Self {
30358 self.inner.transform_feedback_rasterization_stream_select =
30359 transform_feedback_rasterization_stream_select.into();
30360 self
30361 }
30362 pub fn transform_feedback_draw(mut self, transform_feedback_draw: bool) -> Self {
30363 self.inner.transform_feedback_draw = transform_feedback_draw.into();
30364 self
30365 }
30366 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30367 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30368 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
30369 pub fn build(self) -> PhysicalDeviceTransformFeedbackPropertiesEXT {
30370 self.inner
30371 }
30372}
30373#[repr(C)]
30374#[cfg_attr(feature = "debug", derive(Debug))]
30375#[derive(Copy, Clone)]
30376#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationStateStreamCreateInfoEXT.html>"]
30377pub struct PipelineRasterizationStateStreamCreateInfoEXT {
30378 pub s_type: StructureType,
30379 pub p_next: *const c_void,
30380 pub flags: PipelineRasterizationStateStreamCreateFlagsEXT,
30381 pub rasterization_stream: u32,
30382}
30383impl ::std::default::Default for PipelineRasterizationStateStreamCreateInfoEXT {
30384 fn default() -> Self {
30385 Self {
30386 s_type: StructureType::PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT,
30387 p_next: ::std::ptr::null(),
30388 flags: PipelineRasterizationStateStreamCreateFlagsEXT::default(),
30389 rasterization_stream: u32::default(),
30390 }
30391 }
30392}
30393impl PipelineRasterizationStateStreamCreateInfoEXT {
30394 pub fn builder<'a>() -> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
30395 PipelineRasterizationStateStreamCreateInfoEXTBuilder {
30396 inner: Self::default(),
30397 marker: ::std::marker::PhantomData,
30398 }
30399 }
30400}
30401#[repr(transparent)]
30402pub struct PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
30403 inner: PipelineRasterizationStateStreamCreateInfoEXT,
30404 marker: ::std::marker::PhantomData<&'a ()>,
30405}
30406unsafe impl ExtendsPipelineRasterizationStateCreateInfo
30407 for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'_>
30408{
30409}
30410unsafe impl ExtendsPipelineRasterizationStateCreateInfo
30411 for PipelineRasterizationStateStreamCreateInfoEXT
30412{
30413}
30414impl<'a> ::std::ops::Deref for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
30415 type Target = PipelineRasterizationStateStreamCreateInfoEXT;
30416 fn deref(&self) -> &Self::Target {
30417 &self.inner
30418 }
30419}
30420impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
30421 fn deref_mut(&mut self) -> &mut Self::Target {
30422 &mut self.inner
30423 }
30424}
30425impl<'a> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
30426 pub fn flags(mut self, flags: PipelineRasterizationStateStreamCreateFlagsEXT) -> Self {
30427 self.inner.flags = flags;
30428 self
30429 }
30430 pub fn rasterization_stream(mut self, rasterization_stream: u32) -> Self {
30431 self.inner.rasterization_stream = rasterization_stream;
30432 self
30433 }
30434 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30435 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30436 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
30437 pub fn build(self) -> PipelineRasterizationStateStreamCreateInfoEXT {
30438 self.inner
30439 }
30440}
30441#[repr(C)]
30442#[cfg_attr(feature = "debug", derive(Debug))]
30443#[derive(Copy, Clone)]
30444#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV.html>"]
30445pub struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
30446 pub s_type: StructureType,
30447 pub p_next: *mut c_void,
30448 pub representative_fragment_test: Bool32,
30449}
30450impl ::std::default::Default for PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
30451 fn default() -> Self {
30452 Self {
30453 s_type: StructureType::PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV,
30454 p_next: ::std::ptr::null_mut(),
30455 representative_fragment_test: Bool32::default(),
30456 }
30457 }
30458}
30459impl PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
30460 pub fn builder<'a>() -> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
30461 PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder {
30462 inner: Self::default(),
30463 marker: ::std::marker::PhantomData,
30464 }
30465 }
30466}
30467#[repr(transparent)]
30468pub struct PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
30469 inner: PhysicalDeviceRepresentativeFragmentTestFeaturesNV,
30470 marker: ::std::marker::PhantomData<&'a ()>,
30471}
30472unsafe impl ExtendsPhysicalDeviceFeatures2
30473 for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'_>
30474{
30475}
30476unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRepresentativeFragmentTestFeaturesNV {}
30477unsafe impl ExtendsDeviceCreateInfo
30478 for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'_>
30479{
30480}
30481unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRepresentativeFragmentTestFeaturesNV {}
30482impl<'a> ::std::ops::Deref for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
30483 type Target = PhysicalDeviceRepresentativeFragmentTestFeaturesNV;
30484 fn deref(&self) -> &Self::Target {
30485 &self.inner
30486 }
30487}
30488impl<'a> ::std::ops::DerefMut for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
30489 fn deref_mut(&mut self) -> &mut Self::Target {
30490 &mut self.inner
30491 }
30492}
30493impl<'a> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
30494 pub fn representative_fragment_test(mut self, representative_fragment_test: bool) -> Self {
30495 self.inner.representative_fragment_test = representative_fragment_test.into();
30496 self
30497 }
30498 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30499 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30500 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
30501 pub fn build(self) -> PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
30502 self.inner
30503 }
30504}
30505#[repr(C)]
30506#[cfg_attr(feature = "debug", derive(Debug))]
30507#[derive(Copy, Clone)]
30508#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRepresentativeFragmentTestStateCreateInfoNV.html>"]
30509pub struct PipelineRepresentativeFragmentTestStateCreateInfoNV {
30510 pub s_type: StructureType,
30511 pub p_next: *const c_void,
30512 pub representative_fragment_test_enable: Bool32,
30513}
30514impl ::std::default::Default for PipelineRepresentativeFragmentTestStateCreateInfoNV {
30515 fn default() -> Self {
30516 Self {
30517 s_type: StructureType::PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV,
30518 p_next: ::std::ptr::null(),
30519 representative_fragment_test_enable: Bool32::default(),
30520 }
30521 }
30522}
30523impl PipelineRepresentativeFragmentTestStateCreateInfoNV {
30524 pub fn builder<'a>() -> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
30525 PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder {
30526 inner: Self::default(),
30527 marker: ::std::marker::PhantomData,
30528 }
30529 }
30530}
30531#[repr(transparent)]
30532pub struct PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
30533 inner: PipelineRepresentativeFragmentTestStateCreateInfoNV,
30534 marker: ::std::marker::PhantomData<&'a ()>,
30535}
30536unsafe impl ExtendsGraphicsPipelineCreateInfo
30537 for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'_>
30538{
30539}
30540unsafe impl ExtendsGraphicsPipelineCreateInfo
30541 for PipelineRepresentativeFragmentTestStateCreateInfoNV
30542{
30543}
30544impl<'a> ::std::ops::Deref for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
30545 type Target = PipelineRepresentativeFragmentTestStateCreateInfoNV;
30546 fn deref(&self) -> &Self::Target {
30547 &self.inner
30548 }
30549}
30550impl<'a> ::std::ops::DerefMut for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
30551 fn deref_mut(&mut self) -> &mut Self::Target {
30552 &mut self.inner
30553 }
30554}
30555impl<'a> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
30556 pub fn representative_fragment_test_enable(
30557 mut self,
30558 representative_fragment_test_enable: bool,
30559 ) -> Self {
30560 self.inner.representative_fragment_test_enable = representative_fragment_test_enable.into();
30561 self
30562 }
30563 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30564 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30565 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
30566 pub fn build(self) -> PipelineRepresentativeFragmentTestStateCreateInfoNV {
30567 self.inner
30568 }
30569}
30570#[repr(C)]
30571#[cfg_attr(feature = "debug", derive(Debug))]
30572#[derive(Copy, Clone)]
30573#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExclusiveScissorFeaturesNV.html>"]
30574pub struct PhysicalDeviceExclusiveScissorFeaturesNV {
30575 pub s_type: StructureType,
30576 pub p_next: *mut c_void,
30577 pub exclusive_scissor: Bool32,
30578}
30579impl ::std::default::Default for PhysicalDeviceExclusiveScissorFeaturesNV {
30580 fn default() -> Self {
30581 Self {
30582 s_type: StructureType::PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV,
30583 p_next: ::std::ptr::null_mut(),
30584 exclusive_scissor: Bool32::default(),
30585 }
30586 }
30587}
30588impl PhysicalDeviceExclusiveScissorFeaturesNV {
30589 pub fn builder<'a>() -> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
30590 PhysicalDeviceExclusiveScissorFeaturesNVBuilder {
30591 inner: Self::default(),
30592 marker: ::std::marker::PhantomData,
30593 }
30594 }
30595}
30596#[repr(transparent)]
30597pub struct PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
30598 inner: PhysicalDeviceExclusiveScissorFeaturesNV,
30599 marker: ::std::marker::PhantomData<&'a ()>,
30600}
30601unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'_> {}
30602unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExclusiveScissorFeaturesNV {}
30603unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'_> {}
30604unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExclusiveScissorFeaturesNV {}
30605impl<'a> ::std::ops::Deref for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
30606 type Target = PhysicalDeviceExclusiveScissorFeaturesNV;
30607 fn deref(&self) -> &Self::Target {
30608 &self.inner
30609 }
30610}
30611impl<'a> ::std::ops::DerefMut for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
30612 fn deref_mut(&mut self) -> &mut Self::Target {
30613 &mut self.inner
30614 }
30615}
30616impl<'a> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
30617 pub fn exclusive_scissor(mut self, exclusive_scissor: bool) -> Self {
30618 self.inner.exclusive_scissor = exclusive_scissor.into();
30619 self
30620 }
30621 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30622 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30623 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
30624 pub fn build(self) -> PhysicalDeviceExclusiveScissorFeaturesNV {
30625 self.inner
30626 }
30627}
30628#[repr(C)]
30629#[cfg_attr(feature = "debug", derive(Debug))]
30630#[derive(Copy, Clone)]
30631#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportExclusiveScissorStateCreateInfoNV.html>"]
30632pub struct PipelineViewportExclusiveScissorStateCreateInfoNV {
30633 pub s_type: StructureType,
30634 pub p_next: *const c_void,
30635 pub exclusive_scissor_count: u32,
30636 pub p_exclusive_scissors: *const Rect2D,
30637}
30638impl ::std::default::Default for PipelineViewportExclusiveScissorStateCreateInfoNV {
30639 fn default() -> Self {
30640 Self {
30641 s_type: StructureType::PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV,
30642 p_next: ::std::ptr::null(),
30643 exclusive_scissor_count: u32::default(),
30644 p_exclusive_scissors: ::std::ptr::null(),
30645 }
30646 }
30647}
30648impl PipelineViewportExclusiveScissorStateCreateInfoNV {
30649 pub fn builder<'a>() -> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
30650 PipelineViewportExclusiveScissorStateCreateInfoNVBuilder {
30651 inner: Self::default(),
30652 marker: ::std::marker::PhantomData,
30653 }
30654 }
30655}
30656#[repr(transparent)]
30657pub struct PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
30658 inner: PipelineViewportExclusiveScissorStateCreateInfoNV,
30659 marker: ::std::marker::PhantomData<&'a ()>,
30660}
30661unsafe impl ExtendsPipelineViewportStateCreateInfo
30662 for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'_>
30663{
30664}
30665unsafe impl ExtendsPipelineViewportStateCreateInfo
30666 for PipelineViewportExclusiveScissorStateCreateInfoNV
30667{
30668}
30669impl<'a> ::std::ops::Deref for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
30670 type Target = PipelineViewportExclusiveScissorStateCreateInfoNV;
30671 fn deref(&self) -> &Self::Target {
30672 &self.inner
30673 }
30674}
30675impl<'a> ::std::ops::DerefMut for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
30676 fn deref_mut(&mut self) -> &mut Self::Target {
30677 &mut self.inner
30678 }
30679}
30680impl<'a> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
30681 pub fn exclusive_scissors(mut self, exclusive_scissors: &'a [Rect2D]) -> Self {
30682 self.inner.exclusive_scissor_count = exclusive_scissors.len() as _;
30683 self.inner.p_exclusive_scissors = exclusive_scissors.as_ptr();
30684 self
30685 }
30686 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30687 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30688 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
30689 pub fn build(self) -> PipelineViewportExclusiveScissorStateCreateInfoNV {
30690 self.inner
30691 }
30692}
30693#[repr(C)]
30694#[cfg_attr(feature = "debug", derive(Debug))]
30695#[derive(Copy, Clone)]
30696#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCornerSampledImageFeaturesNV.html>"]
30697pub struct PhysicalDeviceCornerSampledImageFeaturesNV {
30698 pub s_type: StructureType,
30699 pub p_next: *mut c_void,
30700 pub corner_sampled_image: Bool32,
30701}
30702impl ::std::default::Default for PhysicalDeviceCornerSampledImageFeaturesNV {
30703 fn default() -> Self {
30704 Self {
30705 s_type: StructureType::PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV,
30706 p_next: ::std::ptr::null_mut(),
30707 corner_sampled_image: Bool32::default(),
30708 }
30709 }
30710}
30711impl PhysicalDeviceCornerSampledImageFeaturesNV {
30712 pub fn builder<'a>() -> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
30713 PhysicalDeviceCornerSampledImageFeaturesNVBuilder {
30714 inner: Self::default(),
30715 marker: ::std::marker::PhantomData,
30716 }
30717 }
30718}
30719#[repr(transparent)]
30720pub struct PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
30721 inner: PhysicalDeviceCornerSampledImageFeaturesNV,
30722 marker: ::std::marker::PhantomData<&'a ()>,
30723}
30724unsafe impl ExtendsPhysicalDeviceFeatures2
30725 for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'_>
30726{
30727}
30728unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCornerSampledImageFeaturesNV {}
30729unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'_> {}
30730unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCornerSampledImageFeaturesNV {}
30731impl<'a> ::std::ops::Deref for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
30732 type Target = PhysicalDeviceCornerSampledImageFeaturesNV;
30733 fn deref(&self) -> &Self::Target {
30734 &self.inner
30735 }
30736}
30737impl<'a> ::std::ops::DerefMut for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
30738 fn deref_mut(&mut self) -> &mut Self::Target {
30739 &mut self.inner
30740 }
30741}
30742impl<'a> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
30743 pub fn corner_sampled_image(mut self, corner_sampled_image: bool) -> Self {
30744 self.inner.corner_sampled_image = corner_sampled_image.into();
30745 self
30746 }
30747 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30748 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30749 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
30750 pub fn build(self) -> PhysicalDeviceCornerSampledImageFeaturesNV {
30751 self.inner
30752 }
30753}
30754#[repr(C)]
30755#[cfg_attr(feature = "debug", derive(Debug))]
30756#[derive(Copy, Clone)]
30757#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceComputeShaderDerivativesFeaturesNV.html>"]
30758pub struct PhysicalDeviceComputeShaderDerivativesFeaturesNV {
30759 pub s_type: StructureType,
30760 pub p_next: *mut c_void,
30761 pub compute_derivative_group_quads: Bool32,
30762 pub compute_derivative_group_linear: Bool32,
30763}
30764impl ::std::default::Default for PhysicalDeviceComputeShaderDerivativesFeaturesNV {
30765 fn default() -> Self {
30766 Self {
30767 s_type: StructureType::PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV,
30768 p_next: ::std::ptr::null_mut(),
30769 compute_derivative_group_quads: Bool32::default(),
30770 compute_derivative_group_linear: Bool32::default(),
30771 }
30772 }
30773}
30774impl PhysicalDeviceComputeShaderDerivativesFeaturesNV {
30775 pub fn builder<'a>() -> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
30776 PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder {
30777 inner: Self::default(),
30778 marker: ::std::marker::PhantomData,
30779 }
30780 }
30781}
30782#[repr(transparent)]
30783pub struct PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
30784 inner: PhysicalDeviceComputeShaderDerivativesFeaturesNV,
30785 marker: ::std::marker::PhantomData<&'a ()>,
30786}
30787unsafe impl ExtendsPhysicalDeviceFeatures2
30788 for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'_>
30789{
30790}
30791unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceComputeShaderDerivativesFeaturesNV {}
30792unsafe impl ExtendsDeviceCreateInfo
30793 for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'_>
30794{
30795}
30796unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceComputeShaderDerivativesFeaturesNV {}
30797impl<'a> ::std::ops::Deref for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
30798 type Target = PhysicalDeviceComputeShaderDerivativesFeaturesNV;
30799 fn deref(&self) -> &Self::Target {
30800 &self.inner
30801 }
30802}
30803impl<'a> ::std::ops::DerefMut for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
30804 fn deref_mut(&mut self) -> &mut Self::Target {
30805 &mut self.inner
30806 }
30807}
30808impl<'a> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
30809 pub fn compute_derivative_group_quads(mut self, compute_derivative_group_quads: bool) -> Self {
30810 self.inner.compute_derivative_group_quads = compute_derivative_group_quads.into();
30811 self
30812 }
30813 pub fn compute_derivative_group_linear(
30814 mut self,
30815 compute_derivative_group_linear: bool,
30816 ) -> Self {
30817 self.inner.compute_derivative_group_linear = compute_derivative_group_linear.into();
30818 self
30819 }
30820 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30821 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30822 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
30823 pub fn build(self) -> PhysicalDeviceComputeShaderDerivativesFeaturesNV {
30824 self.inner
30825 }
30826}
30827#[repr(C)]
30828#[cfg_attr(feature = "debug", derive(Debug))]
30829#[derive(Copy, Clone)]
30830#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV.html>"]
30831pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV {
30832 pub s_type: StructureType,
30833 pub p_next: *mut c_void,
30834 pub fragment_shader_barycentric: Bool32,
30835}
30836impl ::std::default::Default for PhysicalDeviceFragmentShaderBarycentricFeaturesNV {
30837 fn default() -> Self {
30838 Self {
30839 s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV,
30840 p_next: ::std::ptr::null_mut(),
30841 fragment_shader_barycentric: Bool32::default(),
30842 }
30843 }
30844}
30845impl PhysicalDeviceFragmentShaderBarycentricFeaturesNV {
30846 pub fn builder<'a>() -> PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
30847 PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder {
30848 inner: Self::default(),
30849 marker: ::std::marker::PhantomData,
30850 }
30851 }
30852}
30853#[repr(transparent)]
30854pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
30855 inner: PhysicalDeviceFragmentShaderBarycentricFeaturesNV,
30856 marker: ::std::marker::PhantomData<&'a ()>,
30857}
30858unsafe impl ExtendsPhysicalDeviceFeatures2
30859 for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'_>
30860{
30861}
30862unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShaderBarycentricFeaturesNV {}
30863unsafe impl ExtendsDeviceCreateInfo
30864 for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'_>
30865{
30866}
30867unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderBarycentricFeaturesNV {}
30868impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
30869 type Target = PhysicalDeviceFragmentShaderBarycentricFeaturesNV;
30870 fn deref(&self) -> &Self::Target {
30871 &self.inner
30872 }
30873}
30874impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
30875 fn deref_mut(&mut self) -> &mut Self::Target {
30876 &mut self.inner
30877 }
30878}
30879impl<'a> PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
30880 pub fn fragment_shader_barycentric(mut self, fragment_shader_barycentric: bool) -> Self {
30881 self.inner.fragment_shader_barycentric = fragment_shader_barycentric.into();
30882 self
30883 }
30884 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30885 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30886 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
30887 pub fn build(self) -> PhysicalDeviceFragmentShaderBarycentricFeaturesNV {
30888 self.inner
30889 }
30890}
30891#[repr(C)]
30892#[cfg_attr(feature = "debug", derive(Debug))]
30893#[derive(Copy, Clone)]
30894#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderImageFootprintFeaturesNV.html>"]
30895pub struct PhysicalDeviceShaderImageFootprintFeaturesNV {
30896 pub s_type: StructureType,
30897 pub p_next: *mut c_void,
30898 pub image_footprint: Bool32,
30899}
30900impl ::std::default::Default for PhysicalDeviceShaderImageFootprintFeaturesNV {
30901 fn default() -> Self {
30902 Self {
30903 s_type: StructureType::PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV,
30904 p_next: ::std::ptr::null_mut(),
30905 image_footprint: Bool32::default(),
30906 }
30907 }
30908}
30909impl PhysicalDeviceShaderImageFootprintFeaturesNV {
30910 pub fn builder<'a>() -> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
30911 PhysicalDeviceShaderImageFootprintFeaturesNVBuilder {
30912 inner: Self::default(),
30913 marker: ::std::marker::PhantomData,
30914 }
30915 }
30916}
30917#[repr(transparent)]
30918pub struct PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
30919 inner: PhysicalDeviceShaderImageFootprintFeaturesNV,
30920 marker: ::std::marker::PhantomData<&'a ()>,
30921}
30922unsafe impl ExtendsPhysicalDeviceFeatures2
30923 for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'_>
30924{
30925}
30926unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderImageFootprintFeaturesNV {}
30927unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'_> {}
30928unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageFootprintFeaturesNV {}
30929impl<'a> ::std::ops::Deref for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
30930 type Target = PhysicalDeviceShaderImageFootprintFeaturesNV;
30931 fn deref(&self) -> &Self::Target {
30932 &self.inner
30933 }
30934}
30935impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
30936 fn deref_mut(&mut self) -> &mut Self::Target {
30937 &mut self.inner
30938 }
30939}
30940impl<'a> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
30941 pub fn image_footprint(mut self, image_footprint: bool) -> Self {
30942 self.inner.image_footprint = image_footprint.into();
30943 self
30944 }
30945 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30946 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30947 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
30948 pub fn build(self) -> PhysicalDeviceShaderImageFootprintFeaturesNV {
30949 self.inner
30950 }
30951}
30952#[repr(C)]
30953#[cfg_attr(feature = "debug", derive(Debug))]
30954#[derive(Copy, Clone)]
30955#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV.html>"]
30956pub struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
30957 pub s_type: StructureType,
30958 pub p_next: *mut c_void,
30959 pub dedicated_allocation_image_aliasing: Bool32,
30960}
30961impl ::std::default::Default for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
30962 fn default() -> Self {
30963 Self {
30964 s_type: StructureType::PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV,
30965 p_next: ::std::ptr::null_mut(),
30966 dedicated_allocation_image_aliasing: Bool32::default(),
30967 }
30968 }
30969}
30970impl PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
30971 pub fn builder<'a>() -> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
30972 PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder {
30973 inner: Self::default(),
30974 marker: ::std::marker::PhantomData,
30975 }
30976 }
30977}
30978#[repr(transparent)]
30979pub struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
30980 inner: PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV,
30981 marker: ::std::marker::PhantomData<&'a ()>,
30982}
30983unsafe impl ExtendsPhysicalDeviceFeatures2
30984 for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'_>
30985{
30986}
30987unsafe impl ExtendsPhysicalDeviceFeatures2
30988 for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV
30989{
30990}
30991unsafe impl ExtendsDeviceCreateInfo
30992 for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'_>
30993{
30994}
30995unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {}
30996impl<'a> ::std::ops::Deref for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
30997 type Target = PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
30998 fn deref(&self) -> &Self::Target {
30999 &self.inner
31000 }
31001}
31002impl<'a> ::std::ops::DerefMut
31003 for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a>
31004{
31005 fn deref_mut(&mut self) -> &mut Self::Target {
31006 &mut self.inner
31007 }
31008}
31009impl<'a> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
31010 pub fn dedicated_allocation_image_aliasing(
31011 mut self,
31012 dedicated_allocation_image_aliasing: bool,
31013 ) -> Self {
31014 self.inner.dedicated_allocation_image_aliasing = dedicated_allocation_image_aliasing.into();
31015 self
31016 }
31017 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31018 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31019 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
31020 pub fn build(self) -> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
31021 self.inner
31022 }
31023}
31024#[repr(C)]
31025#[cfg_attr(feature = "debug", derive(Debug))]
31026#[derive(Copy, Clone)]
31027#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShadingRatePaletteNV.html>"]
31028pub struct ShadingRatePaletteNV {
31029 pub shading_rate_palette_entry_count: u32,
31030 pub p_shading_rate_palette_entries: *const ShadingRatePaletteEntryNV,
31031}
31032impl ::std::default::Default for ShadingRatePaletteNV {
31033 fn default() -> Self {
31034 Self {
31035 shading_rate_palette_entry_count: u32::default(),
31036 p_shading_rate_palette_entries: ::std::ptr::null(),
31037 }
31038 }
31039}
31040impl ShadingRatePaletteNV {
31041 pub fn builder<'a>() -> ShadingRatePaletteNVBuilder<'a> {
31042 ShadingRatePaletteNVBuilder {
31043 inner: Self::default(),
31044 marker: ::std::marker::PhantomData,
31045 }
31046 }
31047}
31048#[repr(transparent)]
31049pub struct ShadingRatePaletteNVBuilder<'a> {
31050 inner: ShadingRatePaletteNV,
31051 marker: ::std::marker::PhantomData<&'a ()>,
31052}
31053impl<'a> ::std::ops::Deref for ShadingRatePaletteNVBuilder<'a> {
31054 type Target = ShadingRatePaletteNV;
31055 fn deref(&self) -> &Self::Target {
31056 &self.inner
31057 }
31058}
31059impl<'a> ::std::ops::DerefMut for ShadingRatePaletteNVBuilder<'a> {
31060 fn deref_mut(&mut self) -> &mut Self::Target {
31061 &mut self.inner
31062 }
31063}
31064impl<'a> ShadingRatePaletteNVBuilder<'a> {
31065 pub fn shading_rate_palette_entries(
31066 mut self,
31067 shading_rate_palette_entries: &'a [ShadingRatePaletteEntryNV],
31068 ) -> Self {
31069 self.inner.shading_rate_palette_entry_count = shading_rate_palette_entries.len() as _;
31070 self.inner.p_shading_rate_palette_entries = shading_rate_palette_entries.as_ptr();
31071 self
31072 }
31073 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31074 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31075 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
31076 pub fn build(self) -> ShadingRatePaletteNV {
31077 self.inner
31078 }
31079}
31080#[repr(C)]
31081#[cfg_attr(feature = "debug", derive(Debug))]
31082#[derive(Copy, Clone)]
31083#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportShadingRateImageStateCreateInfoNV.html>"]
31084pub struct PipelineViewportShadingRateImageStateCreateInfoNV {
31085 pub s_type: StructureType,
31086 pub p_next: *const c_void,
31087 pub shading_rate_image_enable: Bool32,
31088 pub viewport_count: u32,
31089 pub p_shading_rate_palettes: *const ShadingRatePaletteNV,
31090}
31091impl ::std::default::Default for PipelineViewportShadingRateImageStateCreateInfoNV {
31092 fn default() -> Self {
31093 Self {
31094 s_type: StructureType::PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV,
31095 p_next: ::std::ptr::null(),
31096 shading_rate_image_enable: Bool32::default(),
31097 viewport_count: u32::default(),
31098 p_shading_rate_palettes: ::std::ptr::null(),
31099 }
31100 }
31101}
31102impl PipelineViewportShadingRateImageStateCreateInfoNV {
31103 pub fn builder<'a>() -> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
31104 PipelineViewportShadingRateImageStateCreateInfoNVBuilder {
31105 inner: Self::default(),
31106 marker: ::std::marker::PhantomData,
31107 }
31108 }
31109}
31110#[repr(transparent)]
31111pub struct PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
31112 inner: PipelineViewportShadingRateImageStateCreateInfoNV,
31113 marker: ::std::marker::PhantomData<&'a ()>,
31114}
31115unsafe impl ExtendsPipelineViewportStateCreateInfo
31116 for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'_>
31117{
31118}
31119unsafe impl ExtendsPipelineViewportStateCreateInfo
31120 for PipelineViewportShadingRateImageStateCreateInfoNV
31121{
31122}
31123impl<'a> ::std::ops::Deref for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
31124 type Target = PipelineViewportShadingRateImageStateCreateInfoNV;
31125 fn deref(&self) -> &Self::Target {
31126 &self.inner
31127 }
31128}
31129impl<'a> ::std::ops::DerefMut for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
31130 fn deref_mut(&mut self) -> &mut Self::Target {
31131 &mut self.inner
31132 }
31133}
31134impl<'a> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
31135 pub fn shading_rate_image_enable(mut self, shading_rate_image_enable: bool) -> Self {
31136 self.inner.shading_rate_image_enable = shading_rate_image_enable.into();
31137 self
31138 }
31139 pub fn shading_rate_palettes(
31140 mut self,
31141 shading_rate_palettes: &'a [ShadingRatePaletteNV],
31142 ) -> Self {
31143 self.inner.viewport_count = shading_rate_palettes.len() as _;
31144 self.inner.p_shading_rate_palettes = shading_rate_palettes.as_ptr();
31145 self
31146 }
31147 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31148 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31149 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
31150 pub fn build(self) -> PipelineViewportShadingRateImageStateCreateInfoNV {
31151 self.inner
31152 }
31153}
31154#[repr(C)]
31155#[cfg_attr(feature = "debug", derive(Debug))]
31156#[derive(Copy, Clone)]
31157#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShadingRateImageFeaturesNV.html>"]
31158pub struct PhysicalDeviceShadingRateImageFeaturesNV {
31159 pub s_type: StructureType,
31160 pub p_next: *mut c_void,
31161 pub shading_rate_image: Bool32,
31162 pub shading_rate_coarse_sample_order: Bool32,
31163}
31164impl ::std::default::Default for PhysicalDeviceShadingRateImageFeaturesNV {
31165 fn default() -> Self {
31166 Self {
31167 s_type: StructureType::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV,
31168 p_next: ::std::ptr::null_mut(),
31169 shading_rate_image: Bool32::default(),
31170 shading_rate_coarse_sample_order: Bool32::default(),
31171 }
31172 }
31173}
31174impl PhysicalDeviceShadingRateImageFeaturesNV {
31175 pub fn builder<'a>() -> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
31176 PhysicalDeviceShadingRateImageFeaturesNVBuilder {
31177 inner: Self::default(),
31178 marker: ::std::marker::PhantomData,
31179 }
31180 }
31181}
31182#[repr(transparent)]
31183pub struct PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
31184 inner: PhysicalDeviceShadingRateImageFeaturesNV,
31185 marker: ::std::marker::PhantomData<&'a ()>,
31186}
31187unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'_> {}
31188unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShadingRateImageFeaturesNV {}
31189unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'_> {}
31190unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShadingRateImageFeaturesNV {}
31191impl<'a> ::std::ops::Deref for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
31192 type Target = PhysicalDeviceShadingRateImageFeaturesNV;
31193 fn deref(&self) -> &Self::Target {
31194 &self.inner
31195 }
31196}
31197impl<'a> ::std::ops::DerefMut for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
31198 fn deref_mut(&mut self) -> &mut Self::Target {
31199 &mut self.inner
31200 }
31201}
31202impl<'a> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
31203 pub fn shading_rate_image(mut self, shading_rate_image: bool) -> Self {
31204 self.inner.shading_rate_image = shading_rate_image.into();
31205 self
31206 }
31207 pub fn shading_rate_coarse_sample_order(
31208 mut self,
31209 shading_rate_coarse_sample_order: bool,
31210 ) -> Self {
31211 self.inner.shading_rate_coarse_sample_order = shading_rate_coarse_sample_order.into();
31212 self
31213 }
31214 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31215 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31216 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
31217 pub fn build(self) -> PhysicalDeviceShadingRateImageFeaturesNV {
31218 self.inner
31219 }
31220}
31221#[repr(C)]
31222#[cfg_attr(feature = "debug", derive(Debug))]
31223#[derive(Copy, Clone)]
31224#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShadingRateImagePropertiesNV.html>"]
31225pub struct PhysicalDeviceShadingRateImagePropertiesNV {
31226 pub s_type: StructureType,
31227 pub p_next: *mut c_void,
31228 pub shading_rate_texel_size: Extent2D,
31229 pub shading_rate_palette_size: u32,
31230 pub shading_rate_max_coarse_samples: u32,
31231}
31232impl ::std::default::Default for PhysicalDeviceShadingRateImagePropertiesNV {
31233 fn default() -> Self {
31234 Self {
31235 s_type: StructureType::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV,
31236 p_next: ::std::ptr::null_mut(),
31237 shading_rate_texel_size: Extent2D::default(),
31238 shading_rate_palette_size: u32::default(),
31239 shading_rate_max_coarse_samples: u32::default(),
31240 }
31241 }
31242}
31243impl PhysicalDeviceShadingRateImagePropertiesNV {
31244 pub fn builder<'a>() -> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
31245 PhysicalDeviceShadingRateImagePropertiesNVBuilder {
31246 inner: Self::default(),
31247 marker: ::std::marker::PhantomData,
31248 }
31249 }
31250}
31251#[repr(transparent)]
31252pub struct PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
31253 inner: PhysicalDeviceShadingRateImagePropertiesNV,
31254 marker: ::std::marker::PhantomData<&'a ()>,
31255}
31256unsafe impl ExtendsPhysicalDeviceProperties2
31257 for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'_>
31258{
31259}
31260unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShadingRateImagePropertiesNV {}
31261impl<'a> ::std::ops::Deref for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
31262 type Target = PhysicalDeviceShadingRateImagePropertiesNV;
31263 fn deref(&self) -> &Self::Target {
31264 &self.inner
31265 }
31266}
31267impl<'a> ::std::ops::DerefMut for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
31268 fn deref_mut(&mut self) -> &mut Self::Target {
31269 &mut self.inner
31270 }
31271}
31272impl<'a> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
31273 pub fn shading_rate_texel_size(mut self, shading_rate_texel_size: Extent2D) -> Self {
31274 self.inner.shading_rate_texel_size = shading_rate_texel_size;
31275 self
31276 }
31277 pub fn shading_rate_palette_size(mut self, shading_rate_palette_size: u32) -> Self {
31278 self.inner.shading_rate_palette_size = shading_rate_palette_size;
31279 self
31280 }
31281 pub fn shading_rate_max_coarse_samples(mut self, shading_rate_max_coarse_samples: u32) -> Self {
31282 self.inner.shading_rate_max_coarse_samples = shading_rate_max_coarse_samples;
31283 self
31284 }
31285 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31286 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31287 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
31288 pub fn build(self) -> PhysicalDeviceShadingRateImagePropertiesNV {
31289 self.inner
31290 }
31291}
31292#[repr(C)]
31293#[cfg_attr(feature = "debug", derive(Debug))]
31294#[derive(Copy, Clone)]
31295#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceInvocationMaskFeaturesHUAWEI.html>"]
31296pub struct PhysicalDeviceInvocationMaskFeaturesHUAWEI {
31297 pub s_type: StructureType,
31298 pub p_next: *mut c_void,
31299 pub invocation_mask: Bool32,
31300}
31301impl ::std::default::Default for PhysicalDeviceInvocationMaskFeaturesHUAWEI {
31302 fn default() -> Self {
31303 Self {
31304 s_type: StructureType::PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI,
31305 p_next: ::std::ptr::null_mut(),
31306 invocation_mask: Bool32::default(),
31307 }
31308 }
31309}
31310impl PhysicalDeviceInvocationMaskFeaturesHUAWEI {
31311 pub fn builder<'a>() -> PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
31312 PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder {
31313 inner: Self::default(),
31314 marker: ::std::marker::PhantomData,
31315 }
31316 }
31317}
31318#[repr(transparent)]
31319pub struct PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
31320 inner: PhysicalDeviceInvocationMaskFeaturesHUAWEI,
31321 marker: ::std::marker::PhantomData<&'a ()>,
31322}
31323unsafe impl ExtendsPhysicalDeviceFeatures2
31324 for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'_>
31325{
31326}
31327unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInvocationMaskFeaturesHUAWEI {}
31328unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'_> {}
31329unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInvocationMaskFeaturesHUAWEI {}
31330impl<'a> ::std::ops::Deref for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
31331 type Target = PhysicalDeviceInvocationMaskFeaturesHUAWEI;
31332 fn deref(&self) -> &Self::Target {
31333 &self.inner
31334 }
31335}
31336impl<'a> ::std::ops::DerefMut for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
31337 fn deref_mut(&mut self) -> &mut Self::Target {
31338 &mut self.inner
31339 }
31340}
31341impl<'a> PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
31342 pub fn invocation_mask(mut self, invocation_mask: bool) -> Self {
31343 self.inner.invocation_mask = invocation_mask.into();
31344 self
31345 }
31346 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31347 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31348 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
31349 pub fn build(self) -> PhysicalDeviceInvocationMaskFeaturesHUAWEI {
31350 self.inner
31351 }
31352}
31353#[repr(C)]
31354#[cfg_attr(feature = "debug", derive(Debug))]
31355#[derive(Copy, Clone, Default)]
31356#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCoarseSampleLocationNV.html>"]
31357pub struct CoarseSampleLocationNV {
31358 pub pixel_x: u32,
31359 pub pixel_y: u32,
31360 pub sample: u32,
31361}
31362impl CoarseSampleLocationNV {
31363 pub fn builder<'a>() -> CoarseSampleLocationNVBuilder<'a> {
31364 CoarseSampleLocationNVBuilder {
31365 inner: Self::default(),
31366 marker: ::std::marker::PhantomData,
31367 }
31368 }
31369}
31370#[repr(transparent)]
31371pub struct CoarseSampleLocationNVBuilder<'a> {
31372 inner: CoarseSampleLocationNV,
31373 marker: ::std::marker::PhantomData<&'a ()>,
31374}
31375impl<'a> ::std::ops::Deref for CoarseSampleLocationNVBuilder<'a> {
31376 type Target = CoarseSampleLocationNV;
31377 fn deref(&self) -> &Self::Target {
31378 &self.inner
31379 }
31380}
31381impl<'a> ::std::ops::DerefMut for CoarseSampleLocationNVBuilder<'a> {
31382 fn deref_mut(&mut self) -> &mut Self::Target {
31383 &mut self.inner
31384 }
31385}
31386impl<'a> CoarseSampleLocationNVBuilder<'a> {
31387 pub fn pixel_x(mut self, pixel_x: u32) -> Self {
31388 self.inner.pixel_x = pixel_x;
31389 self
31390 }
31391 pub fn pixel_y(mut self, pixel_y: u32) -> Self {
31392 self.inner.pixel_y = pixel_y;
31393 self
31394 }
31395 pub fn sample(mut self, sample: u32) -> Self {
31396 self.inner.sample = sample;
31397 self
31398 }
31399 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31400 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31401 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
31402 pub fn build(self) -> CoarseSampleLocationNV {
31403 self.inner
31404 }
31405}
31406#[repr(C)]
31407#[cfg_attr(feature = "debug", derive(Debug))]
31408#[derive(Copy, Clone)]
31409#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCoarseSampleOrderCustomNV.html>"]
31410pub struct CoarseSampleOrderCustomNV {
31411 pub shading_rate: ShadingRatePaletteEntryNV,
31412 pub sample_count: u32,
31413 pub sample_location_count: u32,
31414 pub p_sample_locations: *const CoarseSampleLocationNV,
31415}
31416impl ::std::default::Default for CoarseSampleOrderCustomNV {
31417 fn default() -> Self {
31418 Self {
31419 shading_rate: ShadingRatePaletteEntryNV::default(),
31420 sample_count: u32::default(),
31421 sample_location_count: u32::default(),
31422 p_sample_locations: ::std::ptr::null(),
31423 }
31424 }
31425}
31426impl CoarseSampleOrderCustomNV {
31427 pub fn builder<'a>() -> CoarseSampleOrderCustomNVBuilder<'a> {
31428 CoarseSampleOrderCustomNVBuilder {
31429 inner: Self::default(),
31430 marker: ::std::marker::PhantomData,
31431 }
31432 }
31433}
31434#[repr(transparent)]
31435pub struct CoarseSampleOrderCustomNVBuilder<'a> {
31436 inner: CoarseSampleOrderCustomNV,
31437 marker: ::std::marker::PhantomData<&'a ()>,
31438}
31439impl<'a> ::std::ops::Deref for CoarseSampleOrderCustomNVBuilder<'a> {
31440 type Target = CoarseSampleOrderCustomNV;
31441 fn deref(&self) -> &Self::Target {
31442 &self.inner
31443 }
31444}
31445impl<'a> ::std::ops::DerefMut for CoarseSampleOrderCustomNVBuilder<'a> {
31446 fn deref_mut(&mut self) -> &mut Self::Target {
31447 &mut self.inner
31448 }
31449}
31450impl<'a> CoarseSampleOrderCustomNVBuilder<'a> {
31451 pub fn shading_rate(mut self, shading_rate: ShadingRatePaletteEntryNV) -> Self {
31452 self.inner.shading_rate = shading_rate;
31453 self
31454 }
31455 pub fn sample_count(mut self, sample_count: u32) -> Self {
31456 self.inner.sample_count = sample_count;
31457 self
31458 }
31459 pub fn sample_locations(mut self, sample_locations: &'a [CoarseSampleLocationNV]) -> Self {
31460 self.inner.sample_location_count = sample_locations.len() as _;
31461 self.inner.p_sample_locations = sample_locations.as_ptr();
31462 self
31463 }
31464 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31465 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31466 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
31467 pub fn build(self) -> CoarseSampleOrderCustomNV {
31468 self.inner
31469 }
31470}
31471#[repr(C)]
31472#[cfg_attr(feature = "debug", derive(Debug))]
31473#[derive(Copy, Clone)]
31474#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportCoarseSampleOrderStateCreateInfoNV.html>"]
31475pub struct PipelineViewportCoarseSampleOrderStateCreateInfoNV {
31476 pub s_type: StructureType,
31477 pub p_next: *const c_void,
31478 pub sample_order_type: CoarseSampleOrderTypeNV,
31479 pub custom_sample_order_count: u32,
31480 pub p_custom_sample_orders: *const CoarseSampleOrderCustomNV,
31481}
31482impl ::std::default::Default for PipelineViewportCoarseSampleOrderStateCreateInfoNV {
31483 fn default() -> Self {
31484 Self {
31485 s_type: StructureType::PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV,
31486 p_next: ::std::ptr::null(),
31487 sample_order_type: CoarseSampleOrderTypeNV::default(),
31488 custom_sample_order_count: u32::default(),
31489 p_custom_sample_orders: ::std::ptr::null(),
31490 }
31491 }
31492}
31493impl PipelineViewportCoarseSampleOrderStateCreateInfoNV {
31494 pub fn builder<'a>() -> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
31495 PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder {
31496 inner: Self::default(),
31497 marker: ::std::marker::PhantomData,
31498 }
31499 }
31500}
31501#[repr(transparent)]
31502pub struct PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
31503 inner: PipelineViewportCoarseSampleOrderStateCreateInfoNV,
31504 marker: ::std::marker::PhantomData<&'a ()>,
31505}
31506unsafe impl ExtendsPipelineViewportStateCreateInfo
31507 for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'_>
31508{
31509}
31510unsafe impl ExtendsPipelineViewportStateCreateInfo
31511 for PipelineViewportCoarseSampleOrderStateCreateInfoNV
31512{
31513}
31514impl<'a> ::std::ops::Deref for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
31515 type Target = PipelineViewportCoarseSampleOrderStateCreateInfoNV;
31516 fn deref(&self) -> &Self::Target {
31517 &self.inner
31518 }
31519}
31520impl<'a> ::std::ops::DerefMut for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
31521 fn deref_mut(&mut self) -> &mut Self::Target {
31522 &mut self.inner
31523 }
31524}
31525impl<'a> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
31526 pub fn sample_order_type(mut self, sample_order_type: CoarseSampleOrderTypeNV) -> Self {
31527 self.inner.sample_order_type = sample_order_type;
31528 self
31529 }
31530 pub fn custom_sample_orders(
31531 mut self,
31532 custom_sample_orders: &'a [CoarseSampleOrderCustomNV],
31533 ) -> Self {
31534 self.inner.custom_sample_order_count = custom_sample_orders.len() as _;
31535 self.inner.p_custom_sample_orders = custom_sample_orders.as_ptr();
31536 self
31537 }
31538 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31539 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31540 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
31541 pub fn build(self) -> PipelineViewportCoarseSampleOrderStateCreateInfoNV {
31542 self.inner
31543 }
31544}
31545#[repr(C)]
31546#[cfg_attr(feature = "debug", derive(Debug))]
31547#[derive(Copy, Clone)]
31548#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMeshShaderFeaturesNV.html>"]
31549pub struct PhysicalDeviceMeshShaderFeaturesNV {
31550 pub s_type: StructureType,
31551 pub p_next: *mut c_void,
31552 pub task_shader: Bool32,
31553 pub mesh_shader: Bool32,
31554}
31555impl ::std::default::Default for PhysicalDeviceMeshShaderFeaturesNV {
31556 fn default() -> Self {
31557 Self {
31558 s_type: StructureType::PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV,
31559 p_next: ::std::ptr::null_mut(),
31560 task_shader: Bool32::default(),
31561 mesh_shader: Bool32::default(),
31562 }
31563 }
31564}
31565impl PhysicalDeviceMeshShaderFeaturesNV {
31566 pub fn builder<'a>() -> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
31567 PhysicalDeviceMeshShaderFeaturesNVBuilder {
31568 inner: Self::default(),
31569 marker: ::std::marker::PhantomData,
31570 }
31571 }
31572}
31573#[repr(transparent)]
31574pub struct PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
31575 inner: PhysicalDeviceMeshShaderFeaturesNV,
31576 marker: ::std::marker::PhantomData<&'a ()>,
31577}
31578unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMeshShaderFeaturesNVBuilder<'_> {}
31579unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMeshShaderFeaturesNV {}
31580unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesNVBuilder<'_> {}
31581unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesNV {}
31582impl<'a> ::std::ops::Deref for PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
31583 type Target = PhysicalDeviceMeshShaderFeaturesNV;
31584 fn deref(&self) -> &Self::Target {
31585 &self.inner
31586 }
31587}
31588impl<'a> ::std::ops::DerefMut for PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
31589 fn deref_mut(&mut self) -> &mut Self::Target {
31590 &mut self.inner
31591 }
31592}
31593impl<'a> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
31594 pub fn task_shader(mut self, task_shader: bool) -> Self {
31595 self.inner.task_shader = task_shader.into();
31596 self
31597 }
31598 pub fn mesh_shader(mut self, mesh_shader: bool) -> Self {
31599 self.inner.mesh_shader = mesh_shader.into();
31600 self
31601 }
31602 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31603 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31604 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
31605 pub fn build(self) -> PhysicalDeviceMeshShaderFeaturesNV {
31606 self.inner
31607 }
31608}
31609#[repr(C)]
31610#[cfg_attr(feature = "debug", derive(Debug))]
31611#[derive(Copy, Clone)]
31612#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMeshShaderPropertiesNV.html>"]
31613pub struct PhysicalDeviceMeshShaderPropertiesNV {
31614 pub s_type: StructureType,
31615 pub p_next: *mut c_void,
31616 pub max_draw_mesh_tasks_count: u32,
31617 pub max_task_work_group_invocations: u32,
31618 pub max_task_work_group_size: [u32; 3],
31619 pub max_task_total_memory_size: u32,
31620 pub max_task_output_count: u32,
31621 pub max_mesh_work_group_invocations: u32,
31622 pub max_mesh_work_group_size: [u32; 3],
31623 pub max_mesh_total_memory_size: u32,
31624 pub max_mesh_output_vertices: u32,
31625 pub max_mesh_output_primitives: u32,
31626 pub max_mesh_multiview_view_count: u32,
31627 pub mesh_output_per_vertex_granularity: u32,
31628 pub mesh_output_per_primitive_granularity: u32,
31629}
31630impl ::std::default::Default for PhysicalDeviceMeshShaderPropertiesNV {
31631 fn default() -> Self {
31632 Self {
31633 s_type: StructureType::PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV,
31634 p_next: ::std::ptr::null_mut(),
31635 max_draw_mesh_tasks_count: u32::default(),
31636 max_task_work_group_invocations: u32::default(),
31637 max_task_work_group_size: unsafe { ::std::mem::zeroed() },
31638 max_task_total_memory_size: u32::default(),
31639 max_task_output_count: u32::default(),
31640 max_mesh_work_group_invocations: u32::default(),
31641 max_mesh_work_group_size: unsafe { ::std::mem::zeroed() },
31642 max_mesh_total_memory_size: u32::default(),
31643 max_mesh_output_vertices: u32::default(),
31644 max_mesh_output_primitives: u32::default(),
31645 max_mesh_multiview_view_count: u32::default(),
31646 mesh_output_per_vertex_granularity: u32::default(),
31647 mesh_output_per_primitive_granularity: u32::default(),
31648 }
31649 }
31650}
31651impl PhysicalDeviceMeshShaderPropertiesNV {
31652 pub fn builder<'a>() -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
31653 PhysicalDeviceMeshShaderPropertiesNVBuilder {
31654 inner: Self::default(),
31655 marker: ::std::marker::PhantomData,
31656 }
31657 }
31658}
31659#[repr(transparent)]
31660pub struct PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
31661 inner: PhysicalDeviceMeshShaderPropertiesNV,
31662 marker: ::std::marker::PhantomData<&'a ()>,
31663}
31664unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesNVBuilder<'_> {}
31665unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesNV {}
31666impl<'a> ::std::ops::Deref for PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
31667 type Target = PhysicalDeviceMeshShaderPropertiesNV;
31668 fn deref(&self) -> &Self::Target {
31669 &self.inner
31670 }
31671}
31672impl<'a> ::std::ops::DerefMut for PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
31673 fn deref_mut(&mut self) -> &mut Self::Target {
31674 &mut self.inner
31675 }
31676}
31677impl<'a> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
31678 pub fn max_draw_mesh_tasks_count(mut self, max_draw_mesh_tasks_count: u32) -> Self {
31679 self.inner.max_draw_mesh_tasks_count = max_draw_mesh_tasks_count;
31680 self
31681 }
31682 pub fn max_task_work_group_invocations(mut self, max_task_work_group_invocations: u32) -> Self {
31683 self.inner.max_task_work_group_invocations = max_task_work_group_invocations;
31684 self
31685 }
31686 pub fn max_task_work_group_size(mut self, max_task_work_group_size: [u32; 3]) -> Self {
31687 self.inner.max_task_work_group_size = max_task_work_group_size;
31688 self
31689 }
31690 pub fn max_task_total_memory_size(mut self, max_task_total_memory_size: u32) -> Self {
31691 self.inner.max_task_total_memory_size = max_task_total_memory_size;
31692 self
31693 }
31694 pub fn max_task_output_count(mut self, max_task_output_count: u32) -> Self {
31695 self.inner.max_task_output_count = max_task_output_count;
31696 self
31697 }
31698 pub fn max_mesh_work_group_invocations(mut self, max_mesh_work_group_invocations: u32) -> Self {
31699 self.inner.max_mesh_work_group_invocations = max_mesh_work_group_invocations;
31700 self
31701 }
31702 pub fn max_mesh_work_group_size(mut self, max_mesh_work_group_size: [u32; 3]) -> Self {
31703 self.inner.max_mesh_work_group_size = max_mesh_work_group_size;
31704 self
31705 }
31706 pub fn max_mesh_total_memory_size(mut self, max_mesh_total_memory_size: u32) -> Self {
31707 self.inner.max_mesh_total_memory_size = max_mesh_total_memory_size;
31708 self
31709 }
31710 pub fn max_mesh_output_vertices(mut self, max_mesh_output_vertices: u32) -> Self {
31711 self.inner.max_mesh_output_vertices = max_mesh_output_vertices;
31712 self
31713 }
31714 pub fn max_mesh_output_primitives(mut self, max_mesh_output_primitives: u32) -> Self {
31715 self.inner.max_mesh_output_primitives = max_mesh_output_primitives;
31716 self
31717 }
31718 pub fn max_mesh_multiview_view_count(mut self, max_mesh_multiview_view_count: u32) -> Self {
31719 self.inner.max_mesh_multiview_view_count = max_mesh_multiview_view_count;
31720 self
31721 }
31722 pub fn mesh_output_per_vertex_granularity(
31723 mut self,
31724 mesh_output_per_vertex_granularity: u32,
31725 ) -> Self {
31726 self.inner.mesh_output_per_vertex_granularity = mesh_output_per_vertex_granularity;
31727 self
31728 }
31729 pub fn mesh_output_per_primitive_granularity(
31730 mut self,
31731 mesh_output_per_primitive_granularity: u32,
31732 ) -> Self {
31733 self.inner.mesh_output_per_primitive_granularity = mesh_output_per_primitive_granularity;
31734 self
31735 }
31736 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31737 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31738 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
31739 pub fn build(self) -> PhysicalDeviceMeshShaderPropertiesNV {
31740 self.inner
31741 }
31742}
31743#[repr(C)]
31744#[cfg_attr(feature = "debug", derive(Debug))]
31745#[derive(Copy, Clone, Default)]
31746#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrawMeshTasksIndirectCommandNV.html>"]
31747pub struct DrawMeshTasksIndirectCommandNV {
31748 pub task_count: u32,
31749 pub first_task: u32,
31750}
31751impl DrawMeshTasksIndirectCommandNV {
31752 pub fn builder<'a>() -> DrawMeshTasksIndirectCommandNVBuilder<'a> {
31753 DrawMeshTasksIndirectCommandNVBuilder {
31754 inner: Self::default(),
31755 marker: ::std::marker::PhantomData,
31756 }
31757 }
31758}
31759#[repr(transparent)]
31760pub struct DrawMeshTasksIndirectCommandNVBuilder<'a> {
31761 inner: DrawMeshTasksIndirectCommandNV,
31762 marker: ::std::marker::PhantomData<&'a ()>,
31763}
31764impl<'a> ::std::ops::Deref for DrawMeshTasksIndirectCommandNVBuilder<'a> {
31765 type Target = DrawMeshTasksIndirectCommandNV;
31766 fn deref(&self) -> &Self::Target {
31767 &self.inner
31768 }
31769}
31770impl<'a> ::std::ops::DerefMut for DrawMeshTasksIndirectCommandNVBuilder<'a> {
31771 fn deref_mut(&mut self) -> &mut Self::Target {
31772 &mut self.inner
31773 }
31774}
31775impl<'a> DrawMeshTasksIndirectCommandNVBuilder<'a> {
31776 pub fn task_count(mut self, task_count: u32) -> Self {
31777 self.inner.task_count = task_count;
31778 self
31779 }
31780 pub fn first_task(mut self, first_task: u32) -> Self {
31781 self.inner.first_task = first_task;
31782 self
31783 }
31784 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31785 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31786 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
31787 pub fn build(self) -> DrawMeshTasksIndirectCommandNV {
31788 self.inner
31789 }
31790}
31791#[repr(C)]
31792#[cfg_attr(feature = "debug", derive(Debug))]
31793#[derive(Copy, Clone)]
31794#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRayTracingShaderGroupCreateInfoNV.html>"]
31795pub struct RayTracingShaderGroupCreateInfoNV {
31796 pub s_type: StructureType,
31797 pub p_next: *const c_void,
31798 pub ty: RayTracingShaderGroupTypeKHR,
31799 pub general_shader: u32,
31800 pub closest_hit_shader: u32,
31801 pub any_hit_shader: u32,
31802 pub intersection_shader: u32,
31803}
31804impl ::std::default::Default for RayTracingShaderGroupCreateInfoNV {
31805 fn default() -> Self {
31806 Self {
31807 s_type: StructureType::RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV,
31808 p_next: ::std::ptr::null(),
31809 ty: RayTracingShaderGroupTypeKHR::default(),
31810 general_shader: u32::default(),
31811 closest_hit_shader: u32::default(),
31812 any_hit_shader: u32::default(),
31813 intersection_shader: u32::default(),
31814 }
31815 }
31816}
31817impl RayTracingShaderGroupCreateInfoNV {
31818 pub fn builder<'a>() -> RayTracingShaderGroupCreateInfoNVBuilder<'a> {
31819 RayTracingShaderGroupCreateInfoNVBuilder {
31820 inner: Self::default(),
31821 marker: ::std::marker::PhantomData,
31822 }
31823 }
31824}
31825#[repr(transparent)]
31826pub struct RayTracingShaderGroupCreateInfoNVBuilder<'a> {
31827 inner: RayTracingShaderGroupCreateInfoNV,
31828 marker: ::std::marker::PhantomData<&'a ()>,
31829}
31830impl<'a> ::std::ops::Deref for RayTracingShaderGroupCreateInfoNVBuilder<'a> {
31831 type Target = RayTracingShaderGroupCreateInfoNV;
31832 fn deref(&self) -> &Self::Target {
31833 &self.inner
31834 }
31835}
31836impl<'a> ::std::ops::DerefMut for RayTracingShaderGroupCreateInfoNVBuilder<'a> {
31837 fn deref_mut(&mut self) -> &mut Self::Target {
31838 &mut self.inner
31839 }
31840}
31841impl<'a> RayTracingShaderGroupCreateInfoNVBuilder<'a> {
31842 pub fn ty(mut self, ty: RayTracingShaderGroupTypeKHR) -> Self {
31843 self.inner.ty = ty;
31844 self
31845 }
31846 pub fn general_shader(mut self, general_shader: u32) -> Self {
31847 self.inner.general_shader = general_shader;
31848 self
31849 }
31850 pub fn closest_hit_shader(mut self, closest_hit_shader: u32) -> Self {
31851 self.inner.closest_hit_shader = closest_hit_shader;
31852 self
31853 }
31854 pub fn any_hit_shader(mut self, any_hit_shader: u32) -> Self {
31855 self.inner.any_hit_shader = any_hit_shader;
31856 self
31857 }
31858 pub fn intersection_shader(mut self, intersection_shader: u32) -> Self {
31859 self.inner.intersection_shader = intersection_shader;
31860 self
31861 }
31862 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31863 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31864 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
31865 pub fn build(self) -> RayTracingShaderGroupCreateInfoNV {
31866 self.inner
31867 }
31868}
31869#[repr(C)]
31870#[cfg_attr(feature = "debug", derive(Debug))]
31871#[derive(Copy, Clone)]
31872#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRayTracingShaderGroupCreateInfoKHR.html>"]
31873pub struct RayTracingShaderGroupCreateInfoKHR {
31874 pub s_type: StructureType,
31875 pub p_next: *const c_void,
31876 pub ty: RayTracingShaderGroupTypeKHR,
31877 pub general_shader: u32,
31878 pub closest_hit_shader: u32,
31879 pub any_hit_shader: u32,
31880 pub intersection_shader: u32,
31881 pub p_shader_group_capture_replay_handle: *const c_void,
31882}
31883impl ::std::default::Default for RayTracingShaderGroupCreateInfoKHR {
31884 fn default() -> Self {
31885 Self {
31886 s_type: StructureType::RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR,
31887 p_next: ::std::ptr::null(),
31888 ty: RayTracingShaderGroupTypeKHR::default(),
31889 general_shader: u32::default(),
31890 closest_hit_shader: u32::default(),
31891 any_hit_shader: u32::default(),
31892 intersection_shader: u32::default(),
31893 p_shader_group_capture_replay_handle: ::std::ptr::null(),
31894 }
31895 }
31896}
31897impl RayTracingShaderGroupCreateInfoKHR {
31898 pub fn builder<'a>() -> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
31899 RayTracingShaderGroupCreateInfoKHRBuilder {
31900 inner: Self::default(),
31901 marker: ::std::marker::PhantomData,
31902 }
31903 }
31904}
31905#[repr(transparent)]
31906pub struct RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
31907 inner: RayTracingShaderGroupCreateInfoKHR,
31908 marker: ::std::marker::PhantomData<&'a ()>,
31909}
31910impl<'a> ::std::ops::Deref for RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
31911 type Target = RayTracingShaderGroupCreateInfoKHR;
31912 fn deref(&self) -> &Self::Target {
31913 &self.inner
31914 }
31915}
31916impl<'a> ::std::ops::DerefMut for RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
31917 fn deref_mut(&mut self) -> &mut Self::Target {
31918 &mut self.inner
31919 }
31920}
31921impl<'a> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
31922 pub fn ty(mut self, ty: RayTracingShaderGroupTypeKHR) -> Self {
31923 self.inner.ty = ty;
31924 self
31925 }
31926 pub fn general_shader(mut self, general_shader: u32) -> Self {
31927 self.inner.general_shader = general_shader;
31928 self
31929 }
31930 pub fn closest_hit_shader(mut self, closest_hit_shader: u32) -> Self {
31931 self.inner.closest_hit_shader = closest_hit_shader;
31932 self
31933 }
31934 pub fn any_hit_shader(mut self, any_hit_shader: u32) -> Self {
31935 self.inner.any_hit_shader = any_hit_shader;
31936 self
31937 }
31938 pub fn intersection_shader(mut self, intersection_shader: u32) -> Self {
31939 self.inner.intersection_shader = intersection_shader;
31940 self
31941 }
31942 pub fn shader_group_capture_replay_handle(
31943 mut self,
31944 shader_group_capture_replay_handle: *const c_void,
31945 ) -> Self {
31946 self.inner.p_shader_group_capture_replay_handle = shader_group_capture_replay_handle;
31947 self
31948 }
31949 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31950 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31951 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
31952 pub fn build(self) -> RayTracingShaderGroupCreateInfoKHR {
31953 self.inner
31954 }
31955}
31956#[repr(C)]
31957#[cfg_attr(feature = "debug", derive(Debug))]
31958#[derive(Copy, Clone)]
31959#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRayTracingPipelineCreateInfoNV.html>"]
31960pub struct RayTracingPipelineCreateInfoNV {
31961 pub s_type: StructureType,
31962 pub p_next: *const c_void,
31963 pub flags: PipelineCreateFlags,
31964 pub stage_count: u32,
31965 pub p_stages: *const PipelineShaderStageCreateInfo,
31966 pub group_count: u32,
31967 pub p_groups: *const RayTracingShaderGroupCreateInfoNV,
31968 pub max_recursion_depth: u32,
31969 pub layout: PipelineLayout,
31970 pub base_pipeline_handle: Pipeline,
31971 pub base_pipeline_index: i32,
31972}
31973impl ::std::default::Default for RayTracingPipelineCreateInfoNV {
31974 fn default() -> Self {
31975 Self {
31976 s_type: StructureType::RAY_TRACING_PIPELINE_CREATE_INFO_NV,
31977 p_next: ::std::ptr::null(),
31978 flags: PipelineCreateFlags::default(),
31979 stage_count: u32::default(),
31980 p_stages: ::std::ptr::null(),
31981 group_count: u32::default(),
31982 p_groups: ::std::ptr::null(),
31983 max_recursion_depth: u32::default(),
31984 layout: PipelineLayout::default(),
31985 base_pipeline_handle: Pipeline::default(),
31986 base_pipeline_index: i32::default(),
31987 }
31988 }
31989}
31990impl RayTracingPipelineCreateInfoNV {
31991 pub fn builder<'a>() -> RayTracingPipelineCreateInfoNVBuilder<'a> {
31992 RayTracingPipelineCreateInfoNVBuilder {
31993 inner: Self::default(),
31994 marker: ::std::marker::PhantomData,
31995 }
31996 }
31997}
31998#[repr(transparent)]
31999pub struct RayTracingPipelineCreateInfoNVBuilder<'a> {
32000 inner: RayTracingPipelineCreateInfoNV,
32001 marker: ::std::marker::PhantomData<&'a ()>,
32002}
32003pub unsafe trait ExtendsRayTracingPipelineCreateInfoNV {}
32004impl<'a> ::std::ops::Deref for RayTracingPipelineCreateInfoNVBuilder<'a> {
32005 type Target = RayTracingPipelineCreateInfoNV;
32006 fn deref(&self) -> &Self::Target {
32007 &self.inner
32008 }
32009}
32010impl<'a> ::std::ops::DerefMut for RayTracingPipelineCreateInfoNVBuilder<'a> {
32011 fn deref_mut(&mut self) -> &mut Self::Target {
32012 &mut self.inner
32013 }
32014}
32015impl<'a> RayTracingPipelineCreateInfoNVBuilder<'a> {
32016 pub fn flags(mut self, flags: PipelineCreateFlags) -> Self {
32017 self.inner.flags = flags;
32018 self
32019 }
32020 pub fn stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self {
32021 self.inner.stage_count = stages.len() as _;
32022 self.inner.p_stages = stages.as_ptr();
32023 self
32024 }
32025 pub fn groups(mut self, groups: &'a [RayTracingShaderGroupCreateInfoNV]) -> Self {
32026 self.inner.group_count = groups.len() as _;
32027 self.inner.p_groups = groups.as_ptr();
32028 self
32029 }
32030 pub fn max_recursion_depth(mut self, max_recursion_depth: u32) -> Self {
32031 self.inner.max_recursion_depth = max_recursion_depth;
32032 self
32033 }
32034 pub fn layout(mut self, layout: PipelineLayout) -> Self {
32035 self.inner.layout = layout;
32036 self
32037 }
32038 pub fn base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self {
32039 self.inner.base_pipeline_handle = base_pipeline_handle;
32040 self
32041 }
32042 pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self {
32043 self.inner.base_pipeline_index = base_pipeline_index;
32044 self
32045 }
32046 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
32047 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
32048 #[doc = r" valid extension structs can be pushed into the chain."]
32049 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
32050 #[doc = r" chain will look like `A -> D -> B -> C`."]
32051 pub fn push_next<T: ExtendsRayTracingPipelineCreateInfoNV>(mut self, next: &'a mut T) -> Self {
32052 unsafe {
32053 let next_ptr = <*const T>::cast(next);
32054 let last_next = ptr_chain_iter(next).last().unwrap();
32055 (*last_next).p_next = self.inner.p_next as _;
32056 self.inner.p_next = next_ptr;
32057 }
32058 self
32059 }
32060 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32061 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32062 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
32063 pub fn build(self) -> RayTracingPipelineCreateInfoNV {
32064 self.inner
32065 }
32066}
32067#[repr(C)]
32068#[cfg_attr(feature = "debug", derive(Debug))]
32069#[derive(Copy, Clone)]
32070#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRayTracingPipelineCreateInfoKHR.html>"]
32071pub struct RayTracingPipelineCreateInfoKHR {
32072 pub s_type: StructureType,
32073 pub p_next: *const c_void,
32074 pub flags: PipelineCreateFlags,
32075 pub stage_count: u32,
32076 pub p_stages: *const PipelineShaderStageCreateInfo,
32077 pub group_count: u32,
32078 pub p_groups: *const RayTracingShaderGroupCreateInfoKHR,
32079 pub max_pipeline_ray_recursion_depth: u32,
32080 pub p_library_info: *const PipelineLibraryCreateInfoKHR,
32081 pub p_library_interface: *const RayTracingPipelineInterfaceCreateInfoKHR,
32082 pub p_dynamic_state: *const PipelineDynamicStateCreateInfo,
32083 pub layout: PipelineLayout,
32084 pub base_pipeline_handle: Pipeline,
32085 pub base_pipeline_index: i32,
32086}
32087impl ::std::default::Default for RayTracingPipelineCreateInfoKHR {
32088 fn default() -> Self {
32089 Self {
32090 s_type: StructureType::RAY_TRACING_PIPELINE_CREATE_INFO_KHR,
32091 p_next: ::std::ptr::null(),
32092 flags: PipelineCreateFlags::default(),
32093 stage_count: u32::default(),
32094 p_stages: ::std::ptr::null(),
32095 group_count: u32::default(),
32096 p_groups: ::std::ptr::null(),
32097 max_pipeline_ray_recursion_depth: u32::default(),
32098 p_library_info: ::std::ptr::null(),
32099 p_library_interface: ::std::ptr::null(),
32100 p_dynamic_state: ::std::ptr::null(),
32101 layout: PipelineLayout::default(),
32102 base_pipeline_handle: Pipeline::default(),
32103 base_pipeline_index: i32::default(),
32104 }
32105 }
32106}
32107impl RayTracingPipelineCreateInfoKHR {
32108 pub fn builder<'a>() -> RayTracingPipelineCreateInfoKHRBuilder<'a> {
32109 RayTracingPipelineCreateInfoKHRBuilder {
32110 inner: Self::default(),
32111 marker: ::std::marker::PhantomData,
32112 }
32113 }
32114}
32115#[repr(transparent)]
32116pub struct RayTracingPipelineCreateInfoKHRBuilder<'a> {
32117 inner: RayTracingPipelineCreateInfoKHR,
32118 marker: ::std::marker::PhantomData<&'a ()>,
32119}
32120pub unsafe trait ExtendsRayTracingPipelineCreateInfoKHR {}
32121impl<'a> ::std::ops::Deref for RayTracingPipelineCreateInfoKHRBuilder<'a> {
32122 type Target = RayTracingPipelineCreateInfoKHR;
32123 fn deref(&self) -> &Self::Target {
32124 &self.inner
32125 }
32126}
32127impl<'a> ::std::ops::DerefMut for RayTracingPipelineCreateInfoKHRBuilder<'a> {
32128 fn deref_mut(&mut self) -> &mut Self::Target {
32129 &mut self.inner
32130 }
32131}
32132impl<'a> RayTracingPipelineCreateInfoKHRBuilder<'a> {
32133 pub fn flags(mut self, flags: PipelineCreateFlags) -> Self {
32134 self.inner.flags = flags;
32135 self
32136 }
32137 pub fn stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self {
32138 self.inner.stage_count = stages.len() as _;
32139 self.inner.p_stages = stages.as_ptr();
32140 self
32141 }
32142 pub fn groups(mut self, groups: &'a [RayTracingShaderGroupCreateInfoKHR]) -> Self {
32143 self.inner.group_count = groups.len() as _;
32144 self.inner.p_groups = groups.as_ptr();
32145 self
32146 }
32147 pub fn max_pipeline_ray_recursion_depth(
32148 mut self,
32149 max_pipeline_ray_recursion_depth: u32,
32150 ) -> Self {
32151 self.inner.max_pipeline_ray_recursion_depth = max_pipeline_ray_recursion_depth;
32152 self
32153 }
32154 pub fn library_info(mut self, library_info: &'a PipelineLibraryCreateInfoKHR) -> Self {
32155 self.inner.p_library_info = library_info;
32156 self
32157 }
32158 pub fn library_interface(
32159 mut self,
32160 library_interface: &'a RayTracingPipelineInterfaceCreateInfoKHR,
32161 ) -> Self {
32162 self.inner.p_library_interface = library_interface;
32163 self
32164 }
32165 pub fn dynamic_state(mut self, dynamic_state: &'a PipelineDynamicStateCreateInfo) -> Self {
32166 self.inner.p_dynamic_state = dynamic_state;
32167 self
32168 }
32169 pub fn layout(mut self, layout: PipelineLayout) -> Self {
32170 self.inner.layout = layout;
32171 self
32172 }
32173 pub fn base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self {
32174 self.inner.base_pipeline_handle = base_pipeline_handle;
32175 self
32176 }
32177 pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self {
32178 self.inner.base_pipeline_index = base_pipeline_index;
32179 self
32180 }
32181 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
32182 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
32183 #[doc = r" valid extension structs can be pushed into the chain."]
32184 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
32185 #[doc = r" chain will look like `A -> D -> B -> C`."]
32186 pub fn push_next<T: ExtendsRayTracingPipelineCreateInfoKHR>(mut self, next: &'a mut T) -> Self {
32187 unsafe {
32188 let next_ptr = <*const T>::cast(next);
32189 let last_next = ptr_chain_iter(next).last().unwrap();
32190 (*last_next).p_next = self.inner.p_next as _;
32191 self.inner.p_next = next_ptr;
32192 }
32193 self
32194 }
32195 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32196 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32197 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
32198 pub fn build(self) -> RayTracingPipelineCreateInfoKHR {
32199 self.inner
32200 }
32201}
32202#[repr(C)]
32203#[cfg_attr(feature = "debug", derive(Debug))]
32204#[derive(Copy, Clone)]
32205#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeometryTrianglesNV.html>"]
32206pub struct GeometryTrianglesNV {
32207 pub s_type: StructureType,
32208 pub p_next: *const c_void,
32209 pub vertex_data: Buffer,
32210 pub vertex_offset: DeviceSize,
32211 pub vertex_count: u32,
32212 pub vertex_stride: DeviceSize,
32213 pub vertex_format: Format,
32214 pub index_data: Buffer,
32215 pub index_offset: DeviceSize,
32216 pub index_count: u32,
32217 pub index_type: IndexType,
32218 pub transform_data: Buffer,
32219 pub transform_offset: DeviceSize,
32220}
32221impl ::std::default::Default for GeometryTrianglesNV {
32222 fn default() -> Self {
32223 Self {
32224 s_type: StructureType::GEOMETRY_TRIANGLES_NV,
32225 p_next: ::std::ptr::null(),
32226 vertex_data: Buffer::default(),
32227 vertex_offset: DeviceSize::default(),
32228 vertex_count: u32::default(),
32229 vertex_stride: DeviceSize::default(),
32230 vertex_format: Format::default(),
32231 index_data: Buffer::default(),
32232 index_offset: DeviceSize::default(),
32233 index_count: u32::default(),
32234 index_type: IndexType::default(),
32235 transform_data: Buffer::default(),
32236 transform_offset: DeviceSize::default(),
32237 }
32238 }
32239}
32240impl GeometryTrianglesNV {
32241 pub fn builder<'a>() -> GeometryTrianglesNVBuilder<'a> {
32242 GeometryTrianglesNVBuilder {
32243 inner: Self::default(),
32244 marker: ::std::marker::PhantomData,
32245 }
32246 }
32247}
32248#[repr(transparent)]
32249pub struct GeometryTrianglesNVBuilder<'a> {
32250 inner: GeometryTrianglesNV,
32251 marker: ::std::marker::PhantomData<&'a ()>,
32252}
32253impl<'a> ::std::ops::Deref for GeometryTrianglesNVBuilder<'a> {
32254 type Target = GeometryTrianglesNV;
32255 fn deref(&self) -> &Self::Target {
32256 &self.inner
32257 }
32258}
32259impl<'a> ::std::ops::DerefMut for GeometryTrianglesNVBuilder<'a> {
32260 fn deref_mut(&mut self) -> &mut Self::Target {
32261 &mut self.inner
32262 }
32263}
32264impl<'a> GeometryTrianglesNVBuilder<'a> {
32265 pub fn vertex_data(mut self, vertex_data: Buffer) -> Self {
32266 self.inner.vertex_data = vertex_data;
32267 self
32268 }
32269 pub fn vertex_offset(mut self, vertex_offset: DeviceSize) -> Self {
32270 self.inner.vertex_offset = vertex_offset;
32271 self
32272 }
32273 pub fn vertex_count(mut self, vertex_count: u32) -> Self {
32274 self.inner.vertex_count = vertex_count;
32275 self
32276 }
32277 pub fn vertex_stride(mut self, vertex_stride: DeviceSize) -> Self {
32278 self.inner.vertex_stride = vertex_stride;
32279 self
32280 }
32281 pub fn vertex_format(mut self, vertex_format: Format) -> Self {
32282 self.inner.vertex_format = vertex_format;
32283 self
32284 }
32285 pub fn index_data(mut self, index_data: Buffer) -> Self {
32286 self.inner.index_data = index_data;
32287 self
32288 }
32289 pub fn index_offset(mut self, index_offset: DeviceSize) -> Self {
32290 self.inner.index_offset = index_offset;
32291 self
32292 }
32293 pub fn index_count(mut self, index_count: u32) -> Self {
32294 self.inner.index_count = index_count;
32295 self
32296 }
32297 pub fn index_type(mut self, index_type: IndexType) -> Self {
32298 self.inner.index_type = index_type;
32299 self
32300 }
32301 pub fn transform_data(mut self, transform_data: Buffer) -> Self {
32302 self.inner.transform_data = transform_data;
32303 self
32304 }
32305 pub fn transform_offset(mut self, transform_offset: DeviceSize) -> Self {
32306 self.inner.transform_offset = transform_offset;
32307 self
32308 }
32309 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32310 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32311 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
32312 pub fn build(self) -> GeometryTrianglesNV {
32313 self.inner
32314 }
32315}
32316#[repr(C)]
32317#[cfg_attr(feature = "debug", derive(Debug))]
32318#[derive(Copy, Clone)]
32319#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeometryAABBNV.html>"]
32320pub struct GeometryAABBNV {
32321 pub s_type: StructureType,
32322 pub p_next: *const c_void,
32323 pub aabb_data: Buffer,
32324 pub num_aab_bs: u32,
32325 pub stride: u32,
32326 pub offset: DeviceSize,
32327}
32328impl ::std::default::Default for GeometryAABBNV {
32329 fn default() -> Self {
32330 Self {
32331 s_type: StructureType::GEOMETRY_AABB_NV,
32332 p_next: ::std::ptr::null(),
32333 aabb_data: Buffer::default(),
32334 num_aab_bs: u32::default(),
32335 stride: u32::default(),
32336 offset: DeviceSize::default(),
32337 }
32338 }
32339}
32340impl GeometryAABBNV {
32341 pub fn builder<'a>() -> GeometryAABBNVBuilder<'a> {
32342 GeometryAABBNVBuilder {
32343 inner: Self::default(),
32344 marker: ::std::marker::PhantomData,
32345 }
32346 }
32347}
32348#[repr(transparent)]
32349pub struct GeometryAABBNVBuilder<'a> {
32350 inner: GeometryAABBNV,
32351 marker: ::std::marker::PhantomData<&'a ()>,
32352}
32353impl<'a> ::std::ops::Deref for GeometryAABBNVBuilder<'a> {
32354 type Target = GeometryAABBNV;
32355 fn deref(&self) -> &Self::Target {
32356 &self.inner
32357 }
32358}
32359impl<'a> ::std::ops::DerefMut for GeometryAABBNVBuilder<'a> {
32360 fn deref_mut(&mut self) -> &mut Self::Target {
32361 &mut self.inner
32362 }
32363}
32364impl<'a> GeometryAABBNVBuilder<'a> {
32365 pub fn aabb_data(mut self, aabb_data: Buffer) -> Self {
32366 self.inner.aabb_data = aabb_data;
32367 self
32368 }
32369 pub fn num_aab_bs(mut self, num_aab_bs: u32) -> Self {
32370 self.inner.num_aab_bs = num_aab_bs;
32371 self
32372 }
32373 pub fn stride(mut self, stride: u32) -> Self {
32374 self.inner.stride = stride;
32375 self
32376 }
32377 pub fn offset(mut self, offset: DeviceSize) -> Self {
32378 self.inner.offset = offset;
32379 self
32380 }
32381 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32382 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32383 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
32384 pub fn build(self) -> GeometryAABBNV {
32385 self.inner
32386 }
32387}
32388#[repr(C)]
32389#[cfg_attr(feature = "debug", derive(Debug))]
32390#[derive(Copy, Clone, Default)]
32391#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeometryDataNV.html>"]
32392pub struct GeometryDataNV {
32393 pub triangles: GeometryTrianglesNV,
32394 pub aabbs: GeometryAABBNV,
32395}
32396impl GeometryDataNV {
32397 pub fn builder<'a>() -> GeometryDataNVBuilder<'a> {
32398 GeometryDataNVBuilder {
32399 inner: Self::default(),
32400 marker: ::std::marker::PhantomData,
32401 }
32402 }
32403}
32404#[repr(transparent)]
32405pub struct GeometryDataNVBuilder<'a> {
32406 inner: GeometryDataNV,
32407 marker: ::std::marker::PhantomData<&'a ()>,
32408}
32409impl<'a> ::std::ops::Deref for GeometryDataNVBuilder<'a> {
32410 type Target = GeometryDataNV;
32411 fn deref(&self) -> &Self::Target {
32412 &self.inner
32413 }
32414}
32415impl<'a> ::std::ops::DerefMut for GeometryDataNVBuilder<'a> {
32416 fn deref_mut(&mut self) -> &mut Self::Target {
32417 &mut self.inner
32418 }
32419}
32420impl<'a> GeometryDataNVBuilder<'a> {
32421 pub fn triangles(mut self, triangles: GeometryTrianglesNV) -> Self {
32422 self.inner.triangles = triangles;
32423 self
32424 }
32425 pub fn aabbs(mut self, aabbs: GeometryAABBNV) -> Self {
32426 self.inner.aabbs = aabbs;
32427 self
32428 }
32429 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32430 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32431 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
32432 pub fn build(self) -> GeometryDataNV {
32433 self.inner
32434 }
32435}
32436#[repr(C)]
32437#[cfg_attr(feature = "debug", derive(Debug))]
32438#[derive(Copy, Clone)]
32439#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeometryNV.html>"]
32440pub struct GeometryNV {
32441 pub s_type: StructureType,
32442 pub p_next: *const c_void,
32443 pub geometry_type: GeometryTypeKHR,
32444 pub geometry: GeometryDataNV,
32445 pub flags: GeometryFlagsKHR,
32446}
32447impl ::std::default::Default for GeometryNV {
32448 fn default() -> Self {
32449 Self {
32450 s_type: StructureType::GEOMETRY_NV,
32451 p_next: ::std::ptr::null(),
32452 geometry_type: GeometryTypeKHR::default(),
32453 geometry: GeometryDataNV::default(),
32454 flags: GeometryFlagsKHR::default(),
32455 }
32456 }
32457}
32458impl GeometryNV {
32459 pub fn builder<'a>() -> GeometryNVBuilder<'a> {
32460 GeometryNVBuilder {
32461 inner: Self::default(),
32462 marker: ::std::marker::PhantomData,
32463 }
32464 }
32465}
32466#[repr(transparent)]
32467pub struct GeometryNVBuilder<'a> {
32468 inner: GeometryNV,
32469 marker: ::std::marker::PhantomData<&'a ()>,
32470}
32471impl<'a> ::std::ops::Deref for GeometryNVBuilder<'a> {
32472 type Target = GeometryNV;
32473 fn deref(&self) -> &Self::Target {
32474 &self.inner
32475 }
32476}
32477impl<'a> ::std::ops::DerefMut for GeometryNVBuilder<'a> {
32478 fn deref_mut(&mut self) -> &mut Self::Target {
32479 &mut self.inner
32480 }
32481}
32482impl<'a> GeometryNVBuilder<'a> {
32483 pub fn geometry_type(mut self, geometry_type: GeometryTypeKHR) -> Self {
32484 self.inner.geometry_type = geometry_type;
32485 self
32486 }
32487 pub fn geometry(mut self, geometry: GeometryDataNV) -> Self {
32488 self.inner.geometry = geometry;
32489 self
32490 }
32491 pub fn flags(mut self, flags: GeometryFlagsKHR) -> Self {
32492 self.inner.flags = flags;
32493 self
32494 }
32495 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32496 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32497 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
32498 pub fn build(self) -> GeometryNV {
32499 self.inner
32500 }
32501}
32502#[repr(C)]
32503#[cfg_attr(feature = "debug", derive(Debug))]
32504#[derive(Copy, Clone)]
32505#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureInfoNV.html>"]
32506pub struct AccelerationStructureInfoNV {
32507 pub s_type: StructureType,
32508 pub p_next: *const c_void,
32509 pub ty: AccelerationStructureTypeNV,
32510 pub flags: BuildAccelerationStructureFlagsNV,
32511 pub instance_count: u32,
32512 pub geometry_count: u32,
32513 pub p_geometries: *const GeometryNV,
32514}
32515impl ::std::default::Default for AccelerationStructureInfoNV {
32516 fn default() -> Self {
32517 Self {
32518 s_type: StructureType::ACCELERATION_STRUCTURE_INFO_NV,
32519 p_next: ::std::ptr::null(),
32520 ty: AccelerationStructureTypeNV::default(),
32521 flags: BuildAccelerationStructureFlagsNV::default(),
32522 instance_count: u32::default(),
32523 geometry_count: u32::default(),
32524 p_geometries: ::std::ptr::null(),
32525 }
32526 }
32527}
32528impl AccelerationStructureInfoNV {
32529 pub fn builder<'a>() -> AccelerationStructureInfoNVBuilder<'a> {
32530 AccelerationStructureInfoNVBuilder {
32531 inner: Self::default(),
32532 marker: ::std::marker::PhantomData,
32533 }
32534 }
32535}
32536#[repr(transparent)]
32537pub struct AccelerationStructureInfoNVBuilder<'a> {
32538 inner: AccelerationStructureInfoNV,
32539 marker: ::std::marker::PhantomData<&'a ()>,
32540}
32541impl<'a> ::std::ops::Deref for AccelerationStructureInfoNVBuilder<'a> {
32542 type Target = AccelerationStructureInfoNV;
32543 fn deref(&self) -> &Self::Target {
32544 &self.inner
32545 }
32546}
32547impl<'a> ::std::ops::DerefMut for AccelerationStructureInfoNVBuilder<'a> {
32548 fn deref_mut(&mut self) -> &mut Self::Target {
32549 &mut self.inner
32550 }
32551}
32552impl<'a> AccelerationStructureInfoNVBuilder<'a> {
32553 pub fn ty(mut self, ty: AccelerationStructureTypeNV) -> Self {
32554 self.inner.ty = ty;
32555 self
32556 }
32557 pub fn flags(mut self, flags: BuildAccelerationStructureFlagsNV) -> Self {
32558 self.inner.flags = flags;
32559 self
32560 }
32561 pub fn instance_count(mut self, instance_count: u32) -> Self {
32562 self.inner.instance_count = instance_count;
32563 self
32564 }
32565 pub fn geometries(mut self, geometries: &'a [GeometryNV]) -> Self {
32566 self.inner.geometry_count = geometries.len() as _;
32567 self.inner.p_geometries = geometries.as_ptr();
32568 self
32569 }
32570 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32571 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32572 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
32573 pub fn build(self) -> AccelerationStructureInfoNV {
32574 self.inner
32575 }
32576}
32577#[repr(C)]
32578#[cfg_attr(feature = "debug", derive(Debug))]
32579#[derive(Copy, Clone)]
32580#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureCreateInfoNV.html>"]
32581pub struct AccelerationStructureCreateInfoNV {
32582 pub s_type: StructureType,
32583 pub p_next: *const c_void,
32584 pub compacted_size: DeviceSize,
32585 pub info: AccelerationStructureInfoNV,
32586}
32587impl ::std::default::Default for AccelerationStructureCreateInfoNV {
32588 fn default() -> Self {
32589 Self {
32590 s_type: StructureType::ACCELERATION_STRUCTURE_CREATE_INFO_NV,
32591 p_next: ::std::ptr::null(),
32592 compacted_size: DeviceSize::default(),
32593 info: AccelerationStructureInfoNV::default(),
32594 }
32595 }
32596}
32597impl AccelerationStructureCreateInfoNV {
32598 pub fn builder<'a>() -> AccelerationStructureCreateInfoNVBuilder<'a> {
32599 AccelerationStructureCreateInfoNVBuilder {
32600 inner: Self::default(),
32601 marker: ::std::marker::PhantomData,
32602 }
32603 }
32604}
32605#[repr(transparent)]
32606pub struct AccelerationStructureCreateInfoNVBuilder<'a> {
32607 inner: AccelerationStructureCreateInfoNV,
32608 marker: ::std::marker::PhantomData<&'a ()>,
32609}
32610impl<'a> ::std::ops::Deref for AccelerationStructureCreateInfoNVBuilder<'a> {
32611 type Target = AccelerationStructureCreateInfoNV;
32612 fn deref(&self) -> &Self::Target {
32613 &self.inner
32614 }
32615}
32616impl<'a> ::std::ops::DerefMut for AccelerationStructureCreateInfoNVBuilder<'a> {
32617 fn deref_mut(&mut self) -> &mut Self::Target {
32618 &mut self.inner
32619 }
32620}
32621impl<'a> AccelerationStructureCreateInfoNVBuilder<'a> {
32622 pub fn compacted_size(mut self, compacted_size: DeviceSize) -> Self {
32623 self.inner.compacted_size = compacted_size;
32624 self
32625 }
32626 pub fn info(mut self, info: AccelerationStructureInfoNV) -> Self {
32627 self.inner.info = info;
32628 self
32629 }
32630 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32631 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32632 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
32633 pub fn build(self) -> AccelerationStructureCreateInfoNV {
32634 self.inner
32635 }
32636}
32637#[repr(C)]
32638#[cfg_attr(feature = "debug", derive(Debug))]
32639#[derive(Copy, Clone)]
32640#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindAccelerationStructureMemoryInfoNV.html>"]
32641pub struct BindAccelerationStructureMemoryInfoNV {
32642 pub s_type: StructureType,
32643 pub p_next: *const c_void,
32644 pub acceleration_structure: AccelerationStructureNV,
32645 pub memory: DeviceMemory,
32646 pub memory_offset: DeviceSize,
32647 pub device_index_count: u32,
32648 pub p_device_indices: *const u32,
32649}
32650impl ::std::default::Default for BindAccelerationStructureMemoryInfoNV {
32651 fn default() -> Self {
32652 Self {
32653 s_type: StructureType::BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV,
32654 p_next: ::std::ptr::null(),
32655 acceleration_structure: AccelerationStructureNV::default(),
32656 memory: DeviceMemory::default(),
32657 memory_offset: DeviceSize::default(),
32658 device_index_count: u32::default(),
32659 p_device_indices: ::std::ptr::null(),
32660 }
32661 }
32662}
32663impl BindAccelerationStructureMemoryInfoNV {
32664 pub fn builder<'a>() -> BindAccelerationStructureMemoryInfoNVBuilder<'a> {
32665 BindAccelerationStructureMemoryInfoNVBuilder {
32666 inner: Self::default(),
32667 marker: ::std::marker::PhantomData,
32668 }
32669 }
32670}
32671#[repr(transparent)]
32672pub struct BindAccelerationStructureMemoryInfoNVBuilder<'a> {
32673 inner: BindAccelerationStructureMemoryInfoNV,
32674 marker: ::std::marker::PhantomData<&'a ()>,
32675}
32676impl<'a> ::std::ops::Deref for BindAccelerationStructureMemoryInfoNVBuilder<'a> {
32677 type Target = BindAccelerationStructureMemoryInfoNV;
32678 fn deref(&self) -> &Self::Target {
32679 &self.inner
32680 }
32681}
32682impl<'a> ::std::ops::DerefMut for BindAccelerationStructureMemoryInfoNVBuilder<'a> {
32683 fn deref_mut(&mut self) -> &mut Self::Target {
32684 &mut self.inner
32685 }
32686}
32687impl<'a> BindAccelerationStructureMemoryInfoNVBuilder<'a> {
32688 pub fn acceleration_structure(
32689 mut self,
32690 acceleration_structure: AccelerationStructureNV,
32691 ) -> Self {
32692 self.inner.acceleration_structure = acceleration_structure;
32693 self
32694 }
32695 pub fn memory(mut self, memory: DeviceMemory) -> Self {
32696 self.inner.memory = memory;
32697 self
32698 }
32699 pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self {
32700 self.inner.memory_offset = memory_offset;
32701 self
32702 }
32703 pub fn device_indices(mut self, device_indices: &'a [u32]) -> Self {
32704 self.inner.device_index_count = device_indices.len() as _;
32705 self.inner.p_device_indices = device_indices.as_ptr();
32706 self
32707 }
32708 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32709 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32710 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
32711 pub fn build(self) -> BindAccelerationStructureMemoryInfoNV {
32712 self.inner
32713 }
32714}
32715#[repr(C)]
32716#[cfg_attr(feature = "debug", derive(Debug))]
32717#[derive(Copy, Clone)]
32718#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWriteDescriptorSetAccelerationStructureKHR.html>"]
32719pub struct WriteDescriptorSetAccelerationStructureKHR {
32720 pub s_type: StructureType,
32721 pub p_next: *const c_void,
32722 pub acceleration_structure_count: u32,
32723 pub p_acceleration_structures: *const AccelerationStructureKHR,
32724}
32725impl ::std::default::Default for WriteDescriptorSetAccelerationStructureKHR {
32726 fn default() -> Self {
32727 Self {
32728 s_type: StructureType::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR,
32729 p_next: ::std::ptr::null(),
32730 acceleration_structure_count: u32::default(),
32731 p_acceleration_structures: ::std::ptr::null(),
32732 }
32733 }
32734}
32735impl WriteDescriptorSetAccelerationStructureKHR {
32736 pub fn builder<'a>() -> WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
32737 WriteDescriptorSetAccelerationStructureKHRBuilder {
32738 inner: Self::default(),
32739 marker: ::std::marker::PhantomData,
32740 }
32741 }
32742}
32743#[repr(transparent)]
32744pub struct WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
32745 inner: WriteDescriptorSetAccelerationStructureKHR,
32746 marker: ::std::marker::PhantomData<&'a ()>,
32747}
32748unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureKHRBuilder<'_> {}
32749unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureKHR {}
32750impl<'a> ::std::ops::Deref for WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
32751 type Target = WriteDescriptorSetAccelerationStructureKHR;
32752 fn deref(&self) -> &Self::Target {
32753 &self.inner
32754 }
32755}
32756impl<'a> ::std::ops::DerefMut for WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
32757 fn deref_mut(&mut self) -> &mut Self::Target {
32758 &mut self.inner
32759 }
32760}
32761impl<'a> WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
32762 pub fn acceleration_structures(
32763 mut self,
32764 acceleration_structures: &'a [AccelerationStructureKHR],
32765 ) -> Self {
32766 self.inner.acceleration_structure_count = acceleration_structures.len() as _;
32767 self.inner.p_acceleration_structures = acceleration_structures.as_ptr();
32768 self
32769 }
32770 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32771 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32772 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
32773 pub fn build(self) -> WriteDescriptorSetAccelerationStructureKHR {
32774 self.inner
32775 }
32776}
32777#[repr(C)]
32778#[cfg_attr(feature = "debug", derive(Debug))]
32779#[derive(Copy, Clone)]
32780#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWriteDescriptorSetAccelerationStructureNV.html>"]
32781pub struct WriteDescriptorSetAccelerationStructureNV {
32782 pub s_type: StructureType,
32783 pub p_next: *const c_void,
32784 pub acceleration_structure_count: u32,
32785 pub p_acceleration_structures: *const AccelerationStructureNV,
32786}
32787impl ::std::default::Default for WriteDescriptorSetAccelerationStructureNV {
32788 fn default() -> Self {
32789 Self {
32790 s_type: StructureType::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV,
32791 p_next: ::std::ptr::null(),
32792 acceleration_structure_count: u32::default(),
32793 p_acceleration_structures: ::std::ptr::null(),
32794 }
32795 }
32796}
32797impl WriteDescriptorSetAccelerationStructureNV {
32798 pub fn builder<'a>() -> WriteDescriptorSetAccelerationStructureNVBuilder<'a> {
32799 WriteDescriptorSetAccelerationStructureNVBuilder {
32800 inner: Self::default(),
32801 marker: ::std::marker::PhantomData,
32802 }
32803 }
32804}
32805#[repr(transparent)]
32806pub struct WriteDescriptorSetAccelerationStructureNVBuilder<'a> {
32807 inner: WriteDescriptorSetAccelerationStructureNV,
32808 marker: ::std::marker::PhantomData<&'a ()>,
32809}
32810unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureNVBuilder<'_> {}
32811unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureNV {}
32812impl<'a> ::std::ops::Deref for WriteDescriptorSetAccelerationStructureNVBuilder<'a> {
32813 type Target = WriteDescriptorSetAccelerationStructureNV;
32814 fn deref(&self) -> &Self::Target {
32815 &self.inner
32816 }
32817}
32818impl<'a> ::std::ops::DerefMut for WriteDescriptorSetAccelerationStructureNVBuilder<'a> {
32819 fn deref_mut(&mut self) -> &mut Self::Target {
32820 &mut self.inner
32821 }
32822}
32823impl<'a> WriteDescriptorSetAccelerationStructureNVBuilder<'a> {
32824 pub fn acceleration_structures(
32825 mut self,
32826 acceleration_structures: &'a [AccelerationStructureNV],
32827 ) -> Self {
32828 self.inner.acceleration_structure_count = acceleration_structures.len() as _;
32829 self.inner.p_acceleration_structures = acceleration_structures.as_ptr();
32830 self
32831 }
32832 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32833 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32834 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
32835 pub fn build(self) -> WriteDescriptorSetAccelerationStructureNV {
32836 self.inner
32837 }
32838}
32839#[repr(C)]
32840#[cfg_attr(feature = "debug", derive(Debug))]
32841#[derive(Copy, Clone)]
32842#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMemoryRequirementsInfoNV.html>"]
32843pub struct AccelerationStructureMemoryRequirementsInfoNV {
32844 pub s_type: StructureType,
32845 pub p_next: *const c_void,
32846 pub ty: AccelerationStructureMemoryRequirementsTypeNV,
32847 pub acceleration_structure: AccelerationStructureNV,
32848}
32849impl ::std::default::Default for AccelerationStructureMemoryRequirementsInfoNV {
32850 fn default() -> Self {
32851 Self {
32852 s_type: StructureType::ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV,
32853 p_next: ::std::ptr::null(),
32854 ty: AccelerationStructureMemoryRequirementsTypeNV::default(),
32855 acceleration_structure: AccelerationStructureNV::default(),
32856 }
32857 }
32858}
32859impl AccelerationStructureMemoryRequirementsInfoNV {
32860 pub fn builder<'a>() -> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
32861 AccelerationStructureMemoryRequirementsInfoNVBuilder {
32862 inner: Self::default(),
32863 marker: ::std::marker::PhantomData,
32864 }
32865 }
32866}
32867#[repr(transparent)]
32868pub struct AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
32869 inner: AccelerationStructureMemoryRequirementsInfoNV,
32870 marker: ::std::marker::PhantomData<&'a ()>,
32871}
32872impl<'a> ::std::ops::Deref for AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
32873 type Target = AccelerationStructureMemoryRequirementsInfoNV;
32874 fn deref(&self) -> &Self::Target {
32875 &self.inner
32876 }
32877}
32878impl<'a> ::std::ops::DerefMut for AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
32879 fn deref_mut(&mut self) -> &mut Self::Target {
32880 &mut self.inner
32881 }
32882}
32883impl<'a> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
32884 pub fn ty(mut self, ty: AccelerationStructureMemoryRequirementsTypeNV) -> Self {
32885 self.inner.ty = ty;
32886 self
32887 }
32888 pub fn acceleration_structure(
32889 mut self,
32890 acceleration_structure: AccelerationStructureNV,
32891 ) -> Self {
32892 self.inner.acceleration_structure = acceleration_structure;
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."]
32898 pub fn build(self) -> AccelerationStructureMemoryRequirementsInfoNV {
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/VkPhysicalDeviceAccelerationStructureFeaturesKHR.html>"]
32906pub struct PhysicalDeviceAccelerationStructureFeaturesKHR {
32907 pub s_type: StructureType,
32908 pub p_next: *mut c_void,
32909 pub acceleration_structure: Bool32,
32910 pub acceleration_structure_capture_replay: Bool32,
32911 pub acceleration_structure_indirect_build: Bool32,
32912 pub acceleration_structure_host_commands: Bool32,
32913 pub descriptor_binding_acceleration_structure_update_after_bind: Bool32,
32914}
32915impl ::std::default::Default for PhysicalDeviceAccelerationStructureFeaturesKHR {
32916 fn default() -> Self {
32917 Self {
32918 s_type: StructureType::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR,
32919 p_next: ::std::ptr::null_mut(),
32920 acceleration_structure: Bool32::default(),
32921 acceleration_structure_capture_replay: Bool32::default(),
32922 acceleration_structure_indirect_build: Bool32::default(),
32923 acceleration_structure_host_commands: Bool32::default(),
32924 descriptor_binding_acceleration_structure_update_after_bind: Bool32::default(),
32925 }
32926 }
32927}
32928impl PhysicalDeviceAccelerationStructureFeaturesKHR {
32929 pub fn builder<'a>() -> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
32930 PhysicalDeviceAccelerationStructureFeaturesKHRBuilder {
32931 inner: Self::default(),
32932 marker: ::std::marker::PhantomData,
32933 }
32934 }
32935}
32936#[repr(transparent)]
32937pub struct PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
32938 inner: PhysicalDeviceAccelerationStructureFeaturesKHR,
32939 marker: ::std::marker::PhantomData<&'a ()>,
32940}
32941unsafe impl ExtendsPhysicalDeviceFeatures2
32942 for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'_>
32943{
32944}
32945unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceAccelerationStructureFeaturesKHR {}
32946unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'_> {}
32947unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAccelerationStructureFeaturesKHR {}
32948impl<'a> ::std::ops::Deref for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
32949 type Target = PhysicalDeviceAccelerationStructureFeaturesKHR;
32950 fn deref(&self) -> &Self::Target {
32951 &self.inner
32952 }
32953}
32954impl<'a> ::std::ops::DerefMut for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
32955 fn deref_mut(&mut self) -> &mut Self::Target {
32956 &mut self.inner
32957 }
32958}
32959impl<'a> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
32960 pub fn acceleration_structure(mut self, acceleration_structure: bool) -> Self {
32961 self.inner.acceleration_structure = acceleration_structure.into();
32962 self
32963 }
32964 pub fn acceleration_structure_capture_replay(
32965 mut self,
32966 acceleration_structure_capture_replay: bool,
32967 ) -> Self {
32968 self.inner.acceleration_structure_capture_replay =
32969 acceleration_structure_capture_replay.into();
32970 self
32971 }
32972 pub fn acceleration_structure_indirect_build(
32973 mut self,
32974 acceleration_structure_indirect_build: bool,
32975 ) -> Self {
32976 self.inner.acceleration_structure_indirect_build =
32977 acceleration_structure_indirect_build.into();
32978 self
32979 }
32980 pub fn acceleration_structure_host_commands(
32981 mut self,
32982 acceleration_structure_host_commands: bool,
32983 ) -> Self {
32984 self.inner.acceleration_structure_host_commands =
32985 acceleration_structure_host_commands.into();
32986 self
32987 }
32988 pub fn descriptor_binding_acceleration_structure_update_after_bind(
32989 mut self,
32990 descriptor_binding_acceleration_structure_update_after_bind: bool,
32991 ) -> Self {
32992 self.inner
32993 .descriptor_binding_acceleration_structure_update_after_bind =
32994 descriptor_binding_acceleration_structure_update_after_bind.into();
32995 self
32996 }
32997 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32998 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32999 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
33000 pub fn build(self) -> PhysicalDeviceAccelerationStructureFeaturesKHR {
33001 self.inner
33002 }
33003}
33004#[repr(C)]
33005#[cfg_attr(feature = "debug", derive(Debug))]
33006#[derive(Copy, Clone)]
33007#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingPipelineFeaturesKHR.html>"]
33008pub struct PhysicalDeviceRayTracingPipelineFeaturesKHR {
33009 pub s_type: StructureType,
33010 pub p_next: *mut c_void,
33011 pub ray_tracing_pipeline: Bool32,
33012 pub ray_tracing_pipeline_shader_group_handle_capture_replay: Bool32,
33013 pub ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: Bool32,
33014 pub ray_tracing_pipeline_trace_rays_indirect: Bool32,
33015 pub ray_traversal_primitive_culling: Bool32,
33016}
33017impl ::std::default::Default for PhysicalDeviceRayTracingPipelineFeaturesKHR {
33018 fn default() -> Self {
33019 Self {
33020 s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR,
33021 p_next: ::std::ptr::null_mut(),
33022 ray_tracing_pipeline: Bool32::default(),
33023 ray_tracing_pipeline_shader_group_handle_capture_replay: Bool32::default(),
33024 ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: Bool32::default(),
33025 ray_tracing_pipeline_trace_rays_indirect: Bool32::default(),
33026 ray_traversal_primitive_culling: Bool32::default(),
33027 }
33028 }
33029}
33030impl PhysicalDeviceRayTracingPipelineFeaturesKHR {
33031 pub fn builder<'a>() -> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
33032 PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder {
33033 inner: Self::default(),
33034 marker: ::std::marker::PhantomData,
33035 }
33036 }
33037}
33038#[repr(transparent)]
33039pub struct PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
33040 inner: PhysicalDeviceRayTracingPipelineFeaturesKHR,
33041 marker: ::std::marker::PhantomData<&'a ()>,
33042}
33043unsafe impl ExtendsPhysicalDeviceFeatures2
33044 for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'_>
33045{
33046}
33047unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingPipelineFeaturesKHR {}
33048unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'_> {}
33049unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingPipelineFeaturesKHR {}
33050impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
33051 type Target = PhysicalDeviceRayTracingPipelineFeaturesKHR;
33052 fn deref(&self) -> &Self::Target {
33053 &self.inner
33054 }
33055}
33056impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
33057 fn deref_mut(&mut self) -> &mut Self::Target {
33058 &mut self.inner
33059 }
33060}
33061impl<'a> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
33062 pub fn ray_tracing_pipeline(mut self, ray_tracing_pipeline: bool) -> Self {
33063 self.inner.ray_tracing_pipeline = ray_tracing_pipeline.into();
33064 self
33065 }
33066 pub fn ray_tracing_pipeline_shader_group_handle_capture_replay(
33067 mut self,
33068 ray_tracing_pipeline_shader_group_handle_capture_replay: bool,
33069 ) -> Self {
33070 self.inner
33071 .ray_tracing_pipeline_shader_group_handle_capture_replay =
33072 ray_tracing_pipeline_shader_group_handle_capture_replay.into();
33073 self
33074 }
33075 pub fn ray_tracing_pipeline_shader_group_handle_capture_replay_mixed(
33076 mut self,
33077 ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: bool,
33078 ) -> Self {
33079 self.inner
33080 .ray_tracing_pipeline_shader_group_handle_capture_replay_mixed =
33081 ray_tracing_pipeline_shader_group_handle_capture_replay_mixed.into();
33082 self
33083 }
33084 pub fn ray_tracing_pipeline_trace_rays_indirect(
33085 mut self,
33086 ray_tracing_pipeline_trace_rays_indirect: bool,
33087 ) -> Self {
33088 self.inner.ray_tracing_pipeline_trace_rays_indirect =
33089 ray_tracing_pipeline_trace_rays_indirect.into();
33090 self
33091 }
33092 pub fn ray_traversal_primitive_culling(
33093 mut self,
33094 ray_traversal_primitive_culling: bool,
33095 ) -> Self {
33096 self.inner.ray_traversal_primitive_culling = ray_traversal_primitive_culling.into();
33097 self
33098 }
33099 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33100 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33101 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
33102 pub fn build(self) -> PhysicalDeviceRayTracingPipelineFeaturesKHR {
33103 self.inner
33104 }
33105}
33106#[repr(C)]
33107#[cfg_attr(feature = "debug", derive(Debug))]
33108#[derive(Copy, Clone)]
33109#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayQueryFeaturesKHR.html>"]
33110pub struct PhysicalDeviceRayQueryFeaturesKHR {
33111 pub s_type: StructureType,
33112 pub p_next: *mut c_void,
33113 pub ray_query: Bool32,
33114}
33115impl ::std::default::Default for PhysicalDeviceRayQueryFeaturesKHR {
33116 fn default() -> Self {
33117 Self {
33118 s_type: StructureType::PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR,
33119 p_next: ::std::ptr::null_mut(),
33120 ray_query: Bool32::default(),
33121 }
33122 }
33123}
33124impl PhysicalDeviceRayQueryFeaturesKHR {
33125 pub fn builder<'a>() -> PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
33126 PhysicalDeviceRayQueryFeaturesKHRBuilder {
33127 inner: Self::default(),
33128 marker: ::std::marker::PhantomData,
33129 }
33130 }
33131}
33132#[repr(transparent)]
33133pub struct PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
33134 inner: PhysicalDeviceRayQueryFeaturesKHR,
33135 marker: ::std::marker::PhantomData<&'a ()>,
33136}
33137unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayQueryFeaturesKHRBuilder<'_> {}
33138unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayQueryFeaturesKHR {}
33139unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayQueryFeaturesKHRBuilder<'_> {}
33140unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayQueryFeaturesKHR {}
33141impl<'a> ::std::ops::Deref for PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
33142 type Target = PhysicalDeviceRayQueryFeaturesKHR;
33143 fn deref(&self) -> &Self::Target {
33144 &self.inner
33145 }
33146}
33147impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
33148 fn deref_mut(&mut self) -> &mut Self::Target {
33149 &mut self.inner
33150 }
33151}
33152impl<'a> PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
33153 pub fn ray_query(mut self, ray_query: bool) -> Self {
33154 self.inner.ray_query = ray_query.into();
33155 self
33156 }
33157 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33158 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33159 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
33160 pub fn build(self) -> PhysicalDeviceRayQueryFeaturesKHR {
33161 self.inner
33162 }
33163}
33164#[repr(C)]
33165#[cfg_attr(feature = "debug", derive(Debug))]
33166#[derive(Copy, Clone)]
33167#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceAccelerationStructurePropertiesKHR.html>"]
33168pub struct PhysicalDeviceAccelerationStructurePropertiesKHR {
33169 pub s_type: StructureType,
33170 pub p_next: *mut c_void,
33171 pub max_geometry_count: u64,
33172 pub max_instance_count: u64,
33173 pub max_primitive_count: u64,
33174 pub max_per_stage_descriptor_acceleration_structures: u32,
33175 pub max_per_stage_descriptor_update_after_bind_acceleration_structures: u32,
33176 pub max_descriptor_set_acceleration_structures: u32,
33177 pub max_descriptor_set_update_after_bind_acceleration_structures: u32,
33178 pub min_acceleration_structure_scratch_offset_alignment: u32,
33179}
33180impl ::std::default::Default for PhysicalDeviceAccelerationStructurePropertiesKHR {
33181 fn default() -> Self {
33182 Self {
33183 s_type: StructureType::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR,
33184 p_next: ::std::ptr::null_mut(),
33185 max_geometry_count: u64::default(),
33186 max_instance_count: u64::default(),
33187 max_primitive_count: u64::default(),
33188 max_per_stage_descriptor_acceleration_structures: u32::default(),
33189 max_per_stage_descriptor_update_after_bind_acceleration_structures: u32::default(),
33190 max_descriptor_set_acceleration_structures: u32::default(),
33191 max_descriptor_set_update_after_bind_acceleration_structures: u32::default(),
33192 min_acceleration_structure_scratch_offset_alignment: u32::default(),
33193 }
33194 }
33195}
33196impl PhysicalDeviceAccelerationStructurePropertiesKHR {
33197 pub fn builder<'a>() -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
33198 PhysicalDeviceAccelerationStructurePropertiesKHRBuilder {
33199 inner: Self::default(),
33200 marker: ::std::marker::PhantomData,
33201 }
33202 }
33203}
33204#[repr(transparent)]
33205pub struct PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
33206 inner: PhysicalDeviceAccelerationStructurePropertiesKHR,
33207 marker: ::std::marker::PhantomData<&'a ()>,
33208}
33209unsafe impl ExtendsPhysicalDeviceProperties2
33210 for PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'_>
33211{
33212}
33213unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceAccelerationStructurePropertiesKHR {}
33214impl<'a> ::std::ops::Deref for PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
33215 type Target = PhysicalDeviceAccelerationStructurePropertiesKHR;
33216 fn deref(&self) -> &Self::Target {
33217 &self.inner
33218 }
33219}
33220impl<'a> ::std::ops::DerefMut for PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
33221 fn deref_mut(&mut self) -> &mut Self::Target {
33222 &mut self.inner
33223 }
33224}
33225impl<'a> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
33226 pub fn max_geometry_count(mut self, max_geometry_count: u64) -> Self {
33227 self.inner.max_geometry_count = max_geometry_count;
33228 self
33229 }
33230 pub fn max_instance_count(mut self, max_instance_count: u64) -> Self {
33231 self.inner.max_instance_count = max_instance_count;
33232 self
33233 }
33234 pub fn max_primitive_count(mut self, max_primitive_count: u64) -> Self {
33235 self.inner.max_primitive_count = max_primitive_count;
33236 self
33237 }
33238 pub fn max_per_stage_descriptor_acceleration_structures(
33239 mut self,
33240 max_per_stage_descriptor_acceleration_structures: u32,
33241 ) -> Self {
33242 self.inner.max_per_stage_descriptor_acceleration_structures =
33243 max_per_stage_descriptor_acceleration_structures;
33244 self
33245 }
33246 pub fn max_per_stage_descriptor_update_after_bind_acceleration_structures(
33247 mut self,
33248 max_per_stage_descriptor_update_after_bind_acceleration_structures: u32,
33249 ) -> Self {
33250 self.inner
33251 .max_per_stage_descriptor_update_after_bind_acceleration_structures =
33252 max_per_stage_descriptor_update_after_bind_acceleration_structures;
33253 self
33254 }
33255 pub fn max_descriptor_set_acceleration_structures(
33256 mut self,
33257 max_descriptor_set_acceleration_structures: u32,
33258 ) -> Self {
33259 self.inner.max_descriptor_set_acceleration_structures =
33260 max_descriptor_set_acceleration_structures;
33261 self
33262 }
33263 pub fn max_descriptor_set_update_after_bind_acceleration_structures(
33264 mut self,
33265 max_descriptor_set_update_after_bind_acceleration_structures: u32,
33266 ) -> Self {
33267 self.inner
33268 .max_descriptor_set_update_after_bind_acceleration_structures =
33269 max_descriptor_set_update_after_bind_acceleration_structures;
33270 self
33271 }
33272 pub fn min_acceleration_structure_scratch_offset_alignment(
33273 mut self,
33274 min_acceleration_structure_scratch_offset_alignment: u32,
33275 ) -> Self {
33276 self.inner
33277 .min_acceleration_structure_scratch_offset_alignment =
33278 min_acceleration_structure_scratch_offset_alignment;
33279 self
33280 }
33281 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33282 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33283 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
33284 pub fn build(self) -> PhysicalDeviceAccelerationStructurePropertiesKHR {
33285 self.inner
33286 }
33287}
33288#[repr(C)]
33289#[cfg_attr(feature = "debug", derive(Debug))]
33290#[derive(Copy, Clone)]
33291#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingPipelinePropertiesKHR.html>"]
33292pub struct PhysicalDeviceRayTracingPipelinePropertiesKHR {
33293 pub s_type: StructureType,
33294 pub p_next: *mut c_void,
33295 pub shader_group_handle_size: u32,
33296 pub max_ray_recursion_depth: u32,
33297 pub max_shader_group_stride: u32,
33298 pub shader_group_base_alignment: u32,
33299 pub shader_group_handle_capture_replay_size: u32,
33300 pub max_ray_dispatch_invocation_count: u32,
33301 pub shader_group_handle_alignment: u32,
33302 pub max_ray_hit_attribute_size: u32,
33303}
33304impl ::std::default::Default for PhysicalDeviceRayTracingPipelinePropertiesKHR {
33305 fn default() -> Self {
33306 Self {
33307 s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR,
33308 p_next: ::std::ptr::null_mut(),
33309 shader_group_handle_size: u32::default(),
33310 max_ray_recursion_depth: u32::default(),
33311 max_shader_group_stride: u32::default(),
33312 shader_group_base_alignment: u32::default(),
33313 shader_group_handle_capture_replay_size: u32::default(),
33314 max_ray_dispatch_invocation_count: u32::default(),
33315 shader_group_handle_alignment: u32::default(),
33316 max_ray_hit_attribute_size: u32::default(),
33317 }
33318 }
33319}
33320impl PhysicalDeviceRayTracingPipelinePropertiesKHR {
33321 pub fn builder<'a>() -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
33322 PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder {
33323 inner: Self::default(),
33324 marker: ::std::marker::PhantomData,
33325 }
33326 }
33327}
33328#[repr(transparent)]
33329pub struct PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
33330 inner: PhysicalDeviceRayTracingPipelinePropertiesKHR,
33331 marker: ::std::marker::PhantomData<&'a ()>,
33332}
33333unsafe impl ExtendsPhysicalDeviceProperties2
33334 for PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'_>
33335{
33336}
33337unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPipelinePropertiesKHR {}
33338impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
33339 type Target = PhysicalDeviceRayTracingPipelinePropertiesKHR;
33340 fn deref(&self) -> &Self::Target {
33341 &self.inner
33342 }
33343}
33344impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
33345 fn deref_mut(&mut self) -> &mut Self::Target {
33346 &mut self.inner
33347 }
33348}
33349impl<'a> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
33350 pub fn shader_group_handle_size(mut self, shader_group_handle_size: u32) -> Self {
33351 self.inner.shader_group_handle_size = shader_group_handle_size;
33352 self
33353 }
33354 pub fn max_ray_recursion_depth(mut self, max_ray_recursion_depth: u32) -> Self {
33355 self.inner.max_ray_recursion_depth = max_ray_recursion_depth;
33356 self
33357 }
33358 pub fn max_shader_group_stride(mut self, max_shader_group_stride: u32) -> Self {
33359 self.inner.max_shader_group_stride = max_shader_group_stride;
33360 self
33361 }
33362 pub fn shader_group_base_alignment(mut self, shader_group_base_alignment: u32) -> Self {
33363 self.inner.shader_group_base_alignment = shader_group_base_alignment;
33364 self
33365 }
33366 pub fn shader_group_handle_capture_replay_size(
33367 mut self,
33368 shader_group_handle_capture_replay_size: u32,
33369 ) -> Self {
33370 self.inner.shader_group_handle_capture_replay_size =
33371 shader_group_handle_capture_replay_size;
33372 self
33373 }
33374 pub fn max_ray_dispatch_invocation_count(
33375 mut self,
33376 max_ray_dispatch_invocation_count: u32,
33377 ) -> Self {
33378 self.inner.max_ray_dispatch_invocation_count = max_ray_dispatch_invocation_count;
33379 self
33380 }
33381 pub fn shader_group_handle_alignment(mut self, shader_group_handle_alignment: u32) -> Self {
33382 self.inner.shader_group_handle_alignment = shader_group_handle_alignment;
33383 self
33384 }
33385 pub fn max_ray_hit_attribute_size(mut self, max_ray_hit_attribute_size: u32) -> Self {
33386 self.inner.max_ray_hit_attribute_size = max_ray_hit_attribute_size;
33387 self
33388 }
33389 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33390 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33391 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
33392 pub fn build(self) -> PhysicalDeviceRayTracingPipelinePropertiesKHR {
33393 self.inner
33394 }
33395}
33396#[repr(C)]
33397#[cfg_attr(feature = "debug", derive(Debug))]
33398#[derive(Copy, Clone)]
33399#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingPropertiesNV.html>"]
33400pub struct PhysicalDeviceRayTracingPropertiesNV {
33401 pub s_type: StructureType,
33402 pub p_next: *mut c_void,
33403 pub shader_group_handle_size: u32,
33404 pub max_recursion_depth: u32,
33405 pub max_shader_group_stride: u32,
33406 pub shader_group_base_alignment: u32,
33407 pub max_geometry_count: u64,
33408 pub max_instance_count: u64,
33409 pub max_triangle_count: u64,
33410 pub max_descriptor_set_acceleration_structures: u32,
33411}
33412impl ::std::default::Default for PhysicalDeviceRayTracingPropertiesNV {
33413 fn default() -> Self {
33414 Self {
33415 s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV,
33416 p_next: ::std::ptr::null_mut(),
33417 shader_group_handle_size: u32::default(),
33418 max_recursion_depth: u32::default(),
33419 max_shader_group_stride: u32::default(),
33420 shader_group_base_alignment: u32::default(),
33421 max_geometry_count: u64::default(),
33422 max_instance_count: u64::default(),
33423 max_triangle_count: u64::default(),
33424 max_descriptor_set_acceleration_structures: u32::default(),
33425 }
33426 }
33427}
33428impl PhysicalDeviceRayTracingPropertiesNV {
33429 pub fn builder<'a>() -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
33430 PhysicalDeviceRayTracingPropertiesNVBuilder {
33431 inner: Self::default(),
33432 marker: ::std::marker::PhantomData,
33433 }
33434 }
33435}
33436#[repr(transparent)]
33437pub struct PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
33438 inner: PhysicalDeviceRayTracingPropertiesNV,
33439 marker: ::std::marker::PhantomData<&'a ()>,
33440}
33441unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPropertiesNVBuilder<'_> {}
33442unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPropertiesNV {}
33443impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
33444 type Target = PhysicalDeviceRayTracingPropertiesNV;
33445 fn deref(&self) -> &Self::Target {
33446 &self.inner
33447 }
33448}
33449impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
33450 fn deref_mut(&mut self) -> &mut Self::Target {
33451 &mut self.inner
33452 }
33453}
33454impl<'a> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
33455 pub fn shader_group_handle_size(mut self, shader_group_handle_size: u32) -> Self {
33456 self.inner.shader_group_handle_size = shader_group_handle_size;
33457 self
33458 }
33459 pub fn max_recursion_depth(mut self, max_recursion_depth: u32) -> Self {
33460 self.inner.max_recursion_depth = max_recursion_depth;
33461 self
33462 }
33463 pub fn max_shader_group_stride(mut self, max_shader_group_stride: u32) -> Self {
33464 self.inner.max_shader_group_stride = max_shader_group_stride;
33465 self
33466 }
33467 pub fn shader_group_base_alignment(mut self, shader_group_base_alignment: u32) -> Self {
33468 self.inner.shader_group_base_alignment = shader_group_base_alignment;
33469 self
33470 }
33471 pub fn max_geometry_count(mut self, max_geometry_count: u64) -> Self {
33472 self.inner.max_geometry_count = max_geometry_count;
33473 self
33474 }
33475 pub fn max_instance_count(mut self, max_instance_count: u64) -> Self {
33476 self.inner.max_instance_count = max_instance_count;
33477 self
33478 }
33479 pub fn max_triangle_count(mut self, max_triangle_count: u64) -> Self {
33480 self.inner.max_triangle_count = max_triangle_count;
33481 self
33482 }
33483 pub fn max_descriptor_set_acceleration_structures(
33484 mut self,
33485 max_descriptor_set_acceleration_structures: u32,
33486 ) -> Self {
33487 self.inner.max_descriptor_set_acceleration_structures =
33488 max_descriptor_set_acceleration_structures;
33489 self
33490 }
33491 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33492 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33493 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
33494 pub fn build(self) -> PhysicalDeviceRayTracingPropertiesNV {
33495 self.inner
33496 }
33497}
33498#[repr(C)]
33499#[cfg_attr(feature = "debug", derive(Debug))]
33500#[derive(Copy, Clone, Default)]
33501#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkStridedDeviceAddressRegionKHR.html>"]
33502pub struct StridedDeviceAddressRegionKHR {
33503 pub device_address: DeviceAddress,
33504 pub stride: DeviceSize,
33505 pub size: DeviceSize,
33506}
33507impl StridedDeviceAddressRegionKHR {
33508 pub fn builder<'a>() -> StridedDeviceAddressRegionKHRBuilder<'a> {
33509 StridedDeviceAddressRegionKHRBuilder {
33510 inner: Self::default(),
33511 marker: ::std::marker::PhantomData,
33512 }
33513 }
33514}
33515#[repr(transparent)]
33516pub struct StridedDeviceAddressRegionKHRBuilder<'a> {
33517 inner: StridedDeviceAddressRegionKHR,
33518 marker: ::std::marker::PhantomData<&'a ()>,
33519}
33520impl<'a> ::std::ops::Deref for StridedDeviceAddressRegionKHRBuilder<'a> {
33521 type Target = StridedDeviceAddressRegionKHR;
33522 fn deref(&self) -> &Self::Target {
33523 &self.inner
33524 }
33525}
33526impl<'a> ::std::ops::DerefMut for StridedDeviceAddressRegionKHRBuilder<'a> {
33527 fn deref_mut(&mut self) -> &mut Self::Target {
33528 &mut self.inner
33529 }
33530}
33531impl<'a> StridedDeviceAddressRegionKHRBuilder<'a> {
33532 pub fn device_address(mut self, device_address: DeviceAddress) -> Self {
33533 self.inner.device_address = device_address;
33534 self
33535 }
33536 pub fn stride(mut self, stride: DeviceSize) -> Self {
33537 self.inner.stride = stride;
33538 self
33539 }
33540 pub fn size(mut self, size: DeviceSize) -> Self {
33541 self.inner.size = size;
33542 self
33543 }
33544 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33545 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33546 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
33547 pub fn build(self) -> StridedDeviceAddressRegionKHR {
33548 self.inner
33549 }
33550}
33551#[repr(C)]
33552#[cfg_attr(feature = "debug", derive(Debug))]
33553#[derive(Copy, Clone, Default)]
33554#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkTraceRaysIndirectCommandKHR.html>"]
33555pub struct TraceRaysIndirectCommandKHR {
33556 pub width: u32,
33557 pub height: u32,
33558 pub depth: u32,
33559}
33560impl TraceRaysIndirectCommandKHR {
33561 pub fn builder<'a>() -> TraceRaysIndirectCommandKHRBuilder<'a> {
33562 TraceRaysIndirectCommandKHRBuilder {
33563 inner: Self::default(),
33564 marker: ::std::marker::PhantomData,
33565 }
33566 }
33567}
33568#[repr(transparent)]
33569pub struct TraceRaysIndirectCommandKHRBuilder<'a> {
33570 inner: TraceRaysIndirectCommandKHR,
33571 marker: ::std::marker::PhantomData<&'a ()>,
33572}
33573impl<'a> ::std::ops::Deref for TraceRaysIndirectCommandKHRBuilder<'a> {
33574 type Target = TraceRaysIndirectCommandKHR;
33575 fn deref(&self) -> &Self::Target {
33576 &self.inner
33577 }
33578}
33579impl<'a> ::std::ops::DerefMut for TraceRaysIndirectCommandKHRBuilder<'a> {
33580 fn deref_mut(&mut self) -> &mut Self::Target {
33581 &mut self.inner
33582 }
33583}
33584impl<'a> TraceRaysIndirectCommandKHRBuilder<'a> {
33585 pub fn width(mut self, width: u32) -> Self {
33586 self.inner.width = width;
33587 self
33588 }
33589 pub fn height(mut self, height: u32) -> Self {
33590 self.inner.height = height;
33591 self
33592 }
33593 pub fn depth(mut self, depth: u32) -> Self {
33594 self.inner.depth = depth;
33595 self
33596 }
33597 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33598 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33599 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
33600 pub fn build(self) -> TraceRaysIndirectCommandKHR {
33601 self.inner
33602 }
33603}
33604#[repr(C)]
33605#[cfg_attr(feature = "debug", derive(Debug))]
33606#[derive(Copy, Clone)]
33607#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrmFormatModifierPropertiesListEXT.html>"]
33608pub struct DrmFormatModifierPropertiesListEXT {
33609 pub s_type: StructureType,
33610 pub p_next: *mut c_void,
33611 pub drm_format_modifier_count: u32,
33612 pub p_drm_format_modifier_properties: *mut DrmFormatModifierPropertiesEXT,
33613}
33614impl ::std::default::Default for DrmFormatModifierPropertiesListEXT {
33615 fn default() -> Self {
33616 Self {
33617 s_type: StructureType::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT,
33618 p_next: ::std::ptr::null_mut(),
33619 drm_format_modifier_count: u32::default(),
33620 p_drm_format_modifier_properties: ::std::ptr::null_mut(),
33621 }
33622 }
33623}
33624impl DrmFormatModifierPropertiesListEXT {
33625 pub fn builder<'a>() -> DrmFormatModifierPropertiesListEXTBuilder<'a> {
33626 DrmFormatModifierPropertiesListEXTBuilder {
33627 inner: Self::default(),
33628 marker: ::std::marker::PhantomData,
33629 }
33630 }
33631}
33632#[repr(transparent)]
33633pub struct DrmFormatModifierPropertiesListEXTBuilder<'a> {
33634 inner: DrmFormatModifierPropertiesListEXT,
33635 marker: ::std::marker::PhantomData<&'a ()>,
33636}
33637unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesListEXTBuilder<'_> {}
33638unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesListEXT {}
33639impl<'a> ::std::ops::Deref for DrmFormatModifierPropertiesListEXTBuilder<'a> {
33640 type Target = DrmFormatModifierPropertiesListEXT;
33641 fn deref(&self) -> &Self::Target {
33642 &self.inner
33643 }
33644}
33645impl<'a> ::std::ops::DerefMut for DrmFormatModifierPropertiesListEXTBuilder<'a> {
33646 fn deref_mut(&mut self) -> &mut Self::Target {
33647 &mut self.inner
33648 }
33649}
33650impl<'a> DrmFormatModifierPropertiesListEXTBuilder<'a> {
33651 pub fn drm_format_modifier_properties(
33652 mut self,
33653 drm_format_modifier_properties: &'a mut [DrmFormatModifierPropertiesEXT],
33654 ) -> Self {
33655 self.inner.drm_format_modifier_count = drm_format_modifier_properties.len() as _;
33656 self.inner.p_drm_format_modifier_properties = drm_format_modifier_properties.as_mut_ptr();
33657 self
33658 }
33659 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33660 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33661 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
33662 pub fn build(self) -> DrmFormatModifierPropertiesListEXT {
33663 self.inner
33664 }
33665}
33666#[repr(C)]
33667#[cfg_attr(feature = "debug", derive(Debug))]
33668#[derive(Copy, Clone, Default)]
33669#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrmFormatModifierPropertiesEXT.html>"]
33670pub struct DrmFormatModifierPropertiesEXT {
33671 pub drm_format_modifier: u64,
33672 pub drm_format_modifier_plane_count: u32,
33673 pub drm_format_modifier_tiling_features: FormatFeatureFlags,
33674}
33675impl DrmFormatModifierPropertiesEXT {
33676 pub fn builder<'a>() -> DrmFormatModifierPropertiesEXTBuilder<'a> {
33677 DrmFormatModifierPropertiesEXTBuilder {
33678 inner: Self::default(),
33679 marker: ::std::marker::PhantomData,
33680 }
33681 }
33682}
33683#[repr(transparent)]
33684pub struct DrmFormatModifierPropertiesEXTBuilder<'a> {
33685 inner: DrmFormatModifierPropertiesEXT,
33686 marker: ::std::marker::PhantomData<&'a ()>,
33687}
33688impl<'a> ::std::ops::Deref for DrmFormatModifierPropertiesEXTBuilder<'a> {
33689 type Target = DrmFormatModifierPropertiesEXT;
33690 fn deref(&self) -> &Self::Target {
33691 &self.inner
33692 }
33693}
33694impl<'a> ::std::ops::DerefMut for DrmFormatModifierPropertiesEXTBuilder<'a> {
33695 fn deref_mut(&mut self) -> &mut Self::Target {
33696 &mut self.inner
33697 }
33698}
33699impl<'a> DrmFormatModifierPropertiesEXTBuilder<'a> {
33700 pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self {
33701 self.inner.drm_format_modifier = drm_format_modifier;
33702 self
33703 }
33704 pub fn drm_format_modifier_plane_count(mut self, drm_format_modifier_plane_count: u32) -> Self {
33705 self.inner.drm_format_modifier_plane_count = drm_format_modifier_plane_count;
33706 self
33707 }
33708 pub fn drm_format_modifier_tiling_features(
33709 mut self,
33710 drm_format_modifier_tiling_features: FormatFeatureFlags,
33711 ) -> Self {
33712 self.inner.drm_format_modifier_tiling_features = drm_format_modifier_tiling_features;
33713 self
33714 }
33715 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33716 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33717 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
33718 pub fn build(self) -> DrmFormatModifierPropertiesEXT {
33719 self.inner
33720 }
33721}
33722#[repr(C)]
33723#[cfg_attr(feature = "debug", derive(Debug))]
33724#[derive(Copy, Clone)]
33725#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageDrmFormatModifierInfoEXT.html>"]
33726pub struct PhysicalDeviceImageDrmFormatModifierInfoEXT {
33727 pub s_type: StructureType,
33728 pub p_next: *const c_void,
33729 pub drm_format_modifier: u64,
33730 pub sharing_mode: SharingMode,
33731 pub queue_family_index_count: u32,
33732 pub p_queue_family_indices: *const u32,
33733}
33734impl ::std::default::Default for PhysicalDeviceImageDrmFormatModifierInfoEXT {
33735 fn default() -> Self {
33736 Self {
33737 s_type: StructureType::PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT,
33738 p_next: ::std::ptr::null(),
33739 drm_format_modifier: u64::default(),
33740 sharing_mode: SharingMode::default(),
33741 queue_family_index_count: u32::default(),
33742 p_queue_family_indices: ::std::ptr::null(),
33743 }
33744 }
33745}
33746impl PhysicalDeviceImageDrmFormatModifierInfoEXT {
33747 pub fn builder<'a>() -> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
33748 PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder {
33749 inner: Self::default(),
33750 marker: ::std::marker::PhantomData,
33751 }
33752 }
33753}
33754#[repr(transparent)]
33755pub struct PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
33756 inner: PhysicalDeviceImageDrmFormatModifierInfoEXT,
33757 marker: ::std::marker::PhantomData<&'a ()>,
33758}
33759unsafe impl ExtendsPhysicalDeviceImageFormatInfo2
33760 for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'_>
33761{
33762}
33763unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceImageDrmFormatModifierInfoEXT {}
33764impl<'a> ::std::ops::Deref for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
33765 type Target = PhysicalDeviceImageDrmFormatModifierInfoEXT;
33766 fn deref(&self) -> &Self::Target {
33767 &self.inner
33768 }
33769}
33770impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
33771 fn deref_mut(&mut self) -> &mut Self::Target {
33772 &mut self.inner
33773 }
33774}
33775impl<'a> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
33776 pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self {
33777 self.inner.drm_format_modifier = drm_format_modifier;
33778 self
33779 }
33780 pub fn sharing_mode(mut self, sharing_mode: SharingMode) -> Self {
33781 self.inner.sharing_mode = sharing_mode;
33782 self
33783 }
33784 pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self {
33785 self.inner.queue_family_index_count = queue_family_indices.len() as _;
33786 self.inner.p_queue_family_indices = queue_family_indices.as_ptr();
33787 self
33788 }
33789 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33790 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33791 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
33792 pub fn build(self) -> PhysicalDeviceImageDrmFormatModifierInfoEXT {
33793 self.inner
33794 }
33795}
33796#[repr(C)]
33797#[cfg_attr(feature = "debug", derive(Debug))]
33798#[derive(Copy, Clone)]
33799#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageDrmFormatModifierListCreateInfoEXT.html>"]
33800pub struct ImageDrmFormatModifierListCreateInfoEXT {
33801 pub s_type: StructureType,
33802 pub p_next: *const c_void,
33803 pub drm_format_modifier_count: u32,
33804 pub p_drm_format_modifiers: *const u64,
33805}
33806impl ::std::default::Default for ImageDrmFormatModifierListCreateInfoEXT {
33807 fn default() -> Self {
33808 Self {
33809 s_type: StructureType::IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT,
33810 p_next: ::std::ptr::null(),
33811 drm_format_modifier_count: u32::default(),
33812 p_drm_format_modifiers: ::std::ptr::null(),
33813 }
33814 }
33815}
33816impl ImageDrmFormatModifierListCreateInfoEXT {
33817 pub fn builder<'a>() -> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
33818 ImageDrmFormatModifierListCreateInfoEXTBuilder {
33819 inner: Self::default(),
33820 marker: ::std::marker::PhantomData,
33821 }
33822 }
33823}
33824#[repr(transparent)]
33825pub struct ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
33826 inner: ImageDrmFormatModifierListCreateInfoEXT,
33827 marker: ::std::marker::PhantomData<&'a ()>,
33828}
33829unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierListCreateInfoEXTBuilder<'_> {}
33830unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierListCreateInfoEXT {}
33831impl<'a> ::std::ops::Deref for ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
33832 type Target = ImageDrmFormatModifierListCreateInfoEXT;
33833 fn deref(&self) -> &Self::Target {
33834 &self.inner
33835 }
33836}
33837impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
33838 fn deref_mut(&mut self) -> &mut Self::Target {
33839 &mut self.inner
33840 }
33841}
33842impl<'a> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
33843 pub fn drm_format_modifiers(mut self, drm_format_modifiers: &'a [u64]) -> Self {
33844 self.inner.drm_format_modifier_count = drm_format_modifiers.len() as _;
33845 self.inner.p_drm_format_modifiers = drm_format_modifiers.as_ptr();
33846 self
33847 }
33848 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33849 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33850 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
33851 pub fn build(self) -> ImageDrmFormatModifierListCreateInfoEXT {
33852 self.inner
33853 }
33854}
33855#[repr(C)]
33856#[cfg_attr(feature = "debug", derive(Debug))]
33857#[derive(Copy, Clone)]
33858#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageDrmFormatModifierExplicitCreateInfoEXT.html>"]
33859pub struct ImageDrmFormatModifierExplicitCreateInfoEXT {
33860 pub s_type: StructureType,
33861 pub p_next: *const c_void,
33862 pub drm_format_modifier: u64,
33863 pub drm_format_modifier_plane_count: u32,
33864 pub p_plane_layouts: *const SubresourceLayout,
33865}
33866impl ::std::default::Default for ImageDrmFormatModifierExplicitCreateInfoEXT {
33867 fn default() -> Self {
33868 Self {
33869 s_type: StructureType::IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT,
33870 p_next: ::std::ptr::null(),
33871 drm_format_modifier: u64::default(),
33872 drm_format_modifier_plane_count: u32::default(),
33873 p_plane_layouts: ::std::ptr::null(),
33874 }
33875 }
33876}
33877impl ImageDrmFormatModifierExplicitCreateInfoEXT {
33878 pub fn builder<'a>() -> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
33879 ImageDrmFormatModifierExplicitCreateInfoEXTBuilder {
33880 inner: Self::default(),
33881 marker: ::std::marker::PhantomData,
33882 }
33883 }
33884}
33885#[repr(transparent)]
33886pub struct ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
33887 inner: ImageDrmFormatModifierExplicitCreateInfoEXT,
33888 marker: ::std::marker::PhantomData<&'a ()>,
33889}
33890unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'_> {}
33891unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierExplicitCreateInfoEXT {}
33892impl<'a> ::std::ops::Deref for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
33893 type Target = ImageDrmFormatModifierExplicitCreateInfoEXT;
33894 fn deref(&self) -> &Self::Target {
33895 &self.inner
33896 }
33897}
33898impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
33899 fn deref_mut(&mut self) -> &mut Self::Target {
33900 &mut self.inner
33901 }
33902}
33903impl<'a> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
33904 pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self {
33905 self.inner.drm_format_modifier = drm_format_modifier;
33906 self
33907 }
33908 pub fn plane_layouts(mut self, plane_layouts: &'a [SubresourceLayout]) -> Self {
33909 self.inner.drm_format_modifier_plane_count = plane_layouts.len() as _;
33910 self.inner.p_plane_layouts = plane_layouts.as_ptr();
33911 self
33912 }
33913 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33914 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33915 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
33916 pub fn build(self) -> ImageDrmFormatModifierExplicitCreateInfoEXT {
33917 self.inner
33918 }
33919}
33920#[repr(C)]
33921#[cfg_attr(feature = "debug", derive(Debug))]
33922#[derive(Copy, Clone)]
33923#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageDrmFormatModifierPropertiesEXT.html>"]
33924pub struct ImageDrmFormatModifierPropertiesEXT {
33925 pub s_type: StructureType,
33926 pub p_next: *mut c_void,
33927 pub drm_format_modifier: u64,
33928}
33929impl ::std::default::Default for ImageDrmFormatModifierPropertiesEXT {
33930 fn default() -> Self {
33931 Self {
33932 s_type: StructureType::IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT,
33933 p_next: ::std::ptr::null_mut(),
33934 drm_format_modifier: u64::default(),
33935 }
33936 }
33937}
33938impl ImageDrmFormatModifierPropertiesEXT {
33939 pub fn builder<'a>() -> ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
33940 ImageDrmFormatModifierPropertiesEXTBuilder {
33941 inner: Self::default(),
33942 marker: ::std::marker::PhantomData,
33943 }
33944 }
33945}
33946#[repr(transparent)]
33947pub struct ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
33948 inner: ImageDrmFormatModifierPropertiesEXT,
33949 marker: ::std::marker::PhantomData<&'a ()>,
33950}
33951impl<'a> ::std::ops::Deref for ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
33952 type Target = ImageDrmFormatModifierPropertiesEXT;
33953 fn deref(&self) -> &Self::Target {
33954 &self.inner
33955 }
33956}
33957impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
33958 fn deref_mut(&mut self) -> &mut Self::Target {
33959 &mut self.inner
33960 }
33961}
33962impl<'a> ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
33963 pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self {
33964 self.inner.drm_format_modifier = drm_format_modifier;
33965 self
33966 }
33967 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33968 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33969 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
33970 pub fn build(self) -> ImageDrmFormatModifierPropertiesEXT {
33971 self.inner
33972 }
33973}
33974#[repr(C)]
33975#[cfg_attr(feature = "debug", derive(Debug))]
33976#[derive(Copy, Clone)]
33977#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageStencilUsageCreateInfo.html>"]
33978pub struct ImageStencilUsageCreateInfo {
33979 pub s_type: StructureType,
33980 pub p_next: *const c_void,
33981 pub stencil_usage: ImageUsageFlags,
33982}
33983impl ::std::default::Default for ImageStencilUsageCreateInfo {
33984 fn default() -> Self {
33985 Self {
33986 s_type: StructureType::IMAGE_STENCIL_USAGE_CREATE_INFO,
33987 p_next: ::std::ptr::null(),
33988 stencil_usage: ImageUsageFlags::default(),
33989 }
33990 }
33991}
33992impl ImageStencilUsageCreateInfo {
33993 pub fn builder<'a>() -> ImageStencilUsageCreateInfoBuilder<'a> {
33994 ImageStencilUsageCreateInfoBuilder {
33995 inner: Self::default(),
33996 marker: ::std::marker::PhantomData,
33997 }
33998 }
33999}
34000#[repr(transparent)]
34001pub struct ImageStencilUsageCreateInfoBuilder<'a> {
34002 inner: ImageStencilUsageCreateInfo,
34003 marker: ::std::marker::PhantomData<&'a ()>,
34004}
34005unsafe impl ExtendsImageCreateInfo for ImageStencilUsageCreateInfoBuilder<'_> {}
34006unsafe impl ExtendsImageCreateInfo for ImageStencilUsageCreateInfo {}
34007unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageStencilUsageCreateInfoBuilder<'_> {}
34008unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageStencilUsageCreateInfo {}
34009impl<'a> ::std::ops::Deref for ImageStencilUsageCreateInfoBuilder<'a> {
34010 type Target = ImageStencilUsageCreateInfo;
34011 fn deref(&self) -> &Self::Target {
34012 &self.inner
34013 }
34014}
34015impl<'a> ::std::ops::DerefMut for ImageStencilUsageCreateInfoBuilder<'a> {
34016 fn deref_mut(&mut self) -> &mut Self::Target {
34017 &mut self.inner
34018 }
34019}
34020impl<'a> ImageStencilUsageCreateInfoBuilder<'a> {
34021 pub fn stencil_usage(mut self, stencil_usage: ImageUsageFlags) -> Self {
34022 self.inner.stencil_usage = stencil_usage;
34023 self
34024 }
34025 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34026 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34027 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34028 pub fn build(self) -> ImageStencilUsageCreateInfo {
34029 self.inner
34030 }
34031}
34032#[repr(C)]
34033#[cfg_attr(feature = "debug", derive(Debug))]
34034#[derive(Copy, Clone)]
34035#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceMemoryOverallocationCreateInfoAMD.html>"]
34036pub struct DeviceMemoryOverallocationCreateInfoAMD {
34037 pub s_type: StructureType,
34038 pub p_next: *const c_void,
34039 pub overallocation_behavior: MemoryOverallocationBehaviorAMD,
34040}
34041impl ::std::default::Default for DeviceMemoryOverallocationCreateInfoAMD {
34042 fn default() -> Self {
34043 Self {
34044 s_type: StructureType::DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD,
34045 p_next: ::std::ptr::null(),
34046 overallocation_behavior: MemoryOverallocationBehaviorAMD::default(),
34047 }
34048 }
34049}
34050impl DeviceMemoryOverallocationCreateInfoAMD {
34051 pub fn builder<'a>() -> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
34052 DeviceMemoryOverallocationCreateInfoAMDBuilder {
34053 inner: Self::default(),
34054 marker: ::std::marker::PhantomData,
34055 }
34056 }
34057}
34058#[repr(transparent)]
34059pub struct DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
34060 inner: DeviceMemoryOverallocationCreateInfoAMD,
34061 marker: ::std::marker::PhantomData<&'a ()>,
34062}
34063unsafe impl ExtendsDeviceCreateInfo for DeviceMemoryOverallocationCreateInfoAMDBuilder<'_> {}
34064unsafe impl ExtendsDeviceCreateInfo for DeviceMemoryOverallocationCreateInfoAMD {}
34065impl<'a> ::std::ops::Deref for DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
34066 type Target = DeviceMemoryOverallocationCreateInfoAMD;
34067 fn deref(&self) -> &Self::Target {
34068 &self.inner
34069 }
34070}
34071impl<'a> ::std::ops::DerefMut for DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
34072 fn deref_mut(&mut self) -> &mut Self::Target {
34073 &mut self.inner
34074 }
34075}
34076impl<'a> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
34077 pub fn overallocation_behavior(
34078 mut self,
34079 overallocation_behavior: MemoryOverallocationBehaviorAMD,
34080 ) -> Self {
34081 self.inner.overallocation_behavior = overallocation_behavior;
34082 self
34083 }
34084 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34085 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34086 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34087 pub fn build(self) -> DeviceMemoryOverallocationCreateInfoAMD {
34088 self.inner
34089 }
34090}
34091#[repr(C)]
34092#[cfg_attr(feature = "debug", derive(Debug))]
34093#[derive(Copy, Clone)]
34094#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMapFeaturesEXT.html>"]
34095pub struct PhysicalDeviceFragmentDensityMapFeaturesEXT {
34096 pub s_type: StructureType,
34097 pub p_next: *mut c_void,
34098 pub fragment_density_map: Bool32,
34099 pub fragment_density_map_dynamic: Bool32,
34100 pub fragment_density_map_non_subsampled_images: Bool32,
34101}
34102impl ::std::default::Default for PhysicalDeviceFragmentDensityMapFeaturesEXT {
34103 fn default() -> Self {
34104 Self {
34105 s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT,
34106 p_next: ::std::ptr::null_mut(),
34107 fragment_density_map: Bool32::default(),
34108 fragment_density_map_dynamic: Bool32::default(),
34109 fragment_density_map_non_subsampled_images: Bool32::default(),
34110 }
34111 }
34112}
34113impl PhysicalDeviceFragmentDensityMapFeaturesEXT {
34114 pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
34115 PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder {
34116 inner: Self::default(),
34117 marker: ::std::marker::PhantomData,
34118 }
34119 }
34120}
34121#[repr(transparent)]
34122pub struct PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
34123 inner: PhysicalDeviceFragmentDensityMapFeaturesEXT,
34124 marker: ::std::marker::PhantomData<&'a ()>,
34125}
34126unsafe impl ExtendsPhysicalDeviceFeatures2
34127 for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'_>
34128{
34129}
34130unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMapFeaturesEXT {}
34131unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'_> {}
34132unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXT {}
34133impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
34134 type Target = PhysicalDeviceFragmentDensityMapFeaturesEXT;
34135 fn deref(&self) -> &Self::Target {
34136 &self.inner
34137 }
34138}
34139impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
34140 fn deref_mut(&mut self) -> &mut Self::Target {
34141 &mut self.inner
34142 }
34143}
34144impl<'a> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
34145 pub fn fragment_density_map(mut self, fragment_density_map: bool) -> Self {
34146 self.inner.fragment_density_map = fragment_density_map.into();
34147 self
34148 }
34149 pub fn fragment_density_map_dynamic(mut self, fragment_density_map_dynamic: bool) -> Self {
34150 self.inner.fragment_density_map_dynamic = fragment_density_map_dynamic.into();
34151 self
34152 }
34153 pub fn fragment_density_map_non_subsampled_images(
34154 mut self,
34155 fragment_density_map_non_subsampled_images: bool,
34156 ) -> Self {
34157 self.inner.fragment_density_map_non_subsampled_images =
34158 fragment_density_map_non_subsampled_images.into();
34159 self
34160 }
34161 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34162 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34163 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34164 pub fn build(self) -> PhysicalDeviceFragmentDensityMapFeaturesEXT {
34165 self.inner
34166 }
34167}
34168#[repr(C)]
34169#[cfg_attr(feature = "debug", derive(Debug))]
34170#[derive(Copy, Clone)]
34171#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMap2FeaturesEXT.html>"]
34172pub struct PhysicalDeviceFragmentDensityMap2FeaturesEXT {
34173 pub s_type: StructureType,
34174 pub p_next: *mut c_void,
34175 pub fragment_density_map_deferred: Bool32,
34176}
34177impl ::std::default::Default for PhysicalDeviceFragmentDensityMap2FeaturesEXT {
34178 fn default() -> Self {
34179 Self {
34180 s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT,
34181 p_next: ::std::ptr::null_mut(),
34182 fragment_density_map_deferred: Bool32::default(),
34183 }
34184 }
34185}
34186impl PhysicalDeviceFragmentDensityMap2FeaturesEXT {
34187 pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> {
34188 PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder {
34189 inner: Self::default(),
34190 marker: ::std::marker::PhantomData,
34191 }
34192 }
34193}
34194#[repr(transparent)]
34195pub struct PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> {
34196 inner: PhysicalDeviceFragmentDensityMap2FeaturesEXT,
34197 marker: ::std::marker::PhantomData<&'a ()>,
34198}
34199unsafe impl ExtendsPhysicalDeviceFeatures2
34200 for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'_>
34201{
34202}
34203unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMap2FeaturesEXT {}
34204unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'_> {}
34205unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMap2FeaturesEXT {}
34206impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> {
34207 type Target = PhysicalDeviceFragmentDensityMap2FeaturesEXT;
34208 fn deref(&self) -> &Self::Target {
34209 &self.inner
34210 }
34211}
34212impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> {
34213 fn deref_mut(&mut self) -> &mut Self::Target {
34214 &mut self.inner
34215 }
34216}
34217impl<'a> PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> {
34218 pub fn fragment_density_map_deferred(mut self, fragment_density_map_deferred: bool) -> Self {
34219 self.inner.fragment_density_map_deferred = fragment_density_map_deferred.into();
34220 self
34221 }
34222 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34223 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34224 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34225 pub fn build(self) -> PhysicalDeviceFragmentDensityMap2FeaturesEXT {
34226 self.inner
34227 }
34228}
34229#[repr(C)]
34230#[cfg_attr(feature = "debug", derive(Debug))]
34231#[derive(Copy, Clone)]
34232#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM.html>"]
34233pub struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
34234 pub s_type: StructureType,
34235 pub p_next: *mut c_void,
34236 pub fragment_density_map_offset: Bool32,
34237}
34238impl ::std::default::Default for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
34239 fn default() -> Self {
34240 Self {
34241 s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM,
34242 p_next: ::std::ptr::null_mut(),
34243 fragment_density_map_offset: Bool32::default(),
34244 }
34245 }
34246}
34247impl PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
34248 pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> {
34249 PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder {
34250 inner: Self::default(),
34251 marker: ::std::marker::PhantomData,
34252 }
34253 }
34254}
34255#[repr(transparent)]
34256pub struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> {
34257 inner: PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM,
34258 marker: ::std::marker::PhantomData<&'a ()>,
34259}
34260unsafe impl ExtendsPhysicalDeviceFeatures2
34261 for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'_>
34262{
34263}
34264unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {}
34265unsafe impl ExtendsDeviceCreateInfo
34266 for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'_>
34267{
34268}
34269unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {}
34270impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> {
34271 type Target = PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
34272 fn deref(&self) -> &Self::Target {
34273 &self.inner
34274 }
34275}
34276impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> {
34277 fn deref_mut(&mut self) -> &mut Self::Target {
34278 &mut self.inner
34279 }
34280}
34281impl<'a> PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> {
34282 pub fn fragment_density_map_offset(mut self, fragment_density_map_offset: bool) -> Self {
34283 self.inner.fragment_density_map_offset = fragment_density_map_offset.into();
34284 self
34285 }
34286 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34287 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34288 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34289 pub fn build(self) -> PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
34290 self.inner
34291 }
34292}
34293#[repr(C)]
34294#[cfg_attr(feature = "debug", derive(Debug))]
34295#[derive(Copy, Clone)]
34296#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMapPropertiesEXT.html>"]
34297pub struct PhysicalDeviceFragmentDensityMapPropertiesEXT {
34298 pub s_type: StructureType,
34299 pub p_next: *mut c_void,
34300 pub min_fragment_density_texel_size: Extent2D,
34301 pub max_fragment_density_texel_size: Extent2D,
34302 pub fragment_density_invocations: Bool32,
34303}
34304impl ::std::default::Default for PhysicalDeviceFragmentDensityMapPropertiesEXT {
34305 fn default() -> Self {
34306 Self {
34307 s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT,
34308 p_next: ::std::ptr::null_mut(),
34309 min_fragment_density_texel_size: Extent2D::default(),
34310 max_fragment_density_texel_size: Extent2D::default(),
34311 fragment_density_invocations: Bool32::default(),
34312 }
34313 }
34314}
34315impl PhysicalDeviceFragmentDensityMapPropertiesEXT {
34316 pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
34317 PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder {
34318 inner: Self::default(),
34319 marker: ::std::marker::PhantomData,
34320 }
34321 }
34322}
34323#[repr(transparent)]
34324pub struct PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
34325 inner: PhysicalDeviceFragmentDensityMapPropertiesEXT,
34326 marker: ::std::marker::PhantomData<&'a ()>,
34327}
34328unsafe impl ExtendsPhysicalDeviceProperties2
34329 for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'_>
34330{
34331}
34332unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentDensityMapPropertiesEXT {}
34333impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
34334 type Target = PhysicalDeviceFragmentDensityMapPropertiesEXT;
34335 fn deref(&self) -> &Self::Target {
34336 &self.inner
34337 }
34338}
34339impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
34340 fn deref_mut(&mut self) -> &mut Self::Target {
34341 &mut self.inner
34342 }
34343}
34344impl<'a> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
34345 pub fn min_fragment_density_texel_size(
34346 mut self,
34347 min_fragment_density_texel_size: Extent2D,
34348 ) -> Self {
34349 self.inner.min_fragment_density_texel_size = min_fragment_density_texel_size;
34350 self
34351 }
34352 pub fn max_fragment_density_texel_size(
34353 mut self,
34354 max_fragment_density_texel_size: Extent2D,
34355 ) -> Self {
34356 self.inner.max_fragment_density_texel_size = max_fragment_density_texel_size;
34357 self
34358 }
34359 pub fn fragment_density_invocations(mut self, fragment_density_invocations: bool) -> Self {
34360 self.inner.fragment_density_invocations = fragment_density_invocations.into();
34361 self
34362 }
34363 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34364 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34365 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34366 pub fn build(self) -> PhysicalDeviceFragmentDensityMapPropertiesEXT {
34367 self.inner
34368 }
34369}
34370#[repr(C)]
34371#[cfg_attr(feature = "debug", derive(Debug))]
34372#[derive(Copy, Clone)]
34373#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMap2PropertiesEXT.html>"]
34374pub struct PhysicalDeviceFragmentDensityMap2PropertiesEXT {
34375 pub s_type: StructureType,
34376 pub p_next: *mut c_void,
34377 pub subsampled_loads: Bool32,
34378 pub subsampled_coarse_reconstruction_early_access: Bool32,
34379 pub max_subsampled_array_layers: u32,
34380 pub max_descriptor_set_subsampled_samplers: u32,
34381}
34382impl ::std::default::Default for PhysicalDeviceFragmentDensityMap2PropertiesEXT {
34383 fn default() -> Self {
34384 Self {
34385 s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT,
34386 p_next: ::std::ptr::null_mut(),
34387 subsampled_loads: Bool32::default(),
34388 subsampled_coarse_reconstruction_early_access: Bool32::default(),
34389 max_subsampled_array_layers: u32::default(),
34390 max_descriptor_set_subsampled_samplers: u32::default(),
34391 }
34392 }
34393}
34394impl PhysicalDeviceFragmentDensityMap2PropertiesEXT {
34395 pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
34396 PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder {
34397 inner: Self::default(),
34398 marker: ::std::marker::PhantomData,
34399 }
34400 }
34401}
34402#[repr(transparent)]
34403pub struct PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
34404 inner: PhysicalDeviceFragmentDensityMap2PropertiesEXT,
34405 marker: ::std::marker::PhantomData<&'a ()>,
34406}
34407unsafe impl ExtendsPhysicalDeviceProperties2
34408 for PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'_>
34409{
34410}
34411unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentDensityMap2PropertiesEXT {}
34412impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
34413 type Target = PhysicalDeviceFragmentDensityMap2PropertiesEXT;
34414 fn deref(&self) -> &Self::Target {
34415 &self.inner
34416 }
34417}
34418impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
34419 fn deref_mut(&mut self) -> &mut Self::Target {
34420 &mut self.inner
34421 }
34422}
34423impl<'a> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
34424 pub fn subsampled_loads(mut self, subsampled_loads: bool) -> Self {
34425 self.inner.subsampled_loads = subsampled_loads.into();
34426 self
34427 }
34428 pub fn subsampled_coarse_reconstruction_early_access(
34429 mut self,
34430 subsampled_coarse_reconstruction_early_access: bool,
34431 ) -> Self {
34432 self.inner.subsampled_coarse_reconstruction_early_access =
34433 subsampled_coarse_reconstruction_early_access.into();
34434 self
34435 }
34436 pub fn max_subsampled_array_layers(mut self, max_subsampled_array_layers: u32) -> Self {
34437 self.inner.max_subsampled_array_layers = max_subsampled_array_layers;
34438 self
34439 }
34440 pub fn max_descriptor_set_subsampled_samplers(
34441 mut self,
34442 max_descriptor_set_subsampled_samplers: u32,
34443 ) -> Self {
34444 self.inner.max_descriptor_set_subsampled_samplers = max_descriptor_set_subsampled_samplers;
34445 self
34446 }
34447 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34448 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34449 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34450 pub fn build(self) -> PhysicalDeviceFragmentDensityMap2PropertiesEXT {
34451 self.inner
34452 }
34453}
34454#[repr(C)]
34455#[cfg_attr(feature = "debug", derive(Debug))]
34456#[derive(Copy, Clone)]
34457#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM.html>"]
34458pub struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
34459 pub s_type: StructureType,
34460 pub p_next: *mut c_void,
34461 pub fragment_density_offset_granularity: Extent2D,
34462}
34463impl ::std::default::Default for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
34464 fn default() -> Self {
34465 Self {
34466 s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM,
34467 p_next: ::std::ptr::null_mut(),
34468 fragment_density_offset_granularity: Extent2D::default(),
34469 }
34470 }
34471}
34472impl PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
34473 pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> {
34474 PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder {
34475 inner: Self::default(),
34476 marker: ::std::marker::PhantomData,
34477 }
34478 }
34479}
34480#[repr(transparent)]
34481pub struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> {
34482 inner: PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM,
34483 marker: ::std::marker::PhantomData<&'a ()>,
34484}
34485unsafe impl ExtendsPhysicalDeviceProperties2
34486 for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'_>
34487{
34488}
34489unsafe impl ExtendsPhysicalDeviceProperties2
34490 for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM
34491{
34492}
34493impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> {
34494 type Target = PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
34495 fn deref(&self) -> &Self::Target {
34496 &self.inner
34497 }
34498}
34499impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> {
34500 fn deref_mut(&mut self) -> &mut Self::Target {
34501 &mut self.inner
34502 }
34503}
34504impl<'a> PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> {
34505 pub fn fragment_density_offset_granularity(
34506 mut self,
34507 fragment_density_offset_granularity: Extent2D,
34508 ) -> Self {
34509 self.inner.fragment_density_offset_granularity = fragment_density_offset_granularity;
34510 self
34511 }
34512 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34513 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34514 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34515 pub fn build(self) -> PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
34516 self.inner
34517 }
34518}
34519#[repr(C)]
34520#[cfg_attr(feature = "debug", derive(Debug))]
34521#[derive(Copy, Clone)]
34522#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassFragmentDensityMapCreateInfoEXT.html>"]
34523pub struct RenderPassFragmentDensityMapCreateInfoEXT {
34524 pub s_type: StructureType,
34525 pub p_next: *const c_void,
34526 pub fragment_density_map_attachment: AttachmentReference,
34527}
34528impl ::std::default::Default for RenderPassFragmentDensityMapCreateInfoEXT {
34529 fn default() -> Self {
34530 Self {
34531 s_type: StructureType::RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT,
34532 p_next: ::std::ptr::null(),
34533 fragment_density_map_attachment: AttachmentReference::default(),
34534 }
34535 }
34536}
34537impl RenderPassFragmentDensityMapCreateInfoEXT {
34538 pub fn builder<'a>() -> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
34539 RenderPassFragmentDensityMapCreateInfoEXTBuilder {
34540 inner: Self::default(),
34541 marker: ::std::marker::PhantomData,
34542 }
34543 }
34544}
34545#[repr(transparent)]
34546pub struct RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
34547 inner: RenderPassFragmentDensityMapCreateInfoEXT,
34548 marker: ::std::marker::PhantomData<&'a ()>,
34549}
34550unsafe impl ExtendsRenderPassCreateInfo for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'_> {}
34551unsafe impl ExtendsRenderPassCreateInfo for RenderPassFragmentDensityMapCreateInfoEXT {}
34552unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'_> {}
34553unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassFragmentDensityMapCreateInfoEXT {}
34554impl<'a> ::std::ops::Deref for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
34555 type Target = RenderPassFragmentDensityMapCreateInfoEXT;
34556 fn deref(&self) -> &Self::Target {
34557 &self.inner
34558 }
34559}
34560impl<'a> ::std::ops::DerefMut for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
34561 fn deref_mut(&mut self) -> &mut Self::Target {
34562 &mut self.inner
34563 }
34564}
34565impl<'a> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
34566 pub fn fragment_density_map_attachment(
34567 mut self,
34568 fragment_density_map_attachment: AttachmentReference,
34569 ) -> Self {
34570 self.inner.fragment_density_map_attachment = fragment_density_map_attachment;
34571 self
34572 }
34573 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34574 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34575 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34576 pub fn build(self) -> RenderPassFragmentDensityMapCreateInfoEXT {
34577 self.inner
34578 }
34579}
34580#[repr(C)]
34581#[cfg_attr(feature = "debug", derive(Debug))]
34582#[derive(Copy, Clone)]
34583#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassFragmentDensityMapOffsetEndInfoQCOM.html>"]
34584pub struct SubpassFragmentDensityMapOffsetEndInfoQCOM {
34585 pub s_type: StructureType,
34586 pub p_next: *const c_void,
34587 pub fragment_density_offset_count: u32,
34588 pub p_fragment_density_offsets: *const Offset2D,
34589}
34590impl ::std::default::Default for SubpassFragmentDensityMapOffsetEndInfoQCOM {
34591 fn default() -> Self {
34592 Self {
34593 s_type: StructureType::SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM,
34594 p_next: ::std::ptr::null(),
34595 fragment_density_offset_count: u32::default(),
34596 p_fragment_density_offsets: ::std::ptr::null(),
34597 }
34598 }
34599}
34600impl SubpassFragmentDensityMapOffsetEndInfoQCOM {
34601 pub fn builder<'a>() -> SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> {
34602 SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder {
34603 inner: Self::default(),
34604 marker: ::std::marker::PhantomData,
34605 }
34606 }
34607}
34608#[repr(transparent)]
34609pub struct SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> {
34610 inner: SubpassFragmentDensityMapOffsetEndInfoQCOM,
34611 marker: ::std::marker::PhantomData<&'a ()>,
34612}
34613unsafe impl ExtendsSubpassEndInfo for SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'_> {}
34614unsafe impl ExtendsSubpassEndInfo for SubpassFragmentDensityMapOffsetEndInfoQCOM {}
34615impl<'a> ::std::ops::Deref for SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> {
34616 type Target = SubpassFragmentDensityMapOffsetEndInfoQCOM;
34617 fn deref(&self) -> &Self::Target {
34618 &self.inner
34619 }
34620}
34621impl<'a> ::std::ops::DerefMut for SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> {
34622 fn deref_mut(&mut self) -> &mut Self::Target {
34623 &mut self.inner
34624 }
34625}
34626impl<'a> SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> {
34627 pub fn fragment_density_offsets(mut self, fragment_density_offsets: &'a [Offset2D]) -> Self {
34628 self.inner.fragment_density_offset_count = fragment_density_offsets.len() as _;
34629 self.inner.p_fragment_density_offsets = fragment_density_offsets.as_ptr();
34630 self
34631 }
34632 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34633 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34634 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34635 pub fn build(self) -> SubpassFragmentDensityMapOffsetEndInfoQCOM {
34636 self.inner
34637 }
34638}
34639#[repr(C)]
34640#[cfg_attr(feature = "debug", derive(Debug))]
34641#[derive(Copy, Clone)]
34642#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceScalarBlockLayoutFeatures.html>"]
34643pub struct PhysicalDeviceScalarBlockLayoutFeatures {
34644 pub s_type: StructureType,
34645 pub p_next: *mut c_void,
34646 pub scalar_block_layout: Bool32,
34647}
34648impl ::std::default::Default for PhysicalDeviceScalarBlockLayoutFeatures {
34649 fn default() -> Self {
34650 Self {
34651 s_type: StructureType::PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES,
34652 p_next: ::std::ptr::null_mut(),
34653 scalar_block_layout: Bool32::default(),
34654 }
34655 }
34656}
34657impl PhysicalDeviceScalarBlockLayoutFeatures {
34658 pub fn builder<'a>() -> PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
34659 PhysicalDeviceScalarBlockLayoutFeaturesBuilder {
34660 inner: Self::default(),
34661 marker: ::std::marker::PhantomData,
34662 }
34663 }
34664}
34665#[repr(transparent)]
34666pub struct PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
34667 inner: PhysicalDeviceScalarBlockLayoutFeatures,
34668 marker: ::std::marker::PhantomData<&'a ()>,
34669}
34670unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'_> {}
34671unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceScalarBlockLayoutFeatures {}
34672unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'_> {}
34673unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeatures {}
34674impl<'a> ::std::ops::Deref for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
34675 type Target = PhysicalDeviceScalarBlockLayoutFeatures;
34676 fn deref(&self) -> &Self::Target {
34677 &self.inner
34678 }
34679}
34680impl<'a> ::std::ops::DerefMut for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
34681 fn deref_mut(&mut self) -> &mut Self::Target {
34682 &mut self.inner
34683 }
34684}
34685impl<'a> PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
34686 pub fn scalar_block_layout(mut self, scalar_block_layout: bool) -> Self {
34687 self.inner.scalar_block_layout = scalar_block_layout.into();
34688 self
34689 }
34690 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34691 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34692 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34693 pub fn build(self) -> PhysicalDeviceScalarBlockLayoutFeatures {
34694 self.inner
34695 }
34696}
34697#[repr(C)]
34698#[cfg_attr(feature = "debug", derive(Debug))]
34699#[derive(Copy, Clone)]
34700#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceProtectedCapabilitiesKHR.html>"]
34701pub struct SurfaceProtectedCapabilitiesKHR {
34702 pub s_type: StructureType,
34703 pub p_next: *const c_void,
34704 pub supports_protected: Bool32,
34705}
34706impl ::std::default::Default for SurfaceProtectedCapabilitiesKHR {
34707 fn default() -> Self {
34708 Self {
34709 s_type: StructureType::SURFACE_PROTECTED_CAPABILITIES_KHR,
34710 p_next: ::std::ptr::null(),
34711 supports_protected: Bool32::default(),
34712 }
34713 }
34714}
34715impl SurfaceProtectedCapabilitiesKHR {
34716 pub fn builder<'a>() -> SurfaceProtectedCapabilitiesKHRBuilder<'a> {
34717 SurfaceProtectedCapabilitiesKHRBuilder {
34718 inner: Self::default(),
34719 marker: ::std::marker::PhantomData,
34720 }
34721 }
34722}
34723#[repr(transparent)]
34724pub struct SurfaceProtectedCapabilitiesKHRBuilder<'a> {
34725 inner: SurfaceProtectedCapabilitiesKHR,
34726 marker: ::std::marker::PhantomData<&'a ()>,
34727}
34728unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceProtectedCapabilitiesKHRBuilder<'_> {}
34729unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceProtectedCapabilitiesKHR {}
34730impl<'a> ::std::ops::Deref for SurfaceProtectedCapabilitiesKHRBuilder<'a> {
34731 type Target = SurfaceProtectedCapabilitiesKHR;
34732 fn deref(&self) -> &Self::Target {
34733 &self.inner
34734 }
34735}
34736impl<'a> ::std::ops::DerefMut for SurfaceProtectedCapabilitiesKHRBuilder<'a> {
34737 fn deref_mut(&mut self) -> &mut Self::Target {
34738 &mut self.inner
34739 }
34740}
34741impl<'a> SurfaceProtectedCapabilitiesKHRBuilder<'a> {
34742 pub fn supports_protected(mut self, supports_protected: bool) -> Self {
34743 self.inner.supports_protected = supports_protected.into();
34744 self
34745 }
34746 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34747 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34748 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34749 pub fn build(self) -> SurfaceProtectedCapabilitiesKHR {
34750 self.inner
34751 }
34752}
34753#[repr(C)]
34754#[cfg_attr(feature = "debug", derive(Debug))]
34755#[derive(Copy, Clone)]
34756#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceUniformBufferStandardLayoutFeatures.html>"]
34757pub struct PhysicalDeviceUniformBufferStandardLayoutFeatures {
34758 pub s_type: StructureType,
34759 pub p_next: *mut c_void,
34760 pub uniform_buffer_standard_layout: Bool32,
34761}
34762impl ::std::default::Default for PhysicalDeviceUniformBufferStandardLayoutFeatures {
34763 fn default() -> Self {
34764 Self {
34765 s_type: StructureType::PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES,
34766 p_next: ::std::ptr::null_mut(),
34767 uniform_buffer_standard_layout: Bool32::default(),
34768 }
34769 }
34770}
34771impl PhysicalDeviceUniformBufferStandardLayoutFeatures {
34772 pub fn builder<'a>() -> PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
34773 PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder {
34774 inner: Self::default(),
34775 marker: ::std::marker::PhantomData,
34776 }
34777 }
34778}
34779#[repr(transparent)]
34780pub struct PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
34781 inner: PhysicalDeviceUniformBufferStandardLayoutFeatures,
34782 marker: ::std::marker::PhantomData<&'a ()>,
34783}
34784unsafe impl ExtendsPhysicalDeviceFeatures2
34785 for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'_>
34786{
34787}
34788unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceUniformBufferStandardLayoutFeatures {}
34789unsafe impl ExtendsDeviceCreateInfo
34790 for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'_>
34791{
34792}
34793unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceUniformBufferStandardLayoutFeatures {}
34794impl<'a> ::std::ops::Deref for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
34795 type Target = PhysicalDeviceUniformBufferStandardLayoutFeatures;
34796 fn deref(&self) -> &Self::Target {
34797 &self.inner
34798 }
34799}
34800impl<'a> ::std::ops::DerefMut for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
34801 fn deref_mut(&mut self) -> &mut Self::Target {
34802 &mut self.inner
34803 }
34804}
34805impl<'a> PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
34806 pub fn uniform_buffer_standard_layout(mut self, uniform_buffer_standard_layout: bool) -> Self {
34807 self.inner.uniform_buffer_standard_layout = uniform_buffer_standard_layout.into();
34808 self
34809 }
34810 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34811 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34812 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34813 pub fn build(self) -> PhysicalDeviceUniformBufferStandardLayoutFeatures {
34814 self.inner
34815 }
34816}
34817#[repr(C)]
34818#[cfg_attr(feature = "debug", derive(Debug))]
34819#[derive(Copy, Clone)]
34820#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDepthClipEnableFeaturesEXT.html>"]
34821pub struct PhysicalDeviceDepthClipEnableFeaturesEXT {
34822 pub s_type: StructureType,
34823 pub p_next: *mut c_void,
34824 pub depth_clip_enable: Bool32,
34825}
34826impl ::std::default::Default for PhysicalDeviceDepthClipEnableFeaturesEXT {
34827 fn default() -> Self {
34828 Self {
34829 s_type: StructureType::PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT,
34830 p_next: ::std::ptr::null_mut(),
34831 depth_clip_enable: Bool32::default(),
34832 }
34833 }
34834}
34835impl PhysicalDeviceDepthClipEnableFeaturesEXT {
34836 pub fn builder<'a>() -> PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
34837 PhysicalDeviceDepthClipEnableFeaturesEXTBuilder {
34838 inner: Self::default(),
34839 marker: ::std::marker::PhantomData,
34840 }
34841 }
34842}
34843#[repr(transparent)]
34844pub struct PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
34845 inner: PhysicalDeviceDepthClipEnableFeaturesEXT,
34846 marker: ::std::marker::PhantomData<&'a ()>,
34847}
34848unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'_> {}
34849unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClipEnableFeaturesEXT {}
34850unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'_> {}
34851unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipEnableFeaturesEXT {}
34852impl<'a> ::std::ops::Deref for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
34853 type Target = PhysicalDeviceDepthClipEnableFeaturesEXT;
34854 fn deref(&self) -> &Self::Target {
34855 &self.inner
34856 }
34857}
34858impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
34859 fn deref_mut(&mut self) -> &mut Self::Target {
34860 &mut self.inner
34861 }
34862}
34863impl<'a> PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
34864 pub fn depth_clip_enable(mut self, depth_clip_enable: bool) -> Self {
34865 self.inner.depth_clip_enable = depth_clip_enable.into();
34866 self
34867 }
34868 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34869 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34870 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34871 pub fn build(self) -> PhysicalDeviceDepthClipEnableFeaturesEXT {
34872 self.inner
34873 }
34874}
34875#[repr(C)]
34876#[cfg_attr(feature = "debug", derive(Debug))]
34877#[derive(Copy, Clone)]
34878#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationDepthClipStateCreateInfoEXT.html>"]
34879pub struct PipelineRasterizationDepthClipStateCreateInfoEXT {
34880 pub s_type: StructureType,
34881 pub p_next: *const c_void,
34882 pub flags: PipelineRasterizationDepthClipStateCreateFlagsEXT,
34883 pub depth_clip_enable: Bool32,
34884}
34885impl ::std::default::Default for PipelineRasterizationDepthClipStateCreateInfoEXT {
34886 fn default() -> Self {
34887 Self {
34888 s_type: StructureType::PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT,
34889 p_next: ::std::ptr::null(),
34890 flags: PipelineRasterizationDepthClipStateCreateFlagsEXT::default(),
34891 depth_clip_enable: Bool32::default(),
34892 }
34893 }
34894}
34895impl PipelineRasterizationDepthClipStateCreateInfoEXT {
34896 pub fn builder<'a>() -> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
34897 PipelineRasterizationDepthClipStateCreateInfoEXTBuilder {
34898 inner: Self::default(),
34899 marker: ::std::marker::PhantomData,
34900 }
34901 }
34902}
34903#[repr(transparent)]
34904pub struct PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
34905 inner: PipelineRasterizationDepthClipStateCreateInfoEXT,
34906 marker: ::std::marker::PhantomData<&'a ()>,
34907}
34908unsafe impl ExtendsPipelineRasterizationStateCreateInfo
34909 for PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'_>
34910{
34911}
34912unsafe impl ExtendsPipelineRasterizationStateCreateInfo
34913 for PipelineRasterizationDepthClipStateCreateInfoEXT
34914{
34915}
34916impl<'a> ::std::ops::Deref for PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
34917 type Target = PipelineRasterizationDepthClipStateCreateInfoEXT;
34918 fn deref(&self) -> &Self::Target {
34919 &self.inner
34920 }
34921}
34922impl<'a> ::std::ops::DerefMut for PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
34923 fn deref_mut(&mut self) -> &mut Self::Target {
34924 &mut self.inner
34925 }
34926}
34927impl<'a> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
34928 pub fn flags(mut self, flags: PipelineRasterizationDepthClipStateCreateFlagsEXT) -> Self {
34929 self.inner.flags = flags;
34930 self
34931 }
34932 pub fn depth_clip_enable(mut self, depth_clip_enable: bool) -> Self {
34933 self.inner.depth_clip_enable = depth_clip_enable.into();
34934 self
34935 }
34936 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34937 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34938 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34939 pub fn build(self) -> PipelineRasterizationDepthClipStateCreateInfoEXT {
34940 self.inner
34941 }
34942}
34943#[repr(C)]
34944#[cfg_attr(feature = "debug", derive(Debug))]
34945#[derive(Copy, Clone)]
34946#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMemoryBudgetPropertiesEXT.html>"]
34947pub struct PhysicalDeviceMemoryBudgetPropertiesEXT {
34948 pub s_type: StructureType,
34949 pub p_next: *mut c_void,
34950 pub heap_budget: [DeviceSize; MAX_MEMORY_HEAPS],
34951 pub heap_usage: [DeviceSize; MAX_MEMORY_HEAPS],
34952}
34953impl ::std::default::Default for PhysicalDeviceMemoryBudgetPropertiesEXT {
34954 fn default() -> Self {
34955 Self {
34956 s_type: StructureType::PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT,
34957 p_next: ::std::ptr::null_mut(),
34958 heap_budget: unsafe { ::std::mem::zeroed() },
34959 heap_usage: unsafe { ::std::mem::zeroed() },
34960 }
34961 }
34962}
34963impl PhysicalDeviceMemoryBudgetPropertiesEXT {
34964 pub fn builder<'a>() -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
34965 PhysicalDeviceMemoryBudgetPropertiesEXTBuilder {
34966 inner: Self::default(),
34967 marker: ::std::marker::PhantomData,
34968 }
34969 }
34970}
34971#[repr(transparent)]
34972pub struct PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
34973 inner: PhysicalDeviceMemoryBudgetPropertiesEXT,
34974 marker: ::std::marker::PhantomData<&'a ()>,
34975}
34976unsafe impl ExtendsPhysicalDeviceMemoryProperties2
34977 for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'_>
34978{
34979}
34980unsafe impl ExtendsPhysicalDeviceMemoryProperties2 for PhysicalDeviceMemoryBudgetPropertiesEXT {}
34981impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
34982 type Target = PhysicalDeviceMemoryBudgetPropertiesEXT;
34983 fn deref(&self) -> &Self::Target {
34984 &self.inner
34985 }
34986}
34987impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
34988 fn deref_mut(&mut self) -> &mut Self::Target {
34989 &mut self.inner
34990 }
34991}
34992impl<'a> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
34993 pub fn heap_budget(mut self, heap_budget: [DeviceSize; MAX_MEMORY_HEAPS]) -> Self {
34994 self.inner.heap_budget = heap_budget;
34995 self
34996 }
34997 pub fn heap_usage(mut self, heap_usage: [DeviceSize; MAX_MEMORY_HEAPS]) -> Self {
34998 self.inner.heap_usage = heap_usage;
34999 self
35000 }
35001 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35002 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35003 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35004 pub fn build(self) -> PhysicalDeviceMemoryBudgetPropertiesEXT {
35005 self.inner
35006 }
35007}
35008#[repr(C)]
35009#[cfg_attr(feature = "debug", derive(Debug))]
35010#[derive(Copy, Clone)]
35011#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMemoryPriorityFeaturesEXT.html>"]
35012pub struct PhysicalDeviceMemoryPriorityFeaturesEXT {
35013 pub s_type: StructureType,
35014 pub p_next: *mut c_void,
35015 pub memory_priority: Bool32,
35016}
35017impl ::std::default::Default for PhysicalDeviceMemoryPriorityFeaturesEXT {
35018 fn default() -> Self {
35019 Self {
35020 s_type: StructureType::PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT,
35021 p_next: ::std::ptr::null_mut(),
35022 memory_priority: Bool32::default(),
35023 }
35024 }
35025}
35026impl PhysicalDeviceMemoryPriorityFeaturesEXT {
35027 pub fn builder<'a>() -> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
35028 PhysicalDeviceMemoryPriorityFeaturesEXTBuilder {
35029 inner: Self::default(),
35030 marker: ::std::marker::PhantomData,
35031 }
35032 }
35033}
35034#[repr(transparent)]
35035pub struct PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
35036 inner: PhysicalDeviceMemoryPriorityFeaturesEXT,
35037 marker: ::std::marker::PhantomData<&'a ()>,
35038}
35039unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'_> {}
35040unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMemoryPriorityFeaturesEXT {}
35041unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'_> {}
35042unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXT {}
35043impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
35044 type Target = PhysicalDeviceMemoryPriorityFeaturesEXT;
35045 fn deref(&self) -> &Self::Target {
35046 &self.inner
35047 }
35048}
35049impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
35050 fn deref_mut(&mut self) -> &mut Self::Target {
35051 &mut self.inner
35052 }
35053}
35054impl<'a> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
35055 pub fn memory_priority(mut self, memory_priority: bool) -> Self {
35056 self.inner.memory_priority = memory_priority.into();
35057 self
35058 }
35059 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35060 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35061 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35062 pub fn build(self) -> PhysicalDeviceMemoryPriorityFeaturesEXT {
35063 self.inner
35064 }
35065}
35066#[repr(C)]
35067#[cfg_attr(feature = "debug", derive(Debug))]
35068#[derive(Copy, Clone)]
35069#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryPriorityAllocateInfoEXT.html>"]
35070pub struct MemoryPriorityAllocateInfoEXT {
35071 pub s_type: StructureType,
35072 pub p_next: *const c_void,
35073 pub priority: f32,
35074}
35075impl ::std::default::Default for MemoryPriorityAllocateInfoEXT {
35076 fn default() -> Self {
35077 Self {
35078 s_type: StructureType::MEMORY_PRIORITY_ALLOCATE_INFO_EXT,
35079 p_next: ::std::ptr::null(),
35080 priority: f32::default(),
35081 }
35082 }
35083}
35084impl MemoryPriorityAllocateInfoEXT {
35085 pub fn builder<'a>() -> MemoryPriorityAllocateInfoEXTBuilder<'a> {
35086 MemoryPriorityAllocateInfoEXTBuilder {
35087 inner: Self::default(),
35088 marker: ::std::marker::PhantomData,
35089 }
35090 }
35091}
35092#[repr(transparent)]
35093pub struct MemoryPriorityAllocateInfoEXTBuilder<'a> {
35094 inner: MemoryPriorityAllocateInfoEXT,
35095 marker: ::std::marker::PhantomData<&'a ()>,
35096}
35097unsafe impl ExtendsMemoryAllocateInfo for MemoryPriorityAllocateInfoEXTBuilder<'_> {}
35098unsafe impl ExtendsMemoryAllocateInfo for MemoryPriorityAllocateInfoEXT {}
35099impl<'a> ::std::ops::Deref for MemoryPriorityAllocateInfoEXTBuilder<'a> {
35100 type Target = MemoryPriorityAllocateInfoEXT;
35101 fn deref(&self) -> &Self::Target {
35102 &self.inner
35103 }
35104}
35105impl<'a> ::std::ops::DerefMut for MemoryPriorityAllocateInfoEXTBuilder<'a> {
35106 fn deref_mut(&mut self) -> &mut Self::Target {
35107 &mut self.inner
35108 }
35109}
35110impl<'a> MemoryPriorityAllocateInfoEXTBuilder<'a> {
35111 pub fn priority(mut self, priority: f32) -> Self {
35112 self.inner.priority = priority;
35113 self
35114 }
35115 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35116 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35117 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35118 pub fn build(self) -> MemoryPriorityAllocateInfoEXT {
35119 self.inner
35120 }
35121}
35122#[repr(C)]
35123#[cfg_attr(feature = "debug", derive(Debug))]
35124#[derive(Copy, Clone)]
35125#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT.html>"]
35126pub struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
35127 pub s_type: StructureType,
35128 pub p_next: *mut c_void,
35129 pub pageable_device_local_memory: Bool32,
35130}
35131impl ::std::default::Default for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
35132 fn default() -> Self {
35133 Self {
35134 s_type: StructureType::PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT,
35135 p_next: ::std::ptr::null_mut(),
35136 pageable_device_local_memory: Bool32::default(),
35137 }
35138 }
35139}
35140impl PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
35141 pub fn builder<'a>() -> PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> {
35142 PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder {
35143 inner: Self::default(),
35144 marker: ::std::marker::PhantomData,
35145 }
35146 }
35147}
35148#[repr(transparent)]
35149pub struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> {
35150 inner: PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT,
35151 marker: ::std::marker::PhantomData<&'a ()>,
35152}
35153unsafe impl ExtendsPhysicalDeviceFeatures2
35154 for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'_>
35155{
35156}
35157unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {}
35158unsafe impl ExtendsDeviceCreateInfo
35159 for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'_>
35160{
35161}
35162unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {}
35163impl<'a> ::std::ops::Deref for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> {
35164 type Target = PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT;
35165 fn deref(&self) -> &Self::Target {
35166 &self.inner
35167 }
35168}
35169impl<'a> ::std::ops::DerefMut for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> {
35170 fn deref_mut(&mut self) -> &mut Self::Target {
35171 &mut self.inner
35172 }
35173}
35174impl<'a> PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> {
35175 pub fn pageable_device_local_memory(mut self, pageable_device_local_memory: bool) -> Self {
35176 self.inner.pageable_device_local_memory = pageable_device_local_memory.into();
35177 self
35178 }
35179 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35180 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35181 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35182 pub fn build(self) -> PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
35183 self.inner
35184 }
35185}
35186#[repr(C)]
35187#[cfg_attr(feature = "debug", derive(Debug))]
35188#[derive(Copy, Clone)]
35189#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceBufferDeviceAddressFeatures.html>"]
35190pub struct PhysicalDeviceBufferDeviceAddressFeatures {
35191 pub s_type: StructureType,
35192 pub p_next: *mut c_void,
35193 pub buffer_device_address: Bool32,
35194 pub buffer_device_address_capture_replay: Bool32,
35195 pub buffer_device_address_multi_device: Bool32,
35196}
35197impl ::std::default::Default for PhysicalDeviceBufferDeviceAddressFeatures {
35198 fn default() -> Self {
35199 Self {
35200 s_type: StructureType::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES,
35201 p_next: ::std::ptr::null_mut(),
35202 buffer_device_address: Bool32::default(),
35203 buffer_device_address_capture_replay: Bool32::default(),
35204 buffer_device_address_multi_device: Bool32::default(),
35205 }
35206 }
35207}
35208impl PhysicalDeviceBufferDeviceAddressFeatures {
35209 pub fn builder<'a>() -> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
35210 PhysicalDeviceBufferDeviceAddressFeaturesBuilder {
35211 inner: Self::default(),
35212 marker: ::std::marker::PhantomData,
35213 }
35214 }
35215}
35216#[repr(transparent)]
35217pub struct PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
35218 inner: PhysicalDeviceBufferDeviceAddressFeatures,
35219 marker: ::std::marker::PhantomData<&'a ()>,
35220}
35221unsafe impl ExtendsPhysicalDeviceFeatures2
35222 for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'_>
35223{
35224}
35225unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBufferDeviceAddressFeatures {}
35226unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'_> {}
35227unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeatures {}
35228impl<'a> ::std::ops::Deref for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
35229 type Target = PhysicalDeviceBufferDeviceAddressFeatures;
35230 fn deref(&self) -> &Self::Target {
35231 &self.inner
35232 }
35233}
35234impl<'a> ::std::ops::DerefMut for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
35235 fn deref_mut(&mut self) -> &mut Self::Target {
35236 &mut self.inner
35237 }
35238}
35239impl<'a> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
35240 pub fn buffer_device_address(mut self, buffer_device_address: bool) -> Self {
35241 self.inner.buffer_device_address = buffer_device_address.into();
35242 self
35243 }
35244 pub fn buffer_device_address_capture_replay(
35245 mut self,
35246 buffer_device_address_capture_replay: bool,
35247 ) -> Self {
35248 self.inner.buffer_device_address_capture_replay =
35249 buffer_device_address_capture_replay.into();
35250 self
35251 }
35252 pub fn buffer_device_address_multi_device(
35253 mut self,
35254 buffer_device_address_multi_device: bool,
35255 ) -> Self {
35256 self.inner.buffer_device_address_multi_device = buffer_device_address_multi_device.into();
35257 self
35258 }
35259 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35260 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35261 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35262 pub fn build(self) -> PhysicalDeviceBufferDeviceAddressFeatures {
35263 self.inner
35264 }
35265}
35266#[repr(C)]
35267#[cfg_attr(feature = "debug", derive(Debug))]
35268#[derive(Copy, Clone)]
35269#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceBufferDeviceAddressFeaturesEXT.html>"]
35270pub struct PhysicalDeviceBufferDeviceAddressFeaturesEXT {
35271 pub s_type: StructureType,
35272 pub p_next: *mut c_void,
35273 pub buffer_device_address: Bool32,
35274 pub buffer_device_address_capture_replay: Bool32,
35275 pub buffer_device_address_multi_device: Bool32,
35276}
35277impl ::std::default::Default for PhysicalDeviceBufferDeviceAddressFeaturesEXT {
35278 fn default() -> Self {
35279 Self {
35280 s_type: StructureType::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT,
35281 p_next: ::std::ptr::null_mut(),
35282 buffer_device_address: Bool32::default(),
35283 buffer_device_address_capture_replay: Bool32::default(),
35284 buffer_device_address_multi_device: Bool32::default(),
35285 }
35286 }
35287}
35288impl PhysicalDeviceBufferDeviceAddressFeaturesEXT {
35289 pub fn builder<'a>() -> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
35290 PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder {
35291 inner: Self::default(),
35292 marker: ::std::marker::PhantomData,
35293 }
35294 }
35295}
35296#[repr(transparent)]
35297pub struct PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
35298 inner: PhysicalDeviceBufferDeviceAddressFeaturesEXT,
35299 marker: ::std::marker::PhantomData<&'a ()>,
35300}
35301unsafe impl ExtendsPhysicalDeviceFeatures2
35302 for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'_>
35303{
35304}
35305unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBufferDeviceAddressFeaturesEXT {}
35306unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'_> {}
35307unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeaturesEXT {}
35308impl<'a> ::std::ops::Deref for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
35309 type Target = PhysicalDeviceBufferDeviceAddressFeaturesEXT;
35310 fn deref(&self) -> &Self::Target {
35311 &self.inner
35312 }
35313}
35314impl<'a> ::std::ops::DerefMut for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
35315 fn deref_mut(&mut self) -> &mut Self::Target {
35316 &mut self.inner
35317 }
35318}
35319impl<'a> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
35320 pub fn buffer_device_address(mut self, buffer_device_address: bool) -> Self {
35321 self.inner.buffer_device_address = buffer_device_address.into();
35322 self
35323 }
35324 pub fn buffer_device_address_capture_replay(
35325 mut self,
35326 buffer_device_address_capture_replay: bool,
35327 ) -> Self {
35328 self.inner.buffer_device_address_capture_replay =
35329 buffer_device_address_capture_replay.into();
35330 self
35331 }
35332 pub fn buffer_device_address_multi_device(
35333 mut self,
35334 buffer_device_address_multi_device: bool,
35335 ) -> Self {
35336 self.inner.buffer_device_address_multi_device = buffer_device_address_multi_device.into();
35337 self
35338 }
35339 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35340 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35341 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35342 pub fn build(self) -> PhysicalDeviceBufferDeviceAddressFeaturesEXT {
35343 self.inner
35344 }
35345}
35346#[repr(C)]
35347#[cfg_attr(feature = "debug", derive(Debug))]
35348#[derive(Copy, Clone)]
35349#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferDeviceAddressInfo.html>"]
35350pub struct BufferDeviceAddressInfo {
35351 pub s_type: StructureType,
35352 pub p_next: *const c_void,
35353 pub buffer: Buffer,
35354}
35355impl ::std::default::Default for BufferDeviceAddressInfo {
35356 fn default() -> Self {
35357 Self {
35358 s_type: StructureType::BUFFER_DEVICE_ADDRESS_INFO,
35359 p_next: ::std::ptr::null(),
35360 buffer: Buffer::default(),
35361 }
35362 }
35363}
35364impl BufferDeviceAddressInfo {
35365 pub fn builder<'a>() -> BufferDeviceAddressInfoBuilder<'a> {
35366 BufferDeviceAddressInfoBuilder {
35367 inner: Self::default(),
35368 marker: ::std::marker::PhantomData,
35369 }
35370 }
35371}
35372#[repr(transparent)]
35373pub struct BufferDeviceAddressInfoBuilder<'a> {
35374 inner: BufferDeviceAddressInfo,
35375 marker: ::std::marker::PhantomData<&'a ()>,
35376}
35377impl<'a> ::std::ops::Deref for BufferDeviceAddressInfoBuilder<'a> {
35378 type Target = BufferDeviceAddressInfo;
35379 fn deref(&self) -> &Self::Target {
35380 &self.inner
35381 }
35382}
35383impl<'a> ::std::ops::DerefMut for BufferDeviceAddressInfoBuilder<'a> {
35384 fn deref_mut(&mut self) -> &mut Self::Target {
35385 &mut self.inner
35386 }
35387}
35388impl<'a> BufferDeviceAddressInfoBuilder<'a> {
35389 pub fn buffer(mut self, buffer: Buffer) -> Self {
35390 self.inner.buffer = buffer;
35391 self
35392 }
35393 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35394 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35395 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35396 pub fn build(self) -> BufferDeviceAddressInfo {
35397 self.inner
35398 }
35399}
35400#[repr(C)]
35401#[cfg_attr(feature = "debug", derive(Debug))]
35402#[derive(Copy, Clone)]
35403#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferOpaqueCaptureAddressCreateInfo.html>"]
35404pub struct BufferOpaqueCaptureAddressCreateInfo {
35405 pub s_type: StructureType,
35406 pub p_next: *const c_void,
35407 pub opaque_capture_address: u64,
35408}
35409impl ::std::default::Default for BufferOpaqueCaptureAddressCreateInfo {
35410 fn default() -> Self {
35411 Self {
35412 s_type: StructureType::BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO,
35413 p_next: ::std::ptr::null(),
35414 opaque_capture_address: u64::default(),
35415 }
35416 }
35417}
35418impl BufferOpaqueCaptureAddressCreateInfo {
35419 pub fn builder<'a>() -> BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
35420 BufferOpaqueCaptureAddressCreateInfoBuilder {
35421 inner: Self::default(),
35422 marker: ::std::marker::PhantomData,
35423 }
35424 }
35425}
35426#[repr(transparent)]
35427pub struct BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
35428 inner: BufferOpaqueCaptureAddressCreateInfo,
35429 marker: ::std::marker::PhantomData<&'a ()>,
35430}
35431unsafe impl ExtendsBufferCreateInfo for BufferOpaqueCaptureAddressCreateInfoBuilder<'_> {}
35432unsafe impl ExtendsBufferCreateInfo for BufferOpaqueCaptureAddressCreateInfo {}
35433impl<'a> ::std::ops::Deref for BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
35434 type Target = BufferOpaqueCaptureAddressCreateInfo;
35435 fn deref(&self) -> &Self::Target {
35436 &self.inner
35437 }
35438}
35439impl<'a> ::std::ops::DerefMut for BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
35440 fn deref_mut(&mut self) -> &mut Self::Target {
35441 &mut self.inner
35442 }
35443}
35444impl<'a> BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
35445 pub fn opaque_capture_address(mut self, opaque_capture_address: u64) -> Self {
35446 self.inner.opaque_capture_address = opaque_capture_address;
35447 self
35448 }
35449 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35450 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35451 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35452 pub fn build(self) -> BufferOpaqueCaptureAddressCreateInfo {
35453 self.inner
35454 }
35455}
35456#[repr(C)]
35457#[cfg_attr(feature = "debug", derive(Debug))]
35458#[derive(Copy, Clone)]
35459#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferDeviceAddressCreateInfoEXT.html>"]
35460pub struct BufferDeviceAddressCreateInfoEXT {
35461 pub s_type: StructureType,
35462 pub p_next: *const c_void,
35463 pub device_address: DeviceAddress,
35464}
35465impl ::std::default::Default for BufferDeviceAddressCreateInfoEXT {
35466 fn default() -> Self {
35467 Self {
35468 s_type: StructureType::BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT,
35469 p_next: ::std::ptr::null(),
35470 device_address: DeviceAddress::default(),
35471 }
35472 }
35473}
35474impl BufferDeviceAddressCreateInfoEXT {
35475 pub fn builder<'a>() -> BufferDeviceAddressCreateInfoEXTBuilder<'a> {
35476 BufferDeviceAddressCreateInfoEXTBuilder {
35477 inner: Self::default(),
35478 marker: ::std::marker::PhantomData,
35479 }
35480 }
35481}
35482#[repr(transparent)]
35483pub struct BufferDeviceAddressCreateInfoEXTBuilder<'a> {
35484 inner: BufferDeviceAddressCreateInfoEXT,
35485 marker: ::std::marker::PhantomData<&'a ()>,
35486}
35487unsafe impl ExtendsBufferCreateInfo for BufferDeviceAddressCreateInfoEXTBuilder<'_> {}
35488unsafe impl ExtendsBufferCreateInfo for BufferDeviceAddressCreateInfoEXT {}
35489impl<'a> ::std::ops::Deref for BufferDeviceAddressCreateInfoEXTBuilder<'a> {
35490 type Target = BufferDeviceAddressCreateInfoEXT;
35491 fn deref(&self) -> &Self::Target {
35492 &self.inner
35493 }
35494}
35495impl<'a> ::std::ops::DerefMut for BufferDeviceAddressCreateInfoEXTBuilder<'a> {
35496 fn deref_mut(&mut self) -> &mut Self::Target {
35497 &mut self.inner
35498 }
35499}
35500impl<'a> BufferDeviceAddressCreateInfoEXTBuilder<'a> {
35501 pub fn device_address(mut self, device_address: DeviceAddress) -> Self {
35502 self.inner.device_address = device_address;
35503 self
35504 }
35505 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35506 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35507 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35508 pub fn build(self) -> BufferDeviceAddressCreateInfoEXT {
35509 self.inner
35510 }
35511}
35512#[repr(C)]
35513#[cfg_attr(feature = "debug", derive(Debug))]
35514#[derive(Copy, Clone)]
35515#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageViewImageFormatInfoEXT.html>"]
35516pub struct PhysicalDeviceImageViewImageFormatInfoEXT {
35517 pub s_type: StructureType,
35518 pub p_next: *mut c_void,
35519 pub image_view_type: ImageViewType,
35520}
35521impl ::std::default::Default for PhysicalDeviceImageViewImageFormatInfoEXT {
35522 fn default() -> Self {
35523 Self {
35524 s_type: StructureType::PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT,
35525 p_next: ::std::ptr::null_mut(),
35526 image_view_type: ImageViewType::default(),
35527 }
35528 }
35529}
35530impl PhysicalDeviceImageViewImageFormatInfoEXT {
35531 pub fn builder<'a>() -> PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
35532 PhysicalDeviceImageViewImageFormatInfoEXTBuilder {
35533 inner: Self::default(),
35534 marker: ::std::marker::PhantomData,
35535 }
35536 }
35537}
35538#[repr(transparent)]
35539pub struct PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
35540 inner: PhysicalDeviceImageViewImageFormatInfoEXT,
35541 marker: ::std::marker::PhantomData<&'a ()>,
35542}
35543unsafe impl ExtendsPhysicalDeviceImageFormatInfo2
35544 for PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'_>
35545{
35546}
35547unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceImageViewImageFormatInfoEXT {}
35548impl<'a> ::std::ops::Deref for PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
35549 type Target = PhysicalDeviceImageViewImageFormatInfoEXT;
35550 fn deref(&self) -> &Self::Target {
35551 &self.inner
35552 }
35553}
35554impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
35555 fn deref_mut(&mut self) -> &mut Self::Target {
35556 &mut self.inner
35557 }
35558}
35559impl<'a> PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
35560 pub fn image_view_type(mut self, image_view_type: ImageViewType) -> Self {
35561 self.inner.image_view_type = image_view_type;
35562 self
35563 }
35564 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35565 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35566 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35567 pub fn build(self) -> PhysicalDeviceImageViewImageFormatInfoEXT {
35568 self.inner
35569 }
35570}
35571#[repr(C)]
35572#[cfg_attr(feature = "debug", derive(Debug))]
35573#[derive(Copy, Clone)]
35574#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFilterCubicImageViewImageFormatPropertiesEXT.html>"]
35575pub struct FilterCubicImageViewImageFormatPropertiesEXT {
35576 pub s_type: StructureType,
35577 pub p_next: *mut c_void,
35578 pub filter_cubic: Bool32,
35579 pub filter_cubic_minmax: Bool32,
35580}
35581impl ::std::default::Default for FilterCubicImageViewImageFormatPropertiesEXT {
35582 fn default() -> Self {
35583 Self {
35584 s_type: StructureType::FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT,
35585 p_next: ::std::ptr::null_mut(),
35586 filter_cubic: Bool32::default(),
35587 filter_cubic_minmax: Bool32::default(),
35588 }
35589 }
35590}
35591impl FilterCubicImageViewImageFormatPropertiesEXT {
35592 pub fn builder<'a>() -> FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
35593 FilterCubicImageViewImageFormatPropertiesEXTBuilder {
35594 inner: Self::default(),
35595 marker: ::std::marker::PhantomData,
35596 }
35597 }
35598}
35599#[repr(transparent)]
35600pub struct FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
35601 inner: FilterCubicImageViewImageFormatPropertiesEXT,
35602 marker: ::std::marker::PhantomData<&'a ()>,
35603}
35604unsafe impl ExtendsImageFormatProperties2
35605 for FilterCubicImageViewImageFormatPropertiesEXTBuilder<'_>
35606{
35607}
35608unsafe impl ExtendsImageFormatProperties2 for FilterCubicImageViewImageFormatPropertiesEXT {}
35609impl<'a> ::std::ops::Deref for FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
35610 type Target = FilterCubicImageViewImageFormatPropertiesEXT;
35611 fn deref(&self) -> &Self::Target {
35612 &self.inner
35613 }
35614}
35615impl<'a> ::std::ops::DerefMut for FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
35616 fn deref_mut(&mut self) -> &mut Self::Target {
35617 &mut self.inner
35618 }
35619}
35620impl<'a> FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
35621 pub fn filter_cubic(mut self, filter_cubic: bool) -> Self {
35622 self.inner.filter_cubic = filter_cubic.into();
35623 self
35624 }
35625 pub fn filter_cubic_minmax(mut self, filter_cubic_minmax: bool) -> Self {
35626 self.inner.filter_cubic_minmax = filter_cubic_minmax.into();
35627 self
35628 }
35629 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35630 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35631 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35632 pub fn build(self) -> FilterCubicImageViewImageFormatPropertiesEXT {
35633 self.inner
35634 }
35635}
35636#[repr(C)]
35637#[cfg_attr(feature = "debug", derive(Debug))]
35638#[derive(Copy, Clone)]
35639#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImagelessFramebufferFeatures.html>"]
35640pub struct PhysicalDeviceImagelessFramebufferFeatures {
35641 pub s_type: StructureType,
35642 pub p_next: *mut c_void,
35643 pub imageless_framebuffer: Bool32,
35644}
35645impl ::std::default::Default for PhysicalDeviceImagelessFramebufferFeatures {
35646 fn default() -> Self {
35647 Self {
35648 s_type: StructureType::PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES,
35649 p_next: ::std::ptr::null_mut(),
35650 imageless_framebuffer: Bool32::default(),
35651 }
35652 }
35653}
35654impl PhysicalDeviceImagelessFramebufferFeatures {
35655 pub fn builder<'a>() -> PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
35656 PhysicalDeviceImagelessFramebufferFeaturesBuilder {
35657 inner: Self::default(),
35658 marker: ::std::marker::PhantomData,
35659 }
35660 }
35661}
35662#[repr(transparent)]
35663pub struct PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
35664 inner: PhysicalDeviceImagelessFramebufferFeatures,
35665 marker: ::std::marker::PhantomData<&'a ()>,
35666}
35667unsafe impl ExtendsPhysicalDeviceFeatures2
35668 for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'_>
35669{
35670}
35671unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImagelessFramebufferFeatures {}
35672unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'_> {}
35673unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImagelessFramebufferFeatures {}
35674impl<'a> ::std::ops::Deref for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
35675 type Target = PhysicalDeviceImagelessFramebufferFeatures;
35676 fn deref(&self) -> &Self::Target {
35677 &self.inner
35678 }
35679}
35680impl<'a> ::std::ops::DerefMut for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
35681 fn deref_mut(&mut self) -> &mut Self::Target {
35682 &mut self.inner
35683 }
35684}
35685impl<'a> PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
35686 pub fn imageless_framebuffer(mut self, imageless_framebuffer: bool) -> Self {
35687 self.inner.imageless_framebuffer = imageless_framebuffer.into();
35688 self
35689 }
35690 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35691 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35692 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35693 pub fn build(self) -> PhysicalDeviceImagelessFramebufferFeatures {
35694 self.inner
35695 }
35696}
35697#[repr(C)]
35698#[cfg_attr(feature = "debug", derive(Debug))]
35699#[derive(Copy, Clone)]
35700#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebufferAttachmentsCreateInfo.html>"]
35701pub struct FramebufferAttachmentsCreateInfo {
35702 pub s_type: StructureType,
35703 pub p_next: *const c_void,
35704 pub attachment_image_info_count: u32,
35705 pub p_attachment_image_infos: *const FramebufferAttachmentImageInfo,
35706}
35707impl ::std::default::Default for FramebufferAttachmentsCreateInfo {
35708 fn default() -> Self {
35709 Self {
35710 s_type: StructureType::FRAMEBUFFER_ATTACHMENTS_CREATE_INFO,
35711 p_next: ::std::ptr::null(),
35712 attachment_image_info_count: u32::default(),
35713 p_attachment_image_infos: ::std::ptr::null(),
35714 }
35715 }
35716}
35717impl FramebufferAttachmentsCreateInfo {
35718 pub fn builder<'a>() -> FramebufferAttachmentsCreateInfoBuilder<'a> {
35719 FramebufferAttachmentsCreateInfoBuilder {
35720 inner: Self::default(),
35721 marker: ::std::marker::PhantomData,
35722 }
35723 }
35724}
35725#[repr(transparent)]
35726pub struct FramebufferAttachmentsCreateInfoBuilder<'a> {
35727 inner: FramebufferAttachmentsCreateInfo,
35728 marker: ::std::marker::PhantomData<&'a ()>,
35729}
35730unsafe impl ExtendsFramebufferCreateInfo for FramebufferAttachmentsCreateInfoBuilder<'_> {}
35731unsafe impl ExtendsFramebufferCreateInfo for FramebufferAttachmentsCreateInfo {}
35732impl<'a> ::std::ops::Deref for FramebufferAttachmentsCreateInfoBuilder<'a> {
35733 type Target = FramebufferAttachmentsCreateInfo;
35734 fn deref(&self) -> &Self::Target {
35735 &self.inner
35736 }
35737}
35738impl<'a> ::std::ops::DerefMut for FramebufferAttachmentsCreateInfoBuilder<'a> {
35739 fn deref_mut(&mut self) -> &mut Self::Target {
35740 &mut self.inner
35741 }
35742}
35743impl<'a> FramebufferAttachmentsCreateInfoBuilder<'a> {
35744 pub fn attachment_image_infos(
35745 mut self,
35746 attachment_image_infos: &'a [FramebufferAttachmentImageInfo],
35747 ) -> Self {
35748 self.inner.attachment_image_info_count = attachment_image_infos.len() as _;
35749 self.inner.p_attachment_image_infos = attachment_image_infos.as_ptr();
35750 self
35751 }
35752 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35753 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35754 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35755 pub fn build(self) -> FramebufferAttachmentsCreateInfo {
35756 self.inner
35757 }
35758}
35759#[repr(C)]
35760#[cfg_attr(feature = "debug", derive(Debug))]
35761#[derive(Copy, Clone)]
35762#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebufferAttachmentImageInfo.html>"]
35763pub struct FramebufferAttachmentImageInfo {
35764 pub s_type: StructureType,
35765 pub p_next: *const c_void,
35766 pub flags: ImageCreateFlags,
35767 pub usage: ImageUsageFlags,
35768 pub width: u32,
35769 pub height: u32,
35770 pub layer_count: u32,
35771 pub view_format_count: u32,
35772 pub p_view_formats: *const Format,
35773}
35774impl ::std::default::Default for FramebufferAttachmentImageInfo {
35775 fn default() -> Self {
35776 Self {
35777 s_type: StructureType::FRAMEBUFFER_ATTACHMENT_IMAGE_INFO,
35778 p_next: ::std::ptr::null(),
35779 flags: ImageCreateFlags::default(),
35780 usage: ImageUsageFlags::default(),
35781 width: u32::default(),
35782 height: u32::default(),
35783 layer_count: u32::default(),
35784 view_format_count: u32::default(),
35785 p_view_formats: ::std::ptr::null(),
35786 }
35787 }
35788}
35789impl FramebufferAttachmentImageInfo {
35790 pub fn builder<'a>() -> FramebufferAttachmentImageInfoBuilder<'a> {
35791 FramebufferAttachmentImageInfoBuilder {
35792 inner: Self::default(),
35793 marker: ::std::marker::PhantomData,
35794 }
35795 }
35796}
35797#[repr(transparent)]
35798pub struct FramebufferAttachmentImageInfoBuilder<'a> {
35799 inner: FramebufferAttachmentImageInfo,
35800 marker: ::std::marker::PhantomData<&'a ()>,
35801}
35802impl<'a> ::std::ops::Deref for FramebufferAttachmentImageInfoBuilder<'a> {
35803 type Target = FramebufferAttachmentImageInfo;
35804 fn deref(&self) -> &Self::Target {
35805 &self.inner
35806 }
35807}
35808impl<'a> ::std::ops::DerefMut for FramebufferAttachmentImageInfoBuilder<'a> {
35809 fn deref_mut(&mut self) -> &mut Self::Target {
35810 &mut self.inner
35811 }
35812}
35813impl<'a> FramebufferAttachmentImageInfoBuilder<'a> {
35814 pub fn flags(mut self, flags: ImageCreateFlags) -> Self {
35815 self.inner.flags = flags;
35816 self
35817 }
35818 pub fn usage(mut self, usage: ImageUsageFlags) -> Self {
35819 self.inner.usage = usage;
35820 self
35821 }
35822 pub fn width(mut self, width: u32) -> Self {
35823 self.inner.width = width;
35824 self
35825 }
35826 pub fn height(mut self, height: u32) -> Self {
35827 self.inner.height = height;
35828 self
35829 }
35830 pub fn layer_count(mut self, layer_count: u32) -> Self {
35831 self.inner.layer_count = layer_count;
35832 self
35833 }
35834 pub fn view_formats(mut self, view_formats: &'a [Format]) -> Self {
35835 self.inner.view_format_count = view_formats.len() as _;
35836 self.inner.p_view_formats = view_formats.as_ptr();
35837 self
35838 }
35839 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35840 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35841 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35842 pub fn build(self) -> FramebufferAttachmentImageInfo {
35843 self.inner
35844 }
35845}
35846#[repr(C)]
35847#[cfg_attr(feature = "debug", derive(Debug))]
35848#[derive(Copy, Clone)]
35849#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassAttachmentBeginInfo.html>"]
35850pub struct RenderPassAttachmentBeginInfo {
35851 pub s_type: StructureType,
35852 pub p_next: *const c_void,
35853 pub attachment_count: u32,
35854 pub p_attachments: *const ImageView,
35855}
35856impl ::std::default::Default for RenderPassAttachmentBeginInfo {
35857 fn default() -> Self {
35858 Self {
35859 s_type: StructureType::RENDER_PASS_ATTACHMENT_BEGIN_INFO,
35860 p_next: ::std::ptr::null(),
35861 attachment_count: u32::default(),
35862 p_attachments: ::std::ptr::null(),
35863 }
35864 }
35865}
35866impl RenderPassAttachmentBeginInfo {
35867 pub fn builder<'a>() -> RenderPassAttachmentBeginInfoBuilder<'a> {
35868 RenderPassAttachmentBeginInfoBuilder {
35869 inner: Self::default(),
35870 marker: ::std::marker::PhantomData,
35871 }
35872 }
35873}
35874#[repr(transparent)]
35875pub struct RenderPassAttachmentBeginInfoBuilder<'a> {
35876 inner: RenderPassAttachmentBeginInfo,
35877 marker: ::std::marker::PhantomData<&'a ()>,
35878}
35879unsafe impl ExtendsRenderPassBeginInfo for RenderPassAttachmentBeginInfoBuilder<'_> {}
35880unsafe impl ExtendsRenderPassBeginInfo for RenderPassAttachmentBeginInfo {}
35881impl<'a> ::std::ops::Deref for RenderPassAttachmentBeginInfoBuilder<'a> {
35882 type Target = RenderPassAttachmentBeginInfo;
35883 fn deref(&self) -> &Self::Target {
35884 &self.inner
35885 }
35886}
35887impl<'a> ::std::ops::DerefMut for RenderPassAttachmentBeginInfoBuilder<'a> {
35888 fn deref_mut(&mut self) -> &mut Self::Target {
35889 &mut self.inner
35890 }
35891}
35892impl<'a> RenderPassAttachmentBeginInfoBuilder<'a> {
35893 pub fn attachments(mut self, attachments: &'a [ImageView]) -> Self {
35894 self.inner.attachment_count = attachments.len() as _;
35895 self.inner.p_attachments = attachments.as_ptr();
35896 self
35897 }
35898 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35899 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35900 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35901 pub fn build(self) -> RenderPassAttachmentBeginInfo {
35902 self.inner
35903 }
35904}
35905#[repr(C)]
35906#[cfg_attr(feature = "debug", derive(Debug))]
35907#[derive(Copy, Clone)]
35908#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTextureCompressionASTCHDRFeatures.html>"]
35909pub struct PhysicalDeviceTextureCompressionASTCHDRFeatures {
35910 pub s_type: StructureType,
35911 pub p_next: *mut c_void,
35912 pub texture_compression_astc_hdr: Bool32,
35913}
35914impl ::std::default::Default for PhysicalDeviceTextureCompressionASTCHDRFeatures {
35915 fn default() -> Self {
35916 Self {
35917 s_type: StructureType::PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES,
35918 p_next: ::std::ptr::null_mut(),
35919 texture_compression_astc_hdr: Bool32::default(),
35920 }
35921 }
35922}
35923impl PhysicalDeviceTextureCompressionASTCHDRFeatures {
35924 pub fn builder<'a>() -> PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> {
35925 PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder {
35926 inner: Self::default(),
35927 marker: ::std::marker::PhantomData,
35928 }
35929 }
35930}
35931#[repr(transparent)]
35932pub struct PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> {
35933 inner: PhysicalDeviceTextureCompressionASTCHDRFeatures,
35934 marker: ::std::marker::PhantomData<&'a ()>,
35935}
35936unsafe impl ExtendsPhysicalDeviceFeatures2
35937 for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'_>
35938{
35939}
35940unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTextureCompressionASTCHDRFeatures {}
35941unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'_> {}
35942unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTextureCompressionASTCHDRFeatures {}
35943impl<'a> ::std::ops::Deref for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> {
35944 type Target = PhysicalDeviceTextureCompressionASTCHDRFeatures;
35945 fn deref(&self) -> &Self::Target {
35946 &self.inner
35947 }
35948}
35949impl<'a> ::std::ops::DerefMut for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> {
35950 fn deref_mut(&mut self) -> &mut Self::Target {
35951 &mut self.inner
35952 }
35953}
35954impl<'a> PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> {
35955 pub fn texture_compression_astc_hdr(mut self, texture_compression_astc_hdr: bool) -> Self {
35956 self.inner.texture_compression_astc_hdr = texture_compression_astc_hdr.into();
35957 self
35958 }
35959 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35960 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35961 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35962 pub fn build(self) -> PhysicalDeviceTextureCompressionASTCHDRFeatures {
35963 self.inner
35964 }
35965}
35966#[repr(C)]
35967#[cfg_attr(feature = "debug", derive(Debug))]
35968#[derive(Copy, Clone)]
35969#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCooperativeMatrixFeaturesNV.html>"]
35970pub struct PhysicalDeviceCooperativeMatrixFeaturesNV {
35971 pub s_type: StructureType,
35972 pub p_next: *mut c_void,
35973 pub cooperative_matrix: Bool32,
35974 pub cooperative_matrix_robust_buffer_access: Bool32,
35975}
35976impl ::std::default::Default for PhysicalDeviceCooperativeMatrixFeaturesNV {
35977 fn default() -> Self {
35978 Self {
35979 s_type: StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV,
35980 p_next: ::std::ptr::null_mut(),
35981 cooperative_matrix: Bool32::default(),
35982 cooperative_matrix_robust_buffer_access: Bool32::default(),
35983 }
35984 }
35985}
35986impl PhysicalDeviceCooperativeMatrixFeaturesNV {
35987 pub fn builder<'a>() -> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
35988 PhysicalDeviceCooperativeMatrixFeaturesNVBuilder {
35989 inner: Self::default(),
35990 marker: ::std::marker::PhantomData,
35991 }
35992 }
35993}
35994#[repr(transparent)]
35995pub struct PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
35996 inner: PhysicalDeviceCooperativeMatrixFeaturesNV,
35997 marker: ::std::marker::PhantomData<&'a ()>,
35998}
35999unsafe impl ExtendsPhysicalDeviceFeatures2
36000 for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'_>
36001{
36002}
36003unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCooperativeMatrixFeaturesNV {}
36004unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'_> {}
36005unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCooperativeMatrixFeaturesNV {}
36006impl<'a> ::std::ops::Deref for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
36007 type Target = PhysicalDeviceCooperativeMatrixFeaturesNV;
36008 fn deref(&self) -> &Self::Target {
36009 &self.inner
36010 }
36011}
36012impl<'a> ::std::ops::DerefMut for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
36013 fn deref_mut(&mut self) -> &mut Self::Target {
36014 &mut self.inner
36015 }
36016}
36017impl<'a> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
36018 pub fn cooperative_matrix(mut self, cooperative_matrix: bool) -> Self {
36019 self.inner.cooperative_matrix = cooperative_matrix.into();
36020 self
36021 }
36022 pub fn cooperative_matrix_robust_buffer_access(
36023 mut self,
36024 cooperative_matrix_robust_buffer_access: bool,
36025 ) -> Self {
36026 self.inner.cooperative_matrix_robust_buffer_access =
36027 cooperative_matrix_robust_buffer_access.into();
36028 self
36029 }
36030 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36031 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36032 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36033 pub fn build(self) -> PhysicalDeviceCooperativeMatrixFeaturesNV {
36034 self.inner
36035 }
36036}
36037#[repr(C)]
36038#[cfg_attr(feature = "debug", derive(Debug))]
36039#[derive(Copy, Clone)]
36040#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCooperativeMatrixPropertiesNV.html>"]
36041pub struct PhysicalDeviceCooperativeMatrixPropertiesNV {
36042 pub s_type: StructureType,
36043 pub p_next: *mut c_void,
36044 pub cooperative_matrix_supported_stages: ShaderStageFlags,
36045}
36046impl ::std::default::Default for PhysicalDeviceCooperativeMatrixPropertiesNV {
36047 fn default() -> Self {
36048 Self {
36049 s_type: StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV,
36050 p_next: ::std::ptr::null_mut(),
36051 cooperative_matrix_supported_stages: ShaderStageFlags::default(),
36052 }
36053 }
36054}
36055impl PhysicalDeviceCooperativeMatrixPropertiesNV {
36056 pub fn builder<'a>() -> PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
36057 PhysicalDeviceCooperativeMatrixPropertiesNVBuilder {
36058 inner: Self::default(),
36059 marker: ::std::marker::PhantomData,
36060 }
36061 }
36062}
36063#[repr(transparent)]
36064pub struct PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
36065 inner: PhysicalDeviceCooperativeMatrixPropertiesNV,
36066 marker: ::std::marker::PhantomData<&'a ()>,
36067}
36068unsafe impl ExtendsPhysicalDeviceProperties2
36069 for PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'_>
36070{
36071}
36072unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCooperativeMatrixPropertiesNV {}
36073impl<'a> ::std::ops::Deref for PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
36074 type Target = PhysicalDeviceCooperativeMatrixPropertiesNV;
36075 fn deref(&self) -> &Self::Target {
36076 &self.inner
36077 }
36078}
36079impl<'a> ::std::ops::DerefMut for PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
36080 fn deref_mut(&mut self) -> &mut Self::Target {
36081 &mut self.inner
36082 }
36083}
36084impl<'a> PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
36085 pub fn cooperative_matrix_supported_stages(
36086 mut self,
36087 cooperative_matrix_supported_stages: ShaderStageFlags,
36088 ) -> Self {
36089 self.inner.cooperative_matrix_supported_stages = cooperative_matrix_supported_stages;
36090 self
36091 }
36092 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36093 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36094 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36095 pub fn build(self) -> PhysicalDeviceCooperativeMatrixPropertiesNV {
36096 self.inner
36097 }
36098}
36099#[repr(C)]
36100#[cfg_attr(feature = "debug", derive(Debug))]
36101#[derive(Copy, Clone)]
36102#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCooperativeMatrixPropertiesNV.html>"]
36103pub struct CooperativeMatrixPropertiesNV {
36104 pub s_type: StructureType,
36105 pub p_next: *mut c_void,
36106 pub m_size: u32,
36107 pub n_size: u32,
36108 pub k_size: u32,
36109 pub a_type: ComponentTypeNV,
36110 pub b_type: ComponentTypeNV,
36111 pub c_type: ComponentTypeNV,
36112 pub d_type: ComponentTypeNV,
36113 pub scope: ScopeNV,
36114}
36115impl ::std::default::Default for CooperativeMatrixPropertiesNV {
36116 fn default() -> Self {
36117 Self {
36118 s_type: StructureType::COOPERATIVE_MATRIX_PROPERTIES_NV,
36119 p_next: ::std::ptr::null_mut(),
36120 m_size: u32::default(),
36121 n_size: u32::default(),
36122 k_size: u32::default(),
36123 a_type: ComponentTypeNV::default(),
36124 b_type: ComponentTypeNV::default(),
36125 c_type: ComponentTypeNV::default(),
36126 d_type: ComponentTypeNV::default(),
36127 scope: ScopeNV::default(),
36128 }
36129 }
36130}
36131impl CooperativeMatrixPropertiesNV {
36132 pub fn builder<'a>() -> CooperativeMatrixPropertiesNVBuilder<'a> {
36133 CooperativeMatrixPropertiesNVBuilder {
36134 inner: Self::default(),
36135 marker: ::std::marker::PhantomData,
36136 }
36137 }
36138}
36139#[repr(transparent)]
36140pub struct CooperativeMatrixPropertiesNVBuilder<'a> {
36141 inner: CooperativeMatrixPropertiesNV,
36142 marker: ::std::marker::PhantomData<&'a ()>,
36143}
36144impl<'a> ::std::ops::Deref for CooperativeMatrixPropertiesNVBuilder<'a> {
36145 type Target = CooperativeMatrixPropertiesNV;
36146 fn deref(&self) -> &Self::Target {
36147 &self.inner
36148 }
36149}
36150impl<'a> ::std::ops::DerefMut for CooperativeMatrixPropertiesNVBuilder<'a> {
36151 fn deref_mut(&mut self) -> &mut Self::Target {
36152 &mut self.inner
36153 }
36154}
36155impl<'a> CooperativeMatrixPropertiesNVBuilder<'a> {
36156 pub fn m_size(mut self, m_size: u32) -> Self {
36157 self.inner.m_size = m_size;
36158 self
36159 }
36160 pub fn n_size(mut self, n_size: u32) -> Self {
36161 self.inner.n_size = n_size;
36162 self
36163 }
36164 pub fn k_size(mut self, k_size: u32) -> Self {
36165 self.inner.k_size = k_size;
36166 self
36167 }
36168 pub fn a_type(mut self, a_type: ComponentTypeNV) -> Self {
36169 self.inner.a_type = a_type;
36170 self
36171 }
36172 pub fn b_type(mut self, b_type: ComponentTypeNV) -> Self {
36173 self.inner.b_type = b_type;
36174 self
36175 }
36176 pub fn c_type(mut self, c_type: ComponentTypeNV) -> Self {
36177 self.inner.c_type = c_type;
36178 self
36179 }
36180 pub fn d_type(mut self, d_type: ComponentTypeNV) -> Self {
36181 self.inner.d_type = d_type;
36182 self
36183 }
36184 pub fn scope(mut self, scope: ScopeNV) -> Self {
36185 self.inner.scope = scope;
36186 self
36187 }
36188 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36189 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36190 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36191 pub fn build(self) -> CooperativeMatrixPropertiesNV {
36192 self.inner
36193 }
36194}
36195#[repr(C)]
36196#[cfg_attr(feature = "debug", derive(Debug))]
36197#[derive(Copy, Clone)]
36198#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceYcbcrImageArraysFeaturesEXT.html>"]
36199pub struct PhysicalDeviceYcbcrImageArraysFeaturesEXT {
36200 pub s_type: StructureType,
36201 pub p_next: *mut c_void,
36202 pub ycbcr_image_arrays: Bool32,
36203}
36204impl ::std::default::Default for PhysicalDeviceYcbcrImageArraysFeaturesEXT {
36205 fn default() -> Self {
36206 Self {
36207 s_type: StructureType::PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT,
36208 p_next: ::std::ptr::null_mut(),
36209 ycbcr_image_arrays: Bool32::default(),
36210 }
36211 }
36212}
36213impl PhysicalDeviceYcbcrImageArraysFeaturesEXT {
36214 pub fn builder<'a>() -> PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
36215 PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder {
36216 inner: Self::default(),
36217 marker: ::std::marker::PhantomData,
36218 }
36219 }
36220}
36221#[repr(transparent)]
36222pub struct PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
36223 inner: PhysicalDeviceYcbcrImageArraysFeaturesEXT,
36224 marker: ::std::marker::PhantomData<&'a ()>,
36225}
36226unsafe impl ExtendsPhysicalDeviceFeatures2
36227 for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'_>
36228{
36229}
36230unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceYcbcrImageArraysFeaturesEXT {}
36231unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'_> {}
36232unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcrImageArraysFeaturesEXT {}
36233impl<'a> ::std::ops::Deref for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
36234 type Target = PhysicalDeviceYcbcrImageArraysFeaturesEXT;
36235 fn deref(&self) -> &Self::Target {
36236 &self.inner
36237 }
36238}
36239impl<'a> ::std::ops::DerefMut for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
36240 fn deref_mut(&mut self) -> &mut Self::Target {
36241 &mut self.inner
36242 }
36243}
36244impl<'a> PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
36245 pub fn ycbcr_image_arrays(mut self, ycbcr_image_arrays: bool) -> Self {
36246 self.inner.ycbcr_image_arrays = ycbcr_image_arrays.into();
36247 self
36248 }
36249 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36250 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36251 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36252 pub fn build(self) -> PhysicalDeviceYcbcrImageArraysFeaturesEXT {
36253 self.inner
36254 }
36255}
36256#[repr(C)]
36257#[cfg_attr(feature = "debug", derive(Debug))]
36258#[derive(Copy, Clone)]
36259#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewHandleInfoNVX.html>"]
36260pub struct ImageViewHandleInfoNVX {
36261 pub s_type: StructureType,
36262 pub p_next: *const c_void,
36263 pub image_view: ImageView,
36264 pub descriptor_type: DescriptorType,
36265 pub sampler: Sampler,
36266}
36267impl ::std::default::Default for ImageViewHandleInfoNVX {
36268 fn default() -> Self {
36269 Self {
36270 s_type: StructureType::IMAGE_VIEW_HANDLE_INFO_NVX,
36271 p_next: ::std::ptr::null(),
36272 image_view: ImageView::default(),
36273 descriptor_type: DescriptorType::default(),
36274 sampler: Sampler::default(),
36275 }
36276 }
36277}
36278impl ImageViewHandleInfoNVX {
36279 pub fn builder<'a>() -> ImageViewHandleInfoNVXBuilder<'a> {
36280 ImageViewHandleInfoNVXBuilder {
36281 inner: Self::default(),
36282 marker: ::std::marker::PhantomData,
36283 }
36284 }
36285}
36286#[repr(transparent)]
36287pub struct ImageViewHandleInfoNVXBuilder<'a> {
36288 inner: ImageViewHandleInfoNVX,
36289 marker: ::std::marker::PhantomData<&'a ()>,
36290}
36291impl<'a> ::std::ops::Deref for ImageViewHandleInfoNVXBuilder<'a> {
36292 type Target = ImageViewHandleInfoNVX;
36293 fn deref(&self) -> &Self::Target {
36294 &self.inner
36295 }
36296}
36297impl<'a> ::std::ops::DerefMut for ImageViewHandleInfoNVXBuilder<'a> {
36298 fn deref_mut(&mut self) -> &mut Self::Target {
36299 &mut self.inner
36300 }
36301}
36302impl<'a> ImageViewHandleInfoNVXBuilder<'a> {
36303 pub fn image_view(mut self, image_view: ImageView) -> Self {
36304 self.inner.image_view = image_view;
36305 self
36306 }
36307 pub fn descriptor_type(mut self, descriptor_type: DescriptorType) -> Self {
36308 self.inner.descriptor_type = descriptor_type;
36309 self
36310 }
36311 pub fn sampler(mut self, sampler: Sampler) -> Self {
36312 self.inner.sampler = sampler;
36313 self
36314 }
36315 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36316 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36317 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36318 pub fn build(self) -> ImageViewHandleInfoNVX {
36319 self.inner
36320 }
36321}
36322#[repr(C)]
36323#[cfg_attr(feature = "debug", derive(Debug))]
36324#[derive(Copy, Clone)]
36325#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewAddressPropertiesNVX.html>"]
36326pub struct ImageViewAddressPropertiesNVX {
36327 pub s_type: StructureType,
36328 pub p_next: *mut c_void,
36329 pub device_address: DeviceAddress,
36330 pub size: DeviceSize,
36331}
36332impl ::std::default::Default for ImageViewAddressPropertiesNVX {
36333 fn default() -> Self {
36334 Self {
36335 s_type: StructureType::IMAGE_VIEW_ADDRESS_PROPERTIES_NVX,
36336 p_next: ::std::ptr::null_mut(),
36337 device_address: DeviceAddress::default(),
36338 size: DeviceSize::default(),
36339 }
36340 }
36341}
36342impl ImageViewAddressPropertiesNVX {
36343 pub fn builder<'a>() -> ImageViewAddressPropertiesNVXBuilder<'a> {
36344 ImageViewAddressPropertiesNVXBuilder {
36345 inner: Self::default(),
36346 marker: ::std::marker::PhantomData,
36347 }
36348 }
36349}
36350#[repr(transparent)]
36351pub struct ImageViewAddressPropertiesNVXBuilder<'a> {
36352 inner: ImageViewAddressPropertiesNVX,
36353 marker: ::std::marker::PhantomData<&'a ()>,
36354}
36355impl<'a> ::std::ops::Deref for ImageViewAddressPropertiesNVXBuilder<'a> {
36356 type Target = ImageViewAddressPropertiesNVX;
36357 fn deref(&self) -> &Self::Target {
36358 &self.inner
36359 }
36360}
36361impl<'a> ::std::ops::DerefMut for ImageViewAddressPropertiesNVXBuilder<'a> {
36362 fn deref_mut(&mut self) -> &mut Self::Target {
36363 &mut self.inner
36364 }
36365}
36366impl<'a> ImageViewAddressPropertiesNVXBuilder<'a> {
36367 pub fn device_address(mut self, device_address: DeviceAddress) -> Self {
36368 self.inner.device_address = device_address;
36369 self
36370 }
36371 pub fn size(mut self, size: DeviceSize) -> Self {
36372 self.inner.size = size;
36373 self
36374 }
36375 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36376 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36377 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36378 pub fn build(self) -> ImageViewAddressPropertiesNVX {
36379 self.inner
36380 }
36381}
36382#[repr(C)]
36383#[cfg_attr(feature = "debug", derive(Debug))]
36384#[derive(Copy, Clone)]
36385#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentFrameTokenGGP.html>"]
36386pub struct PresentFrameTokenGGP {
36387 pub s_type: StructureType,
36388 pub p_next: *const c_void,
36389 pub frame_token: GgpFrameToken,
36390}
36391impl ::std::default::Default for PresentFrameTokenGGP {
36392 fn default() -> Self {
36393 Self {
36394 s_type: StructureType::PRESENT_FRAME_TOKEN_GGP,
36395 p_next: ::std::ptr::null(),
36396 frame_token: GgpFrameToken::default(),
36397 }
36398 }
36399}
36400impl PresentFrameTokenGGP {
36401 pub fn builder<'a>() -> PresentFrameTokenGGPBuilder<'a> {
36402 PresentFrameTokenGGPBuilder {
36403 inner: Self::default(),
36404 marker: ::std::marker::PhantomData,
36405 }
36406 }
36407}
36408#[repr(transparent)]
36409pub struct PresentFrameTokenGGPBuilder<'a> {
36410 inner: PresentFrameTokenGGP,
36411 marker: ::std::marker::PhantomData<&'a ()>,
36412}
36413unsafe impl ExtendsPresentInfoKHR for PresentFrameTokenGGPBuilder<'_> {}
36414unsafe impl ExtendsPresentInfoKHR for PresentFrameTokenGGP {}
36415impl<'a> ::std::ops::Deref for PresentFrameTokenGGPBuilder<'a> {
36416 type Target = PresentFrameTokenGGP;
36417 fn deref(&self) -> &Self::Target {
36418 &self.inner
36419 }
36420}
36421impl<'a> ::std::ops::DerefMut for PresentFrameTokenGGPBuilder<'a> {
36422 fn deref_mut(&mut self) -> &mut Self::Target {
36423 &mut self.inner
36424 }
36425}
36426impl<'a> PresentFrameTokenGGPBuilder<'a> {
36427 pub fn frame_token(mut self, frame_token: GgpFrameToken) -> Self {
36428 self.inner.frame_token = frame_token;
36429 self
36430 }
36431 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36432 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36433 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36434 pub fn build(self) -> PresentFrameTokenGGP {
36435 self.inner
36436 }
36437}
36438#[repr(C)]
36439#[cfg_attr(feature = "debug", derive(Debug))]
36440#[derive(Copy, Clone, Default)]
36441#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCreationFeedback.html>"]
36442pub struct PipelineCreationFeedback {
36443 pub flags: PipelineCreationFeedbackFlags,
36444 pub duration: u64,
36445}
36446impl PipelineCreationFeedback {
36447 pub fn builder<'a>() -> PipelineCreationFeedbackBuilder<'a> {
36448 PipelineCreationFeedbackBuilder {
36449 inner: Self::default(),
36450 marker: ::std::marker::PhantomData,
36451 }
36452 }
36453}
36454#[repr(transparent)]
36455pub struct PipelineCreationFeedbackBuilder<'a> {
36456 inner: PipelineCreationFeedback,
36457 marker: ::std::marker::PhantomData<&'a ()>,
36458}
36459impl<'a> ::std::ops::Deref for PipelineCreationFeedbackBuilder<'a> {
36460 type Target = PipelineCreationFeedback;
36461 fn deref(&self) -> &Self::Target {
36462 &self.inner
36463 }
36464}
36465impl<'a> ::std::ops::DerefMut for PipelineCreationFeedbackBuilder<'a> {
36466 fn deref_mut(&mut self) -> &mut Self::Target {
36467 &mut self.inner
36468 }
36469}
36470impl<'a> PipelineCreationFeedbackBuilder<'a> {
36471 pub fn flags(mut self, flags: PipelineCreationFeedbackFlags) -> Self {
36472 self.inner.flags = flags;
36473 self
36474 }
36475 pub fn duration(mut self, duration: u64) -> Self {
36476 self.inner.duration = duration;
36477 self
36478 }
36479 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36480 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36481 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36482 pub fn build(self) -> PipelineCreationFeedback {
36483 self.inner
36484 }
36485}
36486#[repr(C)]
36487#[cfg_attr(feature = "debug", derive(Debug))]
36488#[derive(Copy, Clone)]
36489#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCreationFeedbackCreateInfo.html>"]
36490pub struct PipelineCreationFeedbackCreateInfo {
36491 pub s_type: StructureType,
36492 pub p_next: *const c_void,
36493 pub p_pipeline_creation_feedback: *mut PipelineCreationFeedback,
36494 pub pipeline_stage_creation_feedback_count: u32,
36495 pub p_pipeline_stage_creation_feedbacks: *mut PipelineCreationFeedback,
36496}
36497impl ::std::default::Default for PipelineCreationFeedbackCreateInfo {
36498 fn default() -> Self {
36499 Self {
36500 s_type: StructureType::PIPELINE_CREATION_FEEDBACK_CREATE_INFO,
36501 p_next: ::std::ptr::null(),
36502 p_pipeline_creation_feedback: ::std::ptr::null_mut(),
36503 pipeline_stage_creation_feedback_count: u32::default(),
36504 p_pipeline_stage_creation_feedbacks: ::std::ptr::null_mut(),
36505 }
36506 }
36507}
36508impl PipelineCreationFeedbackCreateInfo {
36509 pub fn builder<'a>() -> PipelineCreationFeedbackCreateInfoBuilder<'a> {
36510 PipelineCreationFeedbackCreateInfoBuilder {
36511 inner: Self::default(),
36512 marker: ::std::marker::PhantomData,
36513 }
36514 }
36515}
36516#[repr(transparent)]
36517pub struct PipelineCreationFeedbackCreateInfoBuilder<'a> {
36518 inner: PipelineCreationFeedbackCreateInfo,
36519 marker: ::std::marker::PhantomData<&'a ()>,
36520}
36521unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCreationFeedbackCreateInfoBuilder<'_> {}
36522unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCreationFeedbackCreateInfo {}
36523unsafe impl ExtendsComputePipelineCreateInfo for PipelineCreationFeedbackCreateInfoBuilder<'_> {}
36524unsafe impl ExtendsComputePipelineCreateInfo for PipelineCreationFeedbackCreateInfo {}
36525unsafe impl ExtendsRayTracingPipelineCreateInfoNV
36526 for PipelineCreationFeedbackCreateInfoBuilder<'_>
36527{
36528}
36529unsafe impl ExtendsRayTracingPipelineCreateInfoNV for PipelineCreationFeedbackCreateInfo {}
36530unsafe impl ExtendsRayTracingPipelineCreateInfoKHR
36531 for PipelineCreationFeedbackCreateInfoBuilder<'_>
36532{
36533}
36534unsafe impl ExtendsRayTracingPipelineCreateInfoKHR for PipelineCreationFeedbackCreateInfo {}
36535impl<'a> ::std::ops::Deref for PipelineCreationFeedbackCreateInfoBuilder<'a> {
36536 type Target = PipelineCreationFeedbackCreateInfo;
36537 fn deref(&self) -> &Self::Target {
36538 &self.inner
36539 }
36540}
36541impl<'a> ::std::ops::DerefMut for PipelineCreationFeedbackCreateInfoBuilder<'a> {
36542 fn deref_mut(&mut self) -> &mut Self::Target {
36543 &mut self.inner
36544 }
36545}
36546impl<'a> PipelineCreationFeedbackCreateInfoBuilder<'a> {
36547 pub fn pipeline_creation_feedback(
36548 mut self,
36549 pipeline_creation_feedback: &'a mut PipelineCreationFeedback,
36550 ) -> Self {
36551 self.inner.p_pipeline_creation_feedback = pipeline_creation_feedback;
36552 self
36553 }
36554 pub fn pipeline_stage_creation_feedbacks(
36555 mut self,
36556 pipeline_stage_creation_feedbacks: &'a mut [PipelineCreationFeedback],
36557 ) -> Self {
36558 self.inner.pipeline_stage_creation_feedback_count =
36559 pipeline_stage_creation_feedbacks.len() as _;
36560 self.inner.p_pipeline_stage_creation_feedbacks =
36561 pipeline_stage_creation_feedbacks.as_mut_ptr();
36562 self
36563 }
36564 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36565 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36566 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36567 pub fn build(self) -> PipelineCreationFeedbackCreateInfo {
36568 self.inner
36569 }
36570}
36571#[repr(C)]
36572#[cfg_attr(feature = "debug", derive(Debug))]
36573#[derive(Copy, Clone)]
36574#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceFullScreenExclusiveInfoEXT.html>"]
36575pub struct SurfaceFullScreenExclusiveInfoEXT {
36576 pub s_type: StructureType,
36577 pub p_next: *mut c_void,
36578 pub full_screen_exclusive: FullScreenExclusiveEXT,
36579}
36580impl ::std::default::Default for SurfaceFullScreenExclusiveInfoEXT {
36581 fn default() -> Self {
36582 Self {
36583 s_type: StructureType::SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT,
36584 p_next: ::std::ptr::null_mut(),
36585 full_screen_exclusive: FullScreenExclusiveEXT::default(),
36586 }
36587 }
36588}
36589impl SurfaceFullScreenExclusiveInfoEXT {
36590 pub fn builder<'a>() -> SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
36591 SurfaceFullScreenExclusiveInfoEXTBuilder {
36592 inner: Self::default(),
36593 marker: ::std::marker::PhantomData,
36594 }
36595 }
36596}
36597#[repr(transparent)]
36598pub struct SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
36599 inner: SurfaceFullScreenExclusiveInfoEXT,
36600 marker: ::std::marker::PhantomData<&'a ()>,
36601}
36602unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfaceFullScreenExclusiveInfoEXTBuilder<'_> {}
36603unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfaceFullScreenExclusiveInfoEXT {}
36604unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveInfoEXTBuilder<'_> {}
36605unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveInfoEXT {}
36606impl<'a> ::std::ops::Deref for SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
36607 type Target = SurfaceFullScreenExclusiveInfoEXT;
36608 fn deref(&self) -> &Self::Target {
36609 &self.inner
36610 }
36611}
36612impl<'a> ::std::ops::DerefMut for SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
36613 fn deref_mut(&mut self) -> &mut Self::Target {
36614 &mut self.inner
36615 }
36616}
36617impl<'a> SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
36618 pub fn full_screen_exclusive(mut self, full_screen_exclusive: FullScreenExclusiveEXT) -> Self {
36619 self.inner.full_screen_exclusive = full_screen_exclusive;
36620 self
36621 }
36622 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36623 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36624 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36625 pub fn build(self) -> SurfaceFullScreenExclusiveInfoEXT {
36626 self.inner
36627 }
36628}
36629#[repr(C)]
36630#[cfg_attr(feature = "debug", derive(Debug))]
36631#[derive(Copy, Clone)]
36632#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceFullScreenExclusiveWin32InfoEXT.html>"]
36633pub struct SurfaceFullScreenExclusiveWin32InfoEXT {
36634 pub s_type: StructureType,
36635 pub p_next: *const c_void,
36636 pub hmonitor: HMONITOR,
36637}
36638impl ::std::default::Default for SurfaceFullScreenExclusiveWin32InfoEXT {
36639 fn default() -> Self {
36640 Self {
36641 s_type: StructureType::SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT,
36642 p_next: ::std::ptr::null(),
36643 hmonitor: unsafe { ::std::mem::zeroed() },
36644 }
36645 }
36646}
36647impl SurfaceFullScreenExclusiveWin32InfoEXT {
36648 pub fn builder<'a>() -> SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
36649 SurfaceFullScreenExclusiveWin32InfoEXTBuilder {
36650 inner: Self::default(),
36651 marker: ::std::marker::PhantomData,
36652 }
36653 }
36654}
36655#[repr(transparent)]
36656pub struct SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
36657 inner: SurfaceFullScreenExclusiveWin32InfoEXT,
36658 marker: ::std::marker::PhantomData<&'a ()>,
36659}
36660unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR
36661 for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'_>
36662{
36663}
36664unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfaceFullScreenExclusiveWin32InfoEXT {}
36665unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'_> {}
36666unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveWin32InfoEXT {}
36667impl<'a> ::std::ops::Deref for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
36668 type Target = SurfaceFullScreenExclusiveWin32InfoEXT;
36669 fn deref(&self) -> &Self::Target {
36670 &self.inner
36671 }
36672}
36673impl<'a> ::std::ops::DerefMut for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
36674 fn deref_mut(&mut self) -> &mut Self::Target {
36675 &mut self.inner
36676 }
36677}
36678impl<'a> SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
36679 pub fn hmonitor(mut self, hmonitor: HMONITOR) -> Self {
36680 self.inner.hmonitor = hmonitor;
36681 self
36682 }
36683 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36684 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36685 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36686 pub fn build(self) -> SurfaceFullScreenExclusiveWin32InfoEXT {
36687 self.inner
36688 }
36689}
36690#[repr(C)]
36691#[cfg_attr(feature = "debug", derive(Debug))]
36692#[derive(Copy, Clone)]
36693#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceCapabilitiesFullScreenExclusiveEXT.html>"]
36694pub struct SurfaceCapabilitiesFullScreenExclusiveEXT {
36695 pub s_type: StructureType,
36696 pub p_next: *mut c_void,
36697 pub full_screen_exclusive_supported: Bool32,
36698}
36699impl ::std::default::Default for SurfaceCapabilitiesFullScreenExclusiveEXT {
36700 fn default() -> Self {
36701 Self {
36702 s_type: StructureType::SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT,
36703 p_next: ::std::ptr::null_mut(),
36704 full_screen_exclusive_supported: Bool32::default(),
36705 }
36706 }
36707}
36708impl SurfaceCapabilitiesFullScreenExclusiveEXT {
36709 pub fn builder<'a>() -> SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
36710 SurfaceCapabilitiesFullScreenExclusiveEXTBuilder {
36711 inner: Self::default(),
36712 marker: ::std::marker::PhantomData,
36713 }
36714 }
36715}
36716#[repr(transparent)]
36717pub struct SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
36718 inner: SurfaceCapabilitiesFullScreenExclusiveEXT,
36719 marker: ::std::marker::PhantomData<&'a ()>,
36720}
36721unsafe impl ExtendsSurfaceCapabilities2KHR
36722 for SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'_>
36723{
36724}
36725unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceCapabilitiesFullScreenExclusiveEXT {}
36726impl<'a> ::std::ops::Deref for SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
36727 type Target = SurfaceCapabilitiesFullScreenExclusiveEXT;
36728 fn deref(&self) -> &Self::Target {
36729 &self.inner
36730 }
36731}
36732impl<'a> ::std::ops::DerefMut for SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
36733 fn deref_mut(&mut self) -> &mut Self::Target {
36734 &mut self.inner
36735 }
36736}
36737impl<'a> SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
36738 pub fn full_screen_exclusive_supported(
36739 mut self,
36740 full_screen_exclusive_supported: bool,
36741 ) -> Self {
36742 self.inner.full_screen_exclusive_supported = full_screen_exclusive_supported.into();
36743 self
36744 }
36745 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36746 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36747 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36748 pub fn build(self) -> SurfaceCapabilitiesFullScreenExclusiveEXT {
36749 self.inner
36750 }
36751}
36752#[repr(C)]
36753#[cfg_attr(feature = "debug", derive(Debug))]
36754#[derive(Copy, Clone)]
36755#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePerformanceQueryFeaturesKHR.html>"]
36756pub struct PhysicalDevicePerformanceQueryFeaturesKHR {
36757 pub s_type: StructureType,
36758 pub p_next: *mut c_void,
36759 pub performance_counter_query_pools: Bool32,
36760 pub performance_counter_multiple_query_pools: Bool32,
36761}
36762impl ::std::default::Default for PhysicalDevicePerformanceQueryFeaturesKHR {
36763 fn default() -> Self {
36764 Self {
36765 s_type: StructureType::PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR,
36766 p_next: ::std::ptr::null_mut(),
36767 performance_counter_query_pools: Bool32::default(),
36768 performance_counter_multiple_query_pools: Bool32::default(),
36769 }
36770 }
36771}
36772impl PhysicalDevicePerformanceQueryFeaturesKHR {
36773 pub fn builder<'a>() -> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
36774 PhysicalDevicePerformanceQueryFeaturesKHRBuilder {
36775 inner: Self::default(),
36776 marker: ::std::marker::PhantomData,
36777 }
36778 }
36779}
36780#[repr(transparent)]
36781pub struct PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
36782 inner: PhysicalDevicePerformanceQueryFeaturesKHR,
36783 marker: ::std::marker::PhantomData<&'a ()>,
36784}
36785unsafe impl ExtendsPhysicalDeviceFeatures2
36786 for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'_>
36787{
36788}
36789unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePerformanceQueryFeaturesKHR {}
36790unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'_> {}
36791unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePerformanceQueryFeaturesKHR {}
36792impl<'a> ::std::ops::Deref for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
36793 type Target = PhysicalDevicePerformanceQueryFeaturesKHR;
36794 fn deref(&self) -> &Self::Target {
36795 &self.inner
36796 }
36797}
36798impl<'a> ::std::ops::DerefMut for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
36799 fn deref_mut(&mut self) -> &mut Self::Target {
36800 &mut self.inner
36801 }
36802}
36803impl<'a> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
36804 pub fn performance_counter_query_pools(
36805 mut self,
36806 performance_counter_query_pools: bool,
36807 ) -> Self {
36808 self.inner.performance_counter_query_pools = performance_counter_query_pools.into();
36809 self
36810 }
36811 pub fn performance_counter_multiple_query_pools(
36812 mut self,
36813 performance_counter_multiple_query_pools: bool,
36814 ) -> Self {
36815 self.inner.performance_counter_multiple_query_pools =
36816 performance_counter_multiple_query_pools.into();
36817 self
36818 }
36819 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36820 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36821 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36822 pub fn build(self) -> PhysicalDevicePerformanceQueryFeaturesKHR {
36823 self.inner
36824 }
36825}
36826#[repr(C)]
36827#[cfg_attr(feature = "debug", derive(Debug))]
36828#[derive(Copy, Clone)]
36829#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePerformanceQueryPropertiesKHR.html>"]
36830pub struct PhysicalDevicePerformanceQueryPropertiesKHR {
36831 pub s_type: StructureType,
36832 pub p_next: *mut c_void,
36833 pub allow_command_buffer_query_copies: Bool32,
36834}
36835impl ::std::default::Default for PhysicalDevicePerformanceQueryPropertiesKHR {
36836 fn default() -> Self {
36837 Self {
36838 s_type: StructureType::PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR,
36839 p_next: ::std::ptr::null_mut(),
36840 allow_command_buffer_query_copies: Bool32::default(),
36841 }
36842 }
36843}
36844impl PhysicalDevicePerformanceQueryPropertiesKHR {
36845 pub fn builder<'a>() -> PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
36846 PhysicalDevicePerformanceQueryPropertiesKHRBuilder {
36847 inner: Self::default(),
36848 marker: ::std::marker::PhantomData,
36849 }
36850 }
36851}
36852#[repr(transparent)]
36853pub struct PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
36854 inner: PhysicalDevicePerformanceQueryPropertiesKHR,
36855 marker: ::std::marker::PhantomData<&'a ()>,
36856}
36857unsafe impl ExtendsPhysicalDeviceProperties2
36858 for PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'_>
36859{
36860}
36861unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePerformanceQueryPropertiesKHR {}
36862impl<'a> ::std::ops::Deref for PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
36863 type Target = PhysicalDevicePerformanceQueryPropertiesKHR;
36864 fn deref(&self) -> &Self::Target {
36865 &self.inner
36866 }
36867}
36868impl<'a> ::std::ops::DerefMut for PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
36869 fn deref_mut(&mut self) -> &mut Self::Target {
36870 &mut self.inner
36871 }
36872}
36873impl<'a> PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
36874 pub fn allow_command_buffer_query_copies(
36875 mut self,
36876 allow_command_buffer_query_copies: bool,
36877 ) -> Self {
36878 self.inner.allow_command_buffer_query_copies = allow_command_buffer_query_copies.into();
36879 self
36880 }
36881 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36882 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36883 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36884 pub fn build(self) -> PhysicalDevicePerformanceQueryPropertiesKHR {
36885 self.inner
36886 }
36887}
36888#[repr(C)]
36889#[cfg_attr(feature = "debug", derive(Debug))]
36890#[derive(Copy, Clone)]
36891#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceCounterKHR.html>"]
36892pub struct PerformanceCounterKHR {
36893 pub s_type: StructureType,
36894 pub p_next: *mut c_void,
36895 pub unit: PerformanceCounterUnitKHR,
36896 pub scope: PerformanceCounterScopeKHR,
36897 pub storage: PerformanceCounterStorageKHR,
36898 pub uuid: [u8; UUID_SIZE],
36899}
36900impl ::std::default::Default for PerformanceCounterKHR {
36901 fn default() -> Self {
36902 Self {
36903 s_type: StructureType::PERFORMANCE_COUNTER_KHR,
36904 p_next: ::std::ptr::null_mut(),
36905 unit: PerformanceCounterUnitKHR::default(),
36906 scope: PerformanceCounterScopeKHR::default(),
36907 storage: PerformanceCounterStorageKHR::default(),
36908 uuid: unsafe { ::std::mem::zeroed() },
36909 }
36910 }
36911}
36912impl PerformanceCounterKHR {
36913 pub fn builder<'a>() -> PerformanceCounterKHRBuilder<'a> {
36914 PerformanceCounterKHRBuilder {
36915 inner: Self::default(),
36916 marker: ::std::marker::PhantomData,
36917 }
36918 }
36919}
36920#[repr(transparent)]
36921pub struct PerformanceCounterKHRBuilder<'a> {
36922 inner: PerformanceCounterKHR,
36923 marker: ::std::marker::PhantomData<&'a ()>,
36924}
36925impl<'a> ::std::ops::Deref for PerformanceCounterKHRBuilder<'a> {
36926 type Target = PerformanceCounterKHR;
36927 fn deref(&self) -> &Self::Target {
36928 &self.inner
36929 }
36930}
36931impl<'a> ::std::ops::DerefMut for PerformanceCounterKHRBuilder<'a> {
36932 fn deref_mut(&mut self) -> &mut Self::Target {
36933 &mut self.inner
36934 }
36935}
36936impl<'a> PerformanceCounterKHRBuilder<'a> {
36937 pub fn unit(mut self, unit: PerformanceCounterUnitKHR) -> Self {
36938 self.inner.unit = unit;
36939 self
36940 }
36941 pub fn scope(mut self, scope: PerformanceCounterScopeKHR) -> Self {
36942 self.inner.scope = scope;
36943 self
36944 }
36945 pub fn storage(mut self, storage: PerformanceCounterStorageKHR) -> Self {
36946 self.inner.storage = storage;
36947 self
36948 }
36949 pub fn uuid(mut self, uuid: [u8; UUID_SIZE]) -> Self {
36950 self.inner.uuid = uuid;
36951 self
36952 }
36953 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36954 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36955 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36956 pub fn build(self) -> PerformanceCounterKHR {
36957 self.inner
36958 }
36959}
36960#[repr(C)]
36961#[derive(Copy, Clone)]
36962#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceCounterDescriptionKHR.html>"]
36963pub struct PerformanceCounterDescriptionKHR {
36964 pub s_type: StructureType,
36965 pub p_next: *mut c_void,
36966 pub flags: PerformanceCounterDescriptionFlagsKHR,
36967 pub name: [c_char; MAX_DESCRIPTION_SIZE],
36968 pub category: [c_char; MAX_DESCRIPTION_SIZE],
36969 pub description: [c_char; MAX_DESCRIPTION_SIZE],
36970}
36971#[cfg(feature = "debug")]
36972impl fmt::Debug for PerformanceCounterDescriptionKHR {
36973 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
36974 fmt.debug_struct("PerformanceCounterDescriptionKHR")
36975 .field("s_type", &self.s_type)
36976 .field("p_next", &self.p_next)
36977 .field("flags", &self.flags)
36978 .field("name", &unsafe {
36979 ::std::ffi::CStr::from_ptr(self.name.as_ptr())
36980 })
36981 .field("category", &unsafe {
36982 ::std::ffi::CStr::from_ptr(self.category.as_ptr())
36983 })
36984 .field("description", &unsafe {
36985 ::std::ffi::CStr::from_ptr(self.description.as_ptr())
36986 })
36987 .finish()
36988 }
36989}
36990impl ::std::default::Default for PerformanceCounterDescriptionKHR {
36991 fn default() -> Self {
36992 Self {
36993 s_type: StructureType::PERFORMANCE_COUNTER_DESCRIPTION_KHR,
36994 p_next: ::std::ptr::null_mut(),
36995 flags: PerformanceCounterDescriptionFlagsKHR::default(),
36996 name: unsafe { ::std::mem::zeroed() },
36997 category: unsafe { ::std::mem::zeroed() },
36998 description: unsafe { ::std::mem::zeroed() },
36999 }
37000 }
37001}
37002impl PerformanceCounterDescriptionKHR {
37003 pub fn builder<'a>() -> PerformanceCounterDescriptionKHRBuilder<'a> {
37004 PerformanceCounterDescriptionKHRBuilder {
37005 inner: Self::default(),
37006 marker: ::std::marker::PhantomData,
37007 }
37008 }
37009}
37010#[repr(transparent)]
37011pub struct PerformanceCounterDescriptionKHRBuilder<'a> {
37012 inner: PerformanceCounterDescriptionKHR,
37013 marker: ::std::marker::PhantomData<&'a ()>,
37014}
37015impl<'a> ::std::ops::Deref for PerformanceCounterDescriptionKHRBuilder<'a> {
37016 type Target = PerformanceCounterDescriptionKHR;
37017 fn deref(&self) -> &Self::Target {
37018 &self.inner
37019 }
37020}
37021impl<'a> ::std::ops::DerefMut for PerformanceCounterDescriptionKHRBuilder<'a> {
37022 fn deref_mut(&mut self) -> &mut Self::Target {
37023 &mut self.inner
37024 }
37025}
37026impl<'a> PerformanceCounterDescriptionKHRBuilder<'a> {
37027 pub fn flags(mut self, flags: PerformanceCounterDescriptionFlagsKHR) -> Self {
37028 self.inner.flags = flags;
37029 self
37030 }
37031 pub fn name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
37032 self.inner.name = name;
37033 self
37034 }
37035 pub fn category(mut self, category: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
37036 self.inner.category = category;
37037 self
37038 }
37039 pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
37040 self.inner.description = description;
37041 self
37042 }
37043 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37044 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37045 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37046 pub fn build(self) -> PerformanceCounterDescriptionKHR {
37047 self.inner
37048 }
37049}
37050#[repr(C)]
37051#[cfg_attr(feature = "debug", derive(Debug))]
37052#[derive(Copy, Clone)]
37053#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPoolPerformanceCreateInfoKHR.html>"]
37054pub struct QueryPoolPerformanceCreateInfoKHR {
37055 pub s_type: StructureType,
37056 pub p_next: *const c_void,
37057 pub queue_family_index: u32,
37058 pub counter_index_count: u32,
37059 pub p_counter_indices: *const u32,
37060}
37061impl ::std::default::Default for QueryPoolPerformanceCreateInfoKHR {
37062 fn default() -> Self {
37063 Self {
37064 s_type: StructureType::QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR,
37065 p_next: ::std::ptr::null(),
37066 queue_family_index: u32::default(),
37067 counter_index_count: u32::default(),
37068 p_counter_indices: ::std::ptr::null(),
37069 }
37070 }
37071}
37072impl QueryPoolPerformanceCreateInfoKHR {
37073 pub fn builder<'a>() -> QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
37074 QueryPoolPerformanceCreateInfoKHRBuilder {
37075 inner: Self::default(),
37076 marker: ::std::marker::PhantomData,
37077 }
37078 }
37079}
37080#[repr(transparent)]
37081pub struct QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
37082 inner: QueryPoolPerformanceCreateInfoKHR,
37083 marker: ::std::marker::PhantomData<&'a ()>,
37084}
37085unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceCreateInfoKHRBuilder<'_> {}
37086unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceCreateInfoKHR {}
37087impl<'a> ::std::ops::Deref for QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
37088 type Target = QueryPoolPerformanceCreateInfoKHR;
37089 fn deref(&self) -> &Self::Target {
37090 &self.inner
37091 }
37092}
37093impl<'a> ::std::ops::DerefMut for QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
37094 fn deref_mut(&mut self) -> &mut Self::Target {
37095 &mut self.inner
37096 }
37097}
37098impl<'a> QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
37099 pub fn queue_family_index(mut self, queue_family_index: u32) -> Self {
37100 self.inner.queue_family_index = queue_family_index;
37101 self
37102 }
37103 pub fn counter_indices(mut self, counter_indices: &'a [u32]) -> Self {
37104 self.inner.counter_index_count = counter_indices.len() as _;
37105 self.inner.p_counter_indices = counter_indices.as_ptr();
37106 self
37107 }
37108 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37109 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37110 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37111 pub fn build(self) -> QueryPoolPerformanceCreateInfoKHR {
37112 self.inner
37113 }
37114}
37115#[repr(C)]
37116#[derive(Copy, Clone)]
37117#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceCounterResultKHR.html>"]
37118pub union PerformanceCounterResultKHR {
37119 pub int32: i32,
37120 pub int64: i64,
37121 pub uint32: u32,
37122 pub uint64: u64,
37123 pub float32: f32,
37124 pub float64: f64,
37125}
37126impl ::std::default::Default for PerformanceCounterResultKHR {
37127 fn default() -> Self {
37128 unsafe { ::std::mem::zeroed() }
37129 }
37130}
37131#[repr(C)]
37132#[cfg_attr(feature = "debug", derive(Debug))]
37133#[derive(Copy, Clone)]
37134#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAcquireProfilingLockInfoKHR.html>"]
37135pub struct AcquireProfilingLockInfoKHR {
37136 pub s_type: StructureType,
37137 pub p_next: *const c_void,
37138 pub flags: AcquireProfilingLockFlagsKHR,
37139 pub timeout: u64,
37140}
37141impl ::std::default::Default for AcquireProfilingLockInfoKHR {
37142 fn default() -> Self {
37143 Self {
37144 s_type: StructureType::ACQUIRE_PROFILING_LOCK_INFO_KHR,
37145 p_next: ::std::ptr::null(),
37146 flags: AcquireProfilingLockFlagsKHR::default(),
37147 timeout: u64::default(),
37148 }
37149 }
37150}
37151impl AcquireProfilingLockInfoKHR {
37152 pub fn builder<'a>() -> AcquireProfilingLockInfoKHRBuilder<'a> {
37153 AcquireProfilingLockInfoKHRBuilder {
37154 inner: Self::default(),
37155 marker: ::std::marker::PhantomData,
37156 }
37157 }
37158}
37159#[repr(transparent)]
37160pub struct AcquireProfilingLockInfoKHRBuilder<'a> {
37161 inner: AcquireProfilingLockInfoKHR,
37162 marker: ::std::marker::PhantomData<&'a ()>,
37163}
37164impl<'a> ::std::ops::Deref for AcquireProfilingLockInfoKHRBuilder<'a> {
37165 type Target = AcquireProfilingLockInfoKHR;
37166 fn deref(&self) -> &Self::Target {
37167 &self.inner
37168 }
37169}
37170impl<'a> ::std::ops::DerefMut for AcquireProfilingLockInfoKHRBuilder<'a> {
37171 fn deref_mut(&mut self) -> &mut Self::Target {
37172 &mut self.inner
37173 }
37174}
37175impl<'a> AcquireProfilingLockInfoKHRBuilder<'a> {
37176 pub fn flags(mut self, flags: AcquireProfilingLockFlagsKHR) -> Self {
37177 self.inner.flags = flags;
37178 self
37179 }
37180 pub fn timeout(mut self, timeout: u64) -> Self {
37181 self.inner.timeout = timeout;
37182 self
37183 }
37184 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37185 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37186 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37187 pub fn build(self) -> AcquireProfilingLockInfoKHR {
37188 self.inner
37189 }
37190}
37191#[repr(C)]
37192#[cfg_attr(feature = "debug", derive(Debug))]
37193#[derive(Copy, Clone)]
37194#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceQuerySubmitInfoKHR.html>"]
37195pub struct PerformanceQuerySubmitInfoKHR {
37196 pub s_type: StructureType,
37197 pub p_next: *const c_void,
37198 pub counter_pass_index: u32,
37199}
37200impl ::std::default::Default for PerformanceQuerySubmitInfoKHR {
37201 fn default() -> Self {
37202 Self {
37203 s_type: StructureType::PERFORMANCE_QUERY_SUBMIT_INFO_KHR,
37204 p_next: ::std::ptr::null(),
37205 counter_pass_index: u32::default(),
37206 }
37207 }
37208}
37209impl PerformanceQuerySubmitInfoKHR {
37210 pub fn builder<'a>() -> PerformanceQuerySubmitInfoKHRBuilder<'a> {
37211 PerformanceQuerySubmitInfoKHRBuilder {
37212 inner: Self::default(),
37213 marker: ::std::marker::PhantomData,
37214 }
37215 }
37216}
37217#[repr(transparent)]
37218pub struct PerformanceQuerySubmitInfoKHRBuilder<'a> {
37219 inner: PerformanceQuerySubmitInfoKHR,
37220 marker: ::std::marker::PhantomData<&'a ()>,
37221}
37222unsafe impl ExtendsSubmitInfo for PerformanceQuerySubmitInfoKHRBuilder<'_> {}
37223unsafe impl ExtendsSubmitInfo for PerformanceQuerySubmitInfoKHR {}
37224unsafe impl ExtendsSubmitInfo2 for PerformanceQuerySubmitInfoKHRBuilder<'_> {}
37225unsafe impl ExtendsSubmitInfo2 for PerformanceQuerySubmitInfoKHR {}
37226impl<'a> ::std::ops::Deref for PerformanceQuerySubmitInfoKHRBuilder<'a> {
37227 type Target = PerformanceQuerySubmitInfoKHR;
37228 fn deref(&self) -> &Self::Target {
37229 &self.inner
37230 }
37231}
37232impl<'a> ::std::ops::DerefMut for PerformanceQuerySubmitInfoKHRBuilder<'a> {
37233 fn deref_mut(&mut self) -> &mut Self::Target {
37234 &mut self.inner
37235 }
37236}
37237impl<'a> PerformanceQuerySubmitInfoKHRBuilder<'a> {
37238 pub fn counter_pass_index(mut self, counter_pass_index: u32) -> Self {
37239 self.inner.counter_pass_index = counter_pass_index;
37240 self
37241 }
37242 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37243 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37244 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37245 pub fn build(self) -> PerformanceQuerySubmitInfoKHR {
37246 self.inner
37247 }
37248}
37249#[repr(C)]
37250#[cfg_attr(feature = "debug", derive(Debug))]
37251#[derive(Copy, Clone)]
37252#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkHeadlessSurfaceCreateInfoEXT.html>"]
37253pub struct HeadlessSurfaceCreateInfoEXT {
37254 pub s_type: StructureType,
37255 pub p_next: *const c_void,
37256 pub flags: HeadlessSurfaceCreateFlagsEXT,
37257}
37258impl ::std::default::Default for HeadlessSurfaceCreateInfoEXT {
37259 fn default() -> Self {
37260 Self {
37261 s_type: StructureType::HEADLESS_SURFACE_CREATE_INFO_EXT,
37262 p_next: ::std::ptr::null(),
37263 flags: HeadlessSurfaceCreateFlagsEXT::default(),
37264 }
37265 }
37266}
37267impl HeadlessSurfaceCreateInfoEXT {
37268 pub fn builder<'a>() -> HeadlessSurfaceCreateInfoEXTBuilder<'a> {
37269 HeadlessSurfaceCreateInfoEXTBuilder {
37270 inner: Self::default(),
37271 marker: ::std::marker::PhantomData,
37272 }
37273 }
37274}
37275#[repr(transparent)]
37276pub struct HeadlessSurfaceCreateInfoEXTBuilder<'a> {
37277 inner: HeadlessSurfaceCreateInfoEXT,
37278 marker: ::std::marker::PhantomData<&'a ()>,
37279}
37280impl<'a> ::std::ops::Deref for HeadlessSurfaceCreateInfoEXTBuilder<'a> {
37281 type Target = HeadlessSurfaceCreateInfoEXT;
37282 fn deref(&self) -> &Self::Target {
37283 &self.inner
37284 }
37285}
37286impl<'a> ::std::ops::DerefMut for HeadlessSurfaceCreateInfoEXTBuilder<'a> {
37287 fn deref_mut(&mut self) -> &mut Self::Target {
37288 &mut self.inner
37289 }
37290}
37291impl<'a> HeadlessSurfaceCreateInfoEXTBuilder<'a> {
37292 pub fn flags(mut self, flags: HeadlessSurfaceCreateFlagsEXT) -> Self {
37293 self.inner.flags = flags;
37294 self
37295 }
37296 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37297 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37298 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37299 pub fn build(self) -> HeadlessSurfaceCreateInfoEXT {
37300 self.inner
37301 }
37302}
37303#[repr(C)]
37304#[cfg_attr(feature = "debug", derive(Debug))]
37305#[derive(Copy, Clone)]
37306#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCoverageReductionModeFeaturesNV.html>"]
37307pub struct PhysicalDeviceCoverageReductionModeFeaturesNV {
37308 pub s_type: StructureType,
37309 pub p_next: *mut c_void,
37310 pub coverage_reduction_mode: Bool32,
37311}
37312impl ::std::default::Default for PhysicalDeviceCoverageReductionModeFeaturesNV {
37313 fn default() -> Self {
37314 Self {
37315 s_type: StructureType::PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV,
37316 p_next: ::std::ptr::null_mut(),
37317 coverage_reduction_mode: Bool32::default(),
37318 }
37319 }
37320}
37321impl PhysicalDeviceCoverageReductionModeFeaturesNV {
37322 pub fn builder<'a>() -> PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
37323 PhysicalDeviceCoverageReductionModeFeaturesNVBuilder {
37324 inner: Self::default(),
37325 marker: ::std::marker::PhantomData,
37326 }
37327 }
37328}
37329#[repr(transparent)]
37330pub struct PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
37331 inner: PhysicalDeviceCoverageReductionModeFeaturesNV,
37332 marker: ::std::marker::PhantomData<&'a ()>,
37333}
37334unsafe impl ExtendsPhysicalDeviceFeatures2
37335 for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'_>
37336{
37337}
37338unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCoverageReductionModeFeaturesNV {}
37339unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'_> {}
37340unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoverageReductionModeFeaturesNV {}
37341impl<'a> ::std::ops::Deref for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
37342 type Target = PhysicalDeviceCoverageReductionModeFeaturesNV;
37343 fn deref(&self) -> &Self::Target {
37344 &self.inner
37345 }
37346}
37347impl<'a> ::std::ops::DerefMut for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
37348 fn deref_mut(&mut self) -> &mut Self::Target {
37349 &mut self.inner
37350 }
37351}
37352impl<'a> PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
37353 pub fn coverage_reduction_mode(mut self, coverage_reduction_mode: bool) -> Self {
37354 self.inner.coverage_reduction_mode = coverage_reduction_mode.into();
37355 self
37356 }
37357 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37358 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37359 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37360 pub fn build(self) -> PhysicalDeviceCoverageReductionModeFeaturesNV {
37361 self.inner
37362 }
37363}
37364#[repr(C)]
37365#[cfg_attr(feature = "debug", derive(Debug))]
37366#[derive(Copy, Clone)]
37367#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageReductionStateCreateInfoNV.html>"]
37368pub struct PipelineCoverageReductionStateCreateInfoNV {
37369 pub s_type: StructureType,
37370 pub p_next: *const c_void,
37371 pub flags: PipelineCoverageReductionStateCreateFlagsNV,
37372 pub coverage_reduction_mode: CoverageReductionModeNV,
37373}
37374impl ::std::default::Default for PipelineCoverageReductionStateCreateInfoNV {
37375 fn default() -> Self {
37376 Self {
37377 s_type: StructureType::PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV,
37378 p_next: ::std::ptr::null(),
37379 flags: PipelineCoverageReductionStateCreateFlagsNV::default(),
37380 coverage_reduction_mode: CoverageReductionModeNV::default(),
37381 }
37382 }
37383}
37384impl PipelineCoverageReductionStateCreateInfoNV {
37385 pub fn builder<'a>() -> PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
37386 PipelineCoverageReductionStateCreateInfoNVBuilder {
37387 inner: Self::default(),
37388 marker: ::std::marker::PhantomData,
37389 }
37390 }
37391}
37392#[repr(transparent)]
37393pub struct PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
37394 inner: PipelineCoverageReductionStateCreateInfoNV,
37395 marker: ::std::marker::PhantomData<&'a ()>,
37396}
37397unsafe impl ExtendsPipelineMultisampleStateCreateInfo
37398 for PipelineCoverageReductionStateCreateInfoNVBuilder<'_>
37399{
37400}
37401unsafe impl ExtendsPipelineMultisampleStateCreateInfo
37402 for PipelineCoverageReductionStateCreateInfoNV
37403{
37404}
37405impl<'a> ::std::ops::Deref for PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
37406 type Target = PipelineCoverageReductionStateCreateInfoNV;
37407 fn deref(&self) -> &Self::Target {
37408 &self.inner
37409 }
37410}
37411impl<'a> ::std::ops::DerefMut for PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
37412 fn deref_mut(&mut self) -> &mut Self::Target {
37413 &mut self.inner
37414 }
37415}
37416impl<'a> PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
37417 pub fn flags(mut self, flags: PipelineCoverageReductionStateCreateFlagsNV) -> Self {
37418 self.inner.flags = flags;
37419 self
37420 }
37421 pub fn coverage_reduction_mode(
37422 mut self,
37423 coverage_reduction_mode: CoverageReductionModeNV,
37424 ) -> Self {
37425 self.inner.coverage_reduction_mode = coverage_reduction_mode;
37426 self
37427 }
37428 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37429 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37430 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37431 pub fn build(self) -> PipelineCoverageReductionStateCreateInfoNV {
37432 self.inner
37433 }
37434}
37435#[repr(C)]
37436#[cfg_attr(feature = "debug", derive(Debug))]
37437#[derive(Copy, Clone)]
37438#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebufferMixedSamplesCombinationNV.html>"]
37439pub struct FramebufferMixedSamplesCombinationNV {
37440 pub s_type: StructureType,
37441 pub p_next: *mut c_void,
37442 pub coverage_reduction_mode: CoverageReductionModeNV,
37443 pub rasterization_samples: SampleCountFlags,
37444 pub depth_stencil_samples: SampleCountFlags,
37445 pub color_samples: SampleCountFlags,
37446}
37447impl ::std::default::Default for FramebufferMixedSamplesCombinationNV {
37448 fn default() -> Self {
37449 Self {
37450 s_type: StructureType::FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV,
37451 p_next: ::std::ptr::null_mut(),
37452 coverage_reduction_mode: CoverageReductionModeNV::default(),
37453 rasterization_samples: SampleCountFlags::default(),
37454 depth_stencil_samples: SampleCountFlags::default(),
37455 color_samples: SampleCountFlags::default(),
37456 }
37457 }
37458}
37459impl FramebufferMixedSamplesCombinationNV {
37460 pub fn builder<'a>() -> FramebufferMixedSamplesCombinationNVBuilder<'a> {
37461 FramebufferMixedSamplesCombinationNVBuilder {
37462 inner: Self::default(),
37463 marker: ::std::marker::PhantomData,
37464 }
37465 }
37466}
37467#[repr(transparent)]
37468pub struct FramebufferMixedSamplesCombinationNVBuilder<'a> {
37469 inner: FramebufferMixedSamplesCombinationNV,
37470 marker: ::std::marker::PhantomData<&'a ()>,
37471}
37472impl<'a> ::std::ops::Deref for FramebufferMixedSamplesCombinationNVBuilder<'a> {
37473 type Target = FramebufferMixedSamplesCombinationNV;
37474 fn deref(&self) -> &Self::Target {
37475 &self.inner
37476 }
37477}
37478impl<'a> ::std::ops::DerefMut for FramebufferMixedSamplesCombinationNVBuilder<'a> {
37479 fn deref_mut(&mut self) -> &mut Self::Target {
37480 &mut self.inner
37481 }
37482}
37483impl<'a> FramebufferMixedSamplesCombinationNVBuilder<'a> {
37484 pub fn coverage_reduction_mode(
37485 mut self,
37486 coverage_reduction_mode: CoverageReductionModeNV,
37487 ) -> Self {
37488 self.inner.coverage_reduction_mode = coverage_reduction_mode;
37489 self
37490 }
37491 pub fn rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self {
37492 self.inner.rasterization_samples = rasterization_samples;
37493 self
37494 }
37495 pub fn depth_stencil_samples(mut self, depth_stencil_samples: SampleCountFlags) -> Self {
37496 self.inner.depth_stencil_samples = depth_stencil_samples;
37497 self
37498 }
37499 pub fn color_samples(mut self, color_samples: SampleCountFlags) -> Self {
37500 self.inner.color_samples = color_samples;
37501 self
37502 }
37503 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37504 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37505 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37506 pub fn build(self) -> FramebufferMixedSamplesCombinationNV {
37507 self.inner
37508 }
37509}
37510#[repr(C)]
37511#[cfg_attr(feature = "debug", derive(Debug))]
37512#[derive(Copy, Clone)]
37513#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL.html>"]
37514pub struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
37515 pub s_type: StructureType,
37516 pub p_next: *mut c_void,
37517 pub shader_integer_functions2: Bool32,
37518}
37519impl ::std::default::Default for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
37520 fn default() -> Self {
37521 Self {
37522 s_type: StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL,
37523 p_next: ::std::ptr::null_mut(),
37524 shader_integer_functions2: Bool32::default(),
37525 }
37526 }
37527}
37528impl PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
37529 pub fn builder<'a>() -> PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
37530 PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder {
37531 inner: Self::default(),
37532 marker: ::std::marker::PhantomData,
37533 }
37534 }
37535}
37536#[repr(transparent)]
37537pub struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
37538 inner: PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL,
37539 marker: ::std::marker::PhantomData<&'a ()>,
37540}
37541unsafe impl ExtendsPhysicalDeviceFeatures2
37542 for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'_>
37543{
37544}
37545unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {}
37546unsafe impl ExtendsDeviceCreateInfo
37547 for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'_>
37548{
37549}
37550unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {}
37551impl<'a> ::std::ops::Deref for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
37552 type Target = PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
37553 fn deref(&self) -> &Self::Target {
37554 &self.inner
37555 }
37556}
37557impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
37558 fn deref_mut(&mut self) -> &mut Self::Target {
37559 &mut self.inner
37560 }
37561}
37562impl<'a> PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
37563 pub fn shader_integer_functions2(mut self, shader_integer_functions2: bool) -> Self {
37564 self.inner.shader_integer_functions2 = shader_integer_functions2.into();
37565 self
37566 }
37567 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37568 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37569 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37570 pub fn build(self) -> PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
37571 self.inner
37572 }
37573}
37574#[repr(C)]
37575#[derive(Copy, Clone)]
37576#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceValueDataINTEL.html>"]
37577pub union PerformanceValueDataINTEL {
37578 pub value32: u32,
37579 pub value64: u64,
37580 pub value_float: f32,
37581 pub value_bool: Bool32,
37582 pub value_string: *const c_char,
37583}
37584impl ::std::default::Default for PerformanceValueDataINTEL {
37585 fn default() -> Self {
37586 unsafe { ::std::mem::zeroed() }
37587 }
37588}
37589#[repr(C)]
37590#[derive(Copy, Clone, Default)]
37591#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceValueINTEL.html>"]
37592pub struct PerformanceValueINTEL {
37593 pub ty: PerformanceValueTypeINTEL,
37594 pub data: PerformanceValueDataINTEL,
37595}
37596#[cfg(feature = "debug")]
37597impl fmt::Debug for PerformanceValueINTEL {
37598 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
37599 fmt.debug_struct("PerformanceValueINTEL")
37600 .field("ty", &self.ty)
37601 .field("data", &"union")
37602 .finish()
37603 }
37604}
37605impl PerformanceValueINTEL {
37606 pub fn builder<'a>() -> PerformanceValueINTELBuilder<'a> {
37607 PerformanceValueINTELBuilder {
37608 inner: Self::default(),
37609 marker: ::std::marker::PhantomData,
37610 }
37611 }
37612}
37613#[repr(transparent)]
37614pub struct PerformanceValueINTELBuilder<'a> {
37615 inner: PerformanceValueINTEL,
37616 marker: ::std::marker::PhantomData<&'a ()>,
37617}
37618impl<'a> ::std::ops::Deref for PerformanceValueINTELBuilder<'a> {
37619 type Target = PerformanceValueINTEL;
37620 fn deref(&self) -> &Self::Target {
37621 &self.inner
37622 }
37623}
37624impl<'a> ::std::ops::DerefMut for PerformanceValueINTELBuilder<'a> {
37625 fn deref_mut(&mut self) -> &mut Self::Target {
37626 &mut self.inner
37627 }
37628}
37629impl<'a> PerformanceValueINTELBuilder<'a> {
37630 pub fn ty(mut self, ty: PerformanceValueTypeINTEL) -> Self {
37631 self.inner.ty = ty;
37632 self
37633 }
37634 pub fn data(mut self, data: PerformanceValueDataINTEL) -> Self {
37635 self.inner.data = data;
37636 self
37637 }
37638 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37639 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37640 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37641 pub fn build(self) -> PerformanceValueINTEL {
37642 self.inner
37643 }
37644}
37645#[repr(C)]
37646#[cfg_attr(feature = "debug", derive(Debug))]
37647#[derive(Copy, Clone)]
37648#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkInitializePerformanceApiInfoINTEL.html>"]
37649pub struct InitializePerformanceApiInfoINTEL {
37650 pub s_type: StructureType,
37651 pub p_next: *const c_void,
37652 pub p_user_data: *mut c_void,
37653}
37654impl ::std::default::Default for InitializePerformanceApiInfoINTEL {
37655 fn default() -> Self {
37656 Self {
37657 s_type: StructureType::INITIALIZE_PERFORMANCE_API_INFO_INTEL,
37658 p_next: ::std::ptr::null(),
37659 p_user_data: ::std::ptr::null_mut(),
37660 }
37661 }
37662}
37663impl InitializePerformanceApiInfoINTEL {
37664 pub fn builder<'a>() -> InitializePerformanceApiInfoINTELBuilder<'a> {
37665 InitializePerformanceApiInfoINTELBuilder {
37666 inner: Self::default(),
37667 marker: ::std::marker::PhantomData,
37668 }
37669 }
37670}
37671#[repr(transparent)]
37672pub struct InitializePerformanceApiInfoINTELBuilder<'a> {
37673 inner: InitializePerformanceApiInfoINTEL,
37674 marker: ::std::marker::PhantomData<&'a ()>,
37675}
37676impl<'a> ::std::ops::Deref for InitializePerformanceApiInfoINTELBuilder<'a> {
37677 type Target = InitializePerformanceApiInfoINTEL;
37678 fn deref(&self) -> &Self::Target {
37679 &self.inner
37680 }
37681}
37682impl<'a> ::std::ops::DerefMut for InitializePerformanceApiInfoINTELBuilder<'a> {
37683 fn deref_mut(&mut self) -> &mut Self::Target {
37684 &mut self.inner
37685 }
37686}
37687impl<'a> InitializePerformanceApiInfoINTELBuilder<'a> {
37688 pub fn user_data(mut self, user_data: *mut c_void) -> Self {
37689 self.inner.p_user_data = user_data;
37690 self
37691 }
37692 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37693 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37694 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37695 pub fn build(self) -> InitializePerformanceApiInfoINTEL {
37696 self.inner
37697 }
37698}
37699#[repr(C)]
37700#[cfg_attr(feature = "debug", derive(Debug))]
37701#[derive(Copy, Clone)]
37702#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPoolPerformanceQueryCreateInfoINTEL.html>"]
37703pub struct QueryPoolPerformanceQueryCreateInfoINTEL {
37704 pub s_type: StructureType,
37705 pub p_next: *const c_void,
37706 pub performance_counters_sampling: QueryPoolSamplingModeINTEL,
37707}
37708impl ::std::default::Default for QueryPoolPerformanceQueryCreateInfoINTEL {
37709 fn default() -> Self {
37710 Self {
37711 s_type: StructureType::QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL,
37712 p_next: ::std::ptr::null(),
37713 performance_counters_sampling: QueryPoolSamplingModeINTEL::default(),
37714 }
37715 }
37716}
37717impl QueryPoolPerformanceQueryCreateInfoINTEL {
37718 pub fn builder<'a>() -> QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
37719 QueryPoolPerformanceQueryCreateInfoINTELBuilder {
37720 inner: Self::default(),
37721 marker: ::std::marker::PhantomData,
37722 }
37723 }
37724}
37725#[repr(transparent)]
37726pub struct QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
37727 inner: QueryPoolPerformanceQueryCreateInfoINTEL,
37728 marker: ::std::marker::PhantomData<&'a ()>,
37729}
37730unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceQueryCreateInfoINTELBuilder<'_> {}
37731unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceQueryCreateInfoINTEL {}
37732impl<'a> ::std::ops::Deref for QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
37733 type Target = QueryPoolPerformanceQueryCreateInfoINTEL;
37734 fn deref(&self) -> &Self::Target {
37735 &self.inner
37736 }
37737}
37738impl<'a> ::std::ops::DerefMut for QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
37739 fn deref_mut(&mut self) -> &mut Self::Target {
37740 &mut self.inner
37741 }
37742}
37743impl<'a> QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
37744 pub fn performance_counters_sampling(
37745 mut self,
37746 performance_counters_sampling: QueryPoolSamplingModeINTEL,
37747 ) -> Self {
37748 self.inner.performance_counters_sampling = performance_counters_sampling;
37749 self
37750 }
37751 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37752 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37753 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37754 pub fn build(self) -> QueryPoolPerformanceQueryCreateInfoINTEL {
37755 self.inner
37756 }
37757}
37758#[repr(C)]
37759#[cfg_attr(feature = "debug", derive(Debug))]
37760#[derive(Copy, Clone)]
37761#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceMarkerInfoINTEL.html>"]
37762pub struct PerformanceMarkerInfoINTEL {
37763 pub s_type: StructureType,
37764 pub p_next: *const c_void,
37765 pub marker: u64,
37766}
37767impl ::std::default::Default for PerformanceMarkerInfoINTEL {
37768 fn default() -> Self {
37769 Self {
37770 s_type: StructureType::PERFORMANCE_MARKER_INFO_INTEL,
37771 p_next: ::std::ptr::null(),
37772 marker: u64::default(),
37773 }
37774 }
37775}
37776impl PerformanceMarkerInfoINTEL {
37777 pub fn builder<'a>() -> PerformanceMarkerInfoINTELBuilder<'a> {
37778 PerformanceMarkerInfoINTELBuilder {
37779 inner: Self::default(),
37780 marker: ::std::marker::PhantomData,
37781 }
37782 }
37783}
37784#[repr(transparent)]
37785pub struct PerformanceMarkerInfoINTELBuilder<'a> {
37786 inner: PerformanceMarkerInfoINTEL,
37787 marker: ::std::marker::PhantomData<&'a ()>,
37788}
37789impl<'a> ::std::ops::Deref for PerformanceMarkerInfoINTELBuilder<'a> {
37790 type Target = PerformanceMarkerInfoINTEL;
37791 fn deref(&self) -> &Self::Target {
37792 &self.inner
37793 }
37794}
37795impl<'a> ::std::ops::DerefMut for PerformanceMarkerInfoINTELBuilder<'a> {
37796 fn deref_mut(&mut self) -> &mut Self::Target {
37797 &mut self.inner
37798 }
37799}
37800impl<'a> PerformanceMarkerInfoINTELBuilder<'a> {
37801 pub fn marker(mut self, marker: u64) -> Self {
37802 self.inner.marker = marker;
37803 self
37804 }
37805 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37806 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37807 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37808 pub fn build(self) -> PerformanceMarkerInfoINTEL {
37809 self.inner
37810 }
37811}
37812#[repr(C)]
37813#[cfg_attr(feature = "debug", derive(Debug))]
37814#[derive(Copy, Clone)]
37815#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceStreamMarkerInfoINTEL.html>"]
37816pub struct PerformanceStreamMarkerInfoINTEL {
37817 pub s_type: StructureType,
37818 pub p_next: *const c_void,
37819 pub marker: u32,
37820}
37821impl ::std::default::Default for PerformanceStreamMarkerInfoINTEL {
37822 fn default() -> Self {
37823 Self {
37824 s_type: StructureType::PERFORMANCE_STREAM_MARKER_INFO_INTEL,
37825 p_next: ::std::ptr::null(),
37826 marker: u32::default(),
37827 }
37828 }
37829}
37830impl PerformanceStreamMarkerInfoINTEL {
37831 pub fn builder<'a>() -> PerformanceStreamMarkerInfoINTELBuilder<'a> {
37832 PerformanceStreamMarkerInfoINTELBuilder {
37833 inner: Self::default(),
37834 marker: ::std::marker::PhantomData,
37835 }
37836 }
37837}
37838#[repr(transparent)]
37839pub struct PerformanceStreamMarkerInfoINTELBuilder<'a> {
37840 inner: PerformanceStreamMarkerInfoINTEL,
37841 marker: ::std::marker::PhantomData<&'a ()>,
37842}
37843impl<'a> ::std::ops::Deref for PerformanceStreamMarkerInfoINTELBuilder<'a> {
37844 type Target = PerformanceStreamMarkerInfoINTEL;
37845 fn deref(&self) -> &Self::Target {
37846 &self.inner
37847 }
37848}
37849impl<'a> ::std::ops::DerefMut for PerformanceStreamMarkerInfoINTELBuilder<'a> {
37850 fn deref_mut(&mut self) -> &mut Self::Target {
37851 &mut self.inner
37852 }
37853}
37854impl<'a> PerformanceStreamMarkerInfoINTELBuilder<'a> {
37855 pub fn marker(mut self, marker: u32) -> Self {
37856 self.inner.marker = marker;
37857 self
37858 }
37859 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37860 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37861 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37862 pub fn build(self) -> PerformanceStreamMarkerInfoINTEL {
37863 self.inner
37864 }
37865}
37866#[repr(C)]
37867#[cfg_attr(feature = "debug", derive(Debug))]
37868#[derive(Copy, Clone)]
37869#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceOverrideInfoINTEL.html>"]
37870pub struct PerformanceOverrideInfoINTEL {
37871 pub s_type: StructureType,
37872 pub p_next: *const c_void,
37873 pub ty: PerformanceOverrideTypeINTEL,
37874 pub enable: Bool32,
37875 pub parameter: u64,
37876}
37877impl ::std::default::Default for PerformanceOverrideInfoINTEL {
37878 fn default() -> Self {
37879 Self {
37880 s_type: StructureType::PERFORMANCE_OVERRIDE_INFO_INTEL,
37881 p_next: ::std::ptr::null(),
37882 ty: PerformanceOverrideTypeINTEL::default(),
37883 enable: Bool32::default(),
37884 parameter: u64::default(),
37885 }
37886 }
37887}
37888impl PerformanceOverrideInfoINTEL {
37889 pub fn builder<'a>() -> PerformanceOverrideInfoINTELBuilder<'a> {
37890 PerformanceOverrideInfoINTELBuilder {
37891 inner: Self::default(),
37892 marker: ::std::marker::PhantomData,
37893 }
37894 }
37895}
37896#[repr(transparent)]
37897pub struct PerformanceOverrideInfoINTELBuilder<'a> {
37898 inner: PerformanceOverrideInfoINTEL,
37899 marker: ::std::marker::PhantomData<&'a ()>,
37900}
37901impl<'a> ::std::ops::Deref for PerformanceOverrideInfoINTELBuilder<'a> {
37902 type Target = PerformanceOverrideInfoINTEL;
37903 fn deref(&self) -> &Self::Target {
37904 &self.inner
37905 }
37906}
37907impl<'a> ::std::ops::DerefMut for PerformanceOverrideInfoINTELBuilder<'a> {
37908 fn deref_mut(&mut self) -> &mut Self::Target {
37909 &mut self.inner
37910 }
37911}
37912impl<'a> PerformanceOverrideInfoINTELBuilder<'a> {
37913 pub fn ty(mut self, ty: PerformanceOverrideTypeINTEL) -> Self {
37914 self.inner.ty = ty;
37915 self
37916 }
37917 pub fn enable(mut self, enable: bool) -> Self {
37918 self.inner.enable = enable.into();
37919 self
37920 }
37921 pub fn parameter(mut self, parameter: u64) -> Self {
37922 self.inner.parameter = parameter;
37923 self
37924 }
37925 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37926 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37927 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37928 pub fn build(self) -> PerformanceOverrideInfoINTEL {
37929 self.inner
37930 }
37931}
37932#[repr(C)]
37933#[cfg_attr(feature = "debug", derive(Debug))]
37934#[derive(Copy, Clone)]
37935#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceConfigurationAcquireInfoINTEL.html>"]
37936pub struct PerformanceConfigurationAcquireInfoINTEL {
37937 pub s_type: StructureType,
37938 pub p_next: *const c_void,
37939 pub ty: PerformanceConfigurationTypeINTEL,
37940}
37941impl ::std::default::Default for PerformanceConfigurationAcquireInfoINTEL {
37942 fn default() -> Self {
37943 Self {
37944 s_type: StructureType::PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL,
37945 p_next: ::std::ptr::null(),
37946 ty: PerformanceConfigurationTypeINTEL::default(),
37947 }
37948 }
37949}
37950impl PerformanceConfigurationAcquireInfoINTEL {
37951 pub fn builder<'a>() -> PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
37952 PerformanceConfigurationAcquireInfoINTELBuilder {
37953 inner: Self::default(),
37954 marker: ::std::marker::PhantomData,
37955 }
37956 }
37957}
37958#[repr(transparent)]
37959pub struct PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
37960 inner: PerformanceConfigurationAcquireInfoINTEL,
37961 marker: ::std::marker::PhantomData<&'a ()>,
37962}
37963impl<'a> ::std::ops::Deref for PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
37964 type Target = PerformanceConfigurationAcquireInfoINTEL;
37965 fn deref(&self) -> &Self::Target {
37966 &self.inner
37967 }
37968}
37969impl<'a> ::std::ops::DerefMut for PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
37970 fn deref_mut(&mut self) -> &mut Self::Target {
37971 &mut self.inner
37972 }
37973}
37974impl<'a> PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
37975 pub fn ty(mut self, ty: PerformanceConfigurationTypeINTEL) -> Self {
37976 self.inner.ty = ty;
37977 self
37978 }
37979 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37980 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37981 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37982 pub fn build(self) -> PerformanceConfigurationAcquireInfoINTEL {
37983 self.inner
37984 }
37985}
37986#[repr(C)]
37987#[cfg_attr(feature = "debug", derive(Debug))]
37988#[derive(Copy, Clone)]
37989#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderClockFeaturesKHR.html>"]
37990pub struct PhysicalDeviceShaderClockFeaturesKHR {
37991 pub s_type: StructureType,
37992 pub p_next: *mut c_void,
37993 pub shader_subgroup_clock: Bool32,
37994 pub shader_device_clock: Bool32,
37995}
37996impl ::std::default::Default for PhysicalDeviceShaderClockFeaturesKHR {
37997 fn default() -> Self {
37998 Self {
37999 s_type: StructureType::PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR,
38000 p_next: ::std::ptr::null_mut(),
38001 shader_subgroup_clock: Bool32::default(),
38002 shader_device_clock: Bool32::default(),
38003 }
38004 }
38005}
38006impl PhysicalDeviceShaderClockFeaturesKHR {
38007 pub fn builder<'a>() -> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
38008 PhysicalDeviceShaderClockFeaturesKHRBuilder {
38009 inner: Self::default(),
38010 marker: ::std::marker::PhantomData,
38011 }
38012 }
38013}
38014#[repr(transparent)]
38015pub struct PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
38016 inner: PhysicalDeviceShaderClockFeaturesKHR,
38017 marker: ::std::marker::PhantomData<&'a ()>,
38018}
38019unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderClockFeaturesKHRBuilder<'_> {}
38020unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderClockFeaturesKHR {}
38021unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderClockFeaturesKHRBuilder<'_> {}
38022unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderClockFeaturesKHR {}
38023impl<'a> ::std::ops::Deref for PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
38024 type Target = PhysicalDeviceShaderClockFeaturesKHR;
38025 fn deref(&self) -> &Self::Target {
38026 &self.inner
38027 }
38028}
38029impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
38030 fn deref_mut(&mut self) -> &mut Self::Target {
38031 &mut self.inner
38032 }
38033}
38034impl<'a> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
38035 pub fn shader_subgroup_clock(mut self, shader_subgroup_clock: bool) -> Self {
38036 self.inner.shader_subgroup_clock = shader_subgroup_clock.into();
38037 self
38038 }
38039 pub fn shader_device_clock(mut self, shader_device_clock: bool) -> Self {
38040 self.inner.shader_device_clock = shader_device_clock.into();
38041 self
38042 }
38043 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38044 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38045 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
38046 pub fn build(self) -> PhysicalDeviceShaderClockFeaturesKHR {
38047 self.inner
38048 }
38049}
38050#[repr(C)]
38051#[cfg_attr(feature = "debug", derive(Debug))]
38052#[derive(Copy, Clone)]
38053#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceIndexTypeUint8FeaturesEXT.html>"]
38054pub struct PhysicalDeviceIndexTypeUint8FeaturesEXT {
38055 pub s_type: StructureType,
38056 pub p_next: *mut c_void,
38057 pub index_type_uint8: Bool32,
38058}
38059impl ::std::default::Default for PhysicalDeviceIndexTypeUint8FeaturesEXT {
38060 fn default() -> Self {
38061 Self {
38062 s_type: StructureType::PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT,
38063 p_next: ::std::ptr::null_mut(),
38064 index_type_uint8: Bool32::default(),
38065 }
38066 }
38067}
38068impl PhysicalDeviceIndexTypeUint8FeaturesEXT {
38069 pub fn builder<'a>() -> PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
38070 PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder {
38071 inner: Self::default(),
38072 marker: ::std::marker::PhantomData,
38073 }
38074 }
38075}
38076#[repr(transparent)]
38077pub struct PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
38078 inner: PhysicalDeviceIndexTypeUint8FeaturesEXT,
38079 marker: ::std::marker::PhantomData<&'a ()>,
38080}
38081unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'_> {}
38082unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceIndexTypeUint8FeaturesEXT {}
38083unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'_> {}
38084unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceIndexTypeUint8FeaturesEXT {}
38085impl<'a> ::std::ops::Deref for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
38086 type Target = PhysicalDeviceIndexTypeUint8FeaturesEXT;
38087 fn deref(&self) -> &Self::Target {
38088 &self.inner
38089 }
38090}
38091impl<'a> ::std::ops::DerefMut for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
38092 fn deref_mut(&mut self) -> &mut Self::Target {
38093 &mut self.inner
38094 }
38095}
38096impl<'a> PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
38097 pub fn index_type_uint8(mut self, index_type_uint8: bool) -> Self {
38098 self.inner.index_type_uint8 = index_type_uint8.into();
38099 self
38100 }
38101 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38102 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38103 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
38104 pub fn build(self) -> PhysicalDeviceIndexTypeUint8FeaturesEXT {
38105 self.inner
38106 }
38107}
38108#[repr(C)]
38109#[cfg_attr(feature = "debug", derive(Debug))]
38110#[derive(Copy, Clone)]
38111#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderSMBuiltinsPropertiesNV.html>"]
38112pub struct PhysicalDeviceShaderSMBuiltinsPropertiesNV {
38113 pub s_type: StructureType,
38114 pub p_next: *mut c_void,
38115 pub shader_sm_count: u32,
38116 pub shader_warps_per_sm: u32,
38117}
38118impl ::std::default::Default for PhysicalDeviceShaderSMBuiltinsPropertiesNV {
38119 fn default() -> Self {
38120 Self {
38121 s_type: StructureType::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV,
38122 p_next: ::std::ptr::null_mut(),
38123 shader_sm_count: u32::default(),
38124 shader_warps_per_sm: u32::default(),
38125 }
38126 }
38127}
38128impl PhysicalDeviceShaderSMBuiltinsPropertiesNV {
38129 pub fn builder<'a>() -> PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
38130 PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder {
38131 inner: Self::default(),
38132 marker: ::std::marker::PhantomData,
38133 }
38134 }
38135}
38136#[repr(transparent)]
38137pub struct PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
38138 inner: PhysicalDeviceShaderSMBuiltinsPropertiesNV,
38139 marker: ::std::marker::PhantomData<&'a ()>,
38140}
38141unsafe impl ExtendsPhysicalDeviceProperties2
38142 for PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'_>
38143{
38144}
38145unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderSMBuiltinsPropertiesNV {}
38146impl<'a> ::std::ops::Deref for PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
38147 type Target = PhysicalDeviceShaderSMBuiltinsPropertiesNV;
38148 fn deref(&self) -> &Self::Target {
38149 &self.inner
38150 }
38151}
38152impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
38153 fn deref_mut(&mut self) -> &mut Self::Target {
38154 &mut self.inner
38155 }
38156}
38157impl<'a> PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
38158 pub fn shader_sm_count(mut self, shader_sm_count: u32) -> Self {
38159 self.inner.shader_sm_count = shader_sm_count;
38160 self
38161 }
38162 pub fn shader_warps_per_sm(mut self, shader_warps_per_sm: u32) -> Self {
38163 self.inner.shader_warps_per_sm = shader_warps_per_sm;
38164 self
38165 }
38166 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38167 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38168 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
38169 pub fn build(self) -> PhysicalDeviceShaderSMBuiltinsPropertiesNV {
38170 self.inner
38171 }
38172}
38173#[repr(C)]
38174#[cfg_attr(feature = "debug", derive(Debug))]
38175#[derive(Copy, Clone)]
38176#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderSMBuiltinsFeaturesNV.html>"]
38177pub struct PhysicalDeviceShaderSMBuiltinsFeaturesNV {
38178 pub s_type: StructureType,
38179 pub p_next: *mut c_void,
38180 pub shader_sm_builtins: Bool32,
38181}
38182impl ::std::default::Default for PhysicalDeviceShaderSMBuiltinsFeaturesNV {
38183 fn default() -> Self {
38184 Self {
38185 s_type: StructureType::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV,
38186 p_next: ::std::ptr::null_mut(),
38187 shader_sm_builtins: Bool32::default(),
38188 }
38189 }
38190}
38191impl PhysicalDeviceShaderSMBuiltinsFeaturesNV {
38192 pub fn builder<'a>() -> PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
38193 PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder {
38194 inner: Self::default(),
38195 marker: ::std::marker::PhantomData,
38196 }
38197 }
38198}
38199#[repr(transparent)]
38200pub struct PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
38201 inner: PhysicalDeviceShaderSMBuiltinsFeaturesNV,
38202 marker: ::std::marker::PhantomData<&'a ()>,
38203}
38204unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'_> {}
38205unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderSMBuiltinsFeaturesNV {}
38206unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'_> {}
38207unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSMBuiltinsFeaturesNV {}
38208impl<'a> ::std::ops::Deref for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
38209 type Target = PhysicalDeviceShaderSMBuiltinsFeaturesNV;
38210 fn deref(&self) -> &Self::Target {
38211 &self.inner
38212 }
38213}
38214impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
38215 fn deref_mut(&mut self) -> &mut Self::Target {
38216 &mut self.inner
38217 }
38218}
38219impl<'a> PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
38220 pub fn shader_sm_builtins(mut self, shader_sm_builtins: bool) -> Self {
38221 self.inner.shader_sm_builtins = shader_sm_builtins.into();
38222 self
38223 }
38224 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38225 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38226 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
38227 pub fn build(self) -> PhysicalDeviceShaderSMBuiltinsFeaturesNV {
38228 self.inner
38229 }
38230}
38231#[repr(C)]
38232#[cfg_attr(feature = "debug", derive(Debug))]
38233#[derive(Copy, Clone)]
38234#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT.html>"]
38235pub struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
38236 pub s_type: StructureType,
38237 pub p_next: *mut c_void,
38238 pub fragment_shader_sample_interlock: Bool32,
38239 pub fragment_shader_pixel_interlock: Bool32,
38240 pub fragment_shader_shading_rate_interlock: Bool32,
38241}
38242impl ::std::default::Default for PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
38243 fn default() -> Self {
38244 Self {
38245 s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT,
38246 p_next: ::std::ptr::null_mut(),
38247 fragment_shader_sample_interlock: Bool32::default(),
38248 fragment_shader_pixel_interlock: Bool32::default(),
38249 fragment_shader_shading_rate_interlock: Bool32::default(),
38250 }
38251 }
38252}
38253impl PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
38254 pub fn builder<'a>() -> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
38255 PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder {
38256 inner: Self::default(),
38257 marker: ::std::marker::PhantomData,
38258 }
38259 }
38260}
38261#[repr(transparent)]
38262pub struct PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
38263 inner: PhysicalDeviceFragmentShaderInterlockFeaturesEXT,
38264 marker: ::std::marker::PhantomData<&'a ()>,
38265}
38266unsafe impl ExtendsPhysicalDeviceFeatures2
38267 for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'_>
38268{
38269}
38270unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShaderInterlockFeaturesEXT {}
38271unsafe impl ExtendsDeviceCreateInfo
38272 for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'_>
38273{
38274}
38275unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderInterlockFeaturesEXT {}
38276impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
38277 type Target = PhysicalDeviceFragmentShaderInterlockFeaturesEXT;
38278 fn deref(&self) -> &Self::Target {
38279 &self.inner
38280 }
38281}
38282impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
38283 fn deref_mut(&mut self) -> &mut Self::Target {
38284 &mut self.inner
38285 }
38286}
38287impl<'a> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
38288 pub fn fragment_shader_sample_interlock(
38289 mut self,
38290 fragment_shader_sample_interlock: bool,
38291 ) -> Self {
38292 self.inner.fragment_shader_sample_interlock = fragment_shader_sample_interlock.into();
38293 self
38294 }
38295 pub fn fragment_shader_pixel_interlock(
38296 mut self,
38297 fragment_shader_pixel_interlock: bool,
38298 ) -> Self {
38299 self.inner.fragment_shader_pixel_interlock = fragment_shader_pixel_interlock.into();
38300 self
38301 }
38302 pub fn fragment_shader_shading_rate_interlock(
38303 mut self,
38304 fragment_shader_shading_rate_interlock: bool,
38305 ) -> Self {
38306 self.inner.fragment_shader_shading_rate_interlock =
38307 fragment_shader_shading_rate_interlock.into();
38308 self
38309 }
38310 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38311 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38312 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
38313 pub fn build(self) -> PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
38314 self.inner
38315 }
38316}
38317#[repr(C)]
38318#[cfg_attr(feature = "debug", derive(Debug))]
38319#[derive(Copy, Clone)]
38320#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures.html>"]
38321pub struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
38322 pub s_type: StructureType,
38323 pub p_next: *mut c_void,
38324 pub separate_depth_stencil_layouts: Bool32,
38325}
38326impl ::std::default::Default for PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
38327 fn default() -> Self {
38328 Self {
38329 s_type: StructureType::PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES,
38330 p_next: ::std::ptr::null_mut(),
38331 separate_depth_stencil_layouts: Bool32::default(),
38332 }
38333 }
38334}
38335impl PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
38336 pub fn builder<'a>() -> PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
38337 PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder {
38338 inner: Self::default(),
38339 marker: ::std::marker::PhantomData,
38340 }
38341 }
38342}
38343#[repr(transparent)]
38344pub struct PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
38345 inner: PhysicalDeviceSeparateDepthStencilLayoutsFeatures,
38346 marker: ::std::marker::PhantomData<&'a ()>,
38347}
38348unsafe impl ExtendsPhysicalDeviceFeatures2
38349 for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'_>
38350{
38351}
38352unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSeparateDepthStencilLayoutsFeatures {}
38353unsafe impl ExtendsDeviceCreateInfo
38354 for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'_>
38355{
38356}
38357unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSeparateDepthStencilLayoutsFeatures {}
38358impl<'a> ::std::ops::Deref for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
38359 type Target = PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
38360 fn deref(&self) -> &Self::Target {
38361 &self.inner
38362 }
38363}
38364impl<'a> ::std::ops::DerefMut for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
38365 fn deref_mut(&mut self) -> &mut Self::Target {
38366 &mut self.inner
38367 }
38368}
38369impl<'a> PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
38370 pub fn separate_depth_stencil_layouts(mut self, separate_depth_stencil_layouts: bool) -> Self {
38371 self.inner.separate_depth_stencil_layouts = separate_depth_stencil_layouts.into();
38372 self
38373 }
38374 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38375 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38376 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
38377 pub fn build(self) -> PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
38378 self.inner
38379 }
38380}
38381#[repr(C)]
38382#[cfg_attr(feature = "debug", derive(Debug))]
38383#[derive(Copy, Clone)]
38384#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentReferenceStencilLayout.html>"]
38385pub struct AttachmentReferenceStencilLayout {
38386 pub s_type: StructureType,
38387 pub p_next: *mut c_void,
38388 pub stencil_layout: ImageLayout,
38389}
38390impl ::std::default::Default for AttachmentReferenceStencilLayout {
38391 fn default() -> Self {
38392 Self {
38393 s_type: StructureType::ATTACHMENT_REFERENCE_STENCIL_LAYOUT,
38394 p_next: ::std::ptr::null_mut(),
38395 stencil_layout: ImageLayout::default(),
38396 }
38397 }
38398}
38399impl AttachmentReferenceStencilLayout {
38400 pub fn builder<'a>() -> AttachmentReferenceStencilLayoutBuilder<'a> {
38401 AttachmentReferenceStencilLayoutBuilder {
38402 inner: Self::default(),
38403 marker: ::std::marker::PhantomData,
38404 }
38405 }
38406}
38407#[repr(transparent)]
38408pub struct AttachmentReferenceStencilLayoutBuilder<'a> {
38409 inner: AttachmentReferenceStencilLayout,
38410 marker: ::std::marker::PhantomData<&'a ()>,
38411}
38412unsafe impl ExtendsAttachmentReference2 for AttachmentReferenceStencilLayoutBuilder<'_> {}
38413unsafe impl ExtendsAttachmentReference2 for AttachmentReferenceStencilLayout {}
38414impl<'a> ::std::ops::Deref for AttachmentReferenceStencilLayoutBuilder<'a> {
38415 type Target = AttachmentReferenceStencilLayout;
38416 fn deref(&self) -> &Self::Target {
38417 &self.inner
38418 }
38419}
38420impl<'a> ::std::ops::DerefMut for AttachmentReferenceStencilLayoutBuilder<'a> {
38421 fn deref_mut(&mut self) -> &mut Self::Target {
38422 &mut self.inner
38423 }
38424}
38425impl<'a> AttachmentReferenceStencilLayoutBuilder<'a> {
38426 pub fn stencil_layout(mut self, stencil_layout: ImageLayout) -> Self {
38427 self.inner.stencil_layout = stencil_layout;
38428 self
38429 }
38430 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38431 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38432 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
38433 pub fn build(self) -> AttachmentReferenceStencilLayout {
38434 self.inner
38435 }
38436}
38437#[repr(C)]
38438#[cfg_attr(feature = "debug", derive(Debug))]
38439#[derive(Copy, Clone)]
38440#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT.html>"]
38441pub struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
38442 pub s_type: StructureType,
38443 pub p_next: *mut c_void,
38444 pub primitive_topology_list_restart: Bool32,
38445 pub primitive_topology_patch_list_restart: Bool32,
38446}
38447impl ::std::default::Default for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
38448 fn default() -> Self {
38449 Self {
38450 s_type: StructureType::PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT,
38451 p_next: ::std::ptr::null_mut(),
38452 primitive_topology_list_restart: Bool32::default(),
38453 primitive_topology_patch_list_restart: Bool32::default(),
38454 }
38455 }
38456}
38457impl PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
38458 pub fn builder<'a>() -> PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> {
38459 PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder {
38460 inner: Self::default(),
38461 marker: ::std::marker::PhantomData,
38462 }
38463 }
38464}
38465#[repr(transparent)]
38466pub struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> {
38467 inner: PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT,
38468 marker: ::std::marker::PhantomData<&'a ()>,
38469}
38470unsafe impl ExtendsPhysicalDeviceFeatures2
38471 for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'_>
38472{
38473}
38474unsafe impl ExtendsPhysicalDeviceFeatures2
38475 for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT
38476{
38477}
38478unsafe impl ExtendsDeviceCreateInfo
38479 for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'_>
38480{
38481}
38482unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {}
38483impl<'a> ::std::ops::Deref for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> {
38484 type Target = PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT;
38485 fn deref(&self) -> &Self::Target {
38486 &self.inner
38487 }
38488}
38489impl<'a> ::std::ops::DerefMut for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> {
38490 fn deref_mut(&mut self) -> &mut Self::Target {
38491 &mut self.inner
38492 }
38493}
38494impl<'a> PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> {
38495 pub fn primitive_topology_list_restart(
38496 mut self,
38497 primitive_topology_list_restart: bool,
38498 ) -> Self {
38499 self.inner.primitive_topology_list_restart = primitive_topology_list_restart.into();
38500 self
38501 }
38502 pub fn primitive_topology_patch_list_restart(
38503 mut self,
38504 primitive_topology_patch_list_restart: bool,
38505 ) -> Self {
38506 self.inner.primitive_topology_patch_list_restart =
38507 primitive_topology_patch_list_restart.into();
38508 self
38509 }
38510 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38511 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38512 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
38513 pub fn build(self) -> PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
38514 self.inner
38515 }
38516}
38517#[repr(C)]
38518#[cfg_attr(feature = "debug", derive(Debug))]
38519#[derive(Copy, Clone)]
38520#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentDescriptionStencilLayout.html>"]
38521pub struct AttachmentDescriptionStencilLayout {
38522 pub s_type: StructureType,
38523 pub p_next: *mut c_void,
38524 pub stencil_initial_layout: ImageLayout,
38525 pub stencil_final_layout: ImageLayout,
38526}
38527impl ::std::default::Default for AttachmentDescriptionStencilLayout {
38528 fn default() -> Self {
38529 Self {
38530 s_type: StructureType::ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT,
38531 p_next: ::std::ptr::null_mut(),
38532 stencil_initial_layout: ImageLayout::default(),
38533 stencil_final_layout: ImageLayout::default(),
38534 }
38535 }
38536}
38537impl AttachmentDescriptionStencilLayout {
38538 pub fn builder<'a>() -> AttachmentDescriptionStencilLayoutBuilder<'a> {
38539 AttachmentDescriptionStencilLayoutBuilder {
38540 inner: Self::default(),
38541 marker: ::std::marker::PhantomData,
38542 }
38543 }
38544}
38545#[repr(transparent)]
38546pub struct AttachmentDescriptionStencilLayoutBuilder<'a> {
38547 inner: AttachmentDescriptionStencilLayout,
38548 marker: ::std::marker::PhantomData<&'a ()>,
38549}
38550unsafe impl ExtendsAttachmentDescription2 for AttachmentDescriptionStencilLayoutBuilder<'_> {}
38551unsafe impl ExtendsAttachmentDescription2 for AttachmentDescriptionStencilLayout {}
38552impl<'a> ::std::ops::Deref for AttachmentDescriptionStencilLayoutBuilder<'a> {
38553 type Target = AttachmentDescriptionStencilLayout;
38554 fn deref(&self) -> &Self::Target {
38555 &self.inner
38556 }
38557}
38558impl<'a> ::std::ops::DerefMut for AttachmentDescriptionStencilLayoutBuilder<'a> {
38559 fn deref_mut(&mut self) -> &mut Self::Target {
38560 &mut self.inner
38561 }
38562}
38563impl<'a> AttachmentDescriptionStencilLayoutBuilder<'a> {
38564 pub fn stencil_initial_layout(mut self, stencil_initial_layout: ImageLayout) -> Self {
38565 self.inner.stencil_initial_layout = stencil_initial_layout;
38566 self
38567 }
38568 pub fn stencil_final_layout(mut self, stencil_final_layout: ImageLayout) -> Self {
38569 self.inner.stencil_final_layout = stencil_final_layout;
38570 self
38571 }
38572 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38573 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38574 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
38575 pub fn build(self) -> AttachmentDescriptionStencilLayout {
38576 self.inner
38577 }
38578}
38579#[repr(C)]
38580#[cfg_attr(feature = "debug", derive(Debug))]
38581#[derive(Copy, Clone)]
38582#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR.html>"]
38583pub struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
38584 pub s_type: StructureType,
38585 pub p_next: *mut c_void,
38586 pub pipeline_executable_info: Bool32,
38587}
38588impl ::std::default::Default for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
38589 fn default() -> Self {
38590 Self {
38591 s_type: StructureType::PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR,
38592 p_next: ::std::ptr::null_mut(),
38593 pipeline_executable_info: Bool32::default(),
38594 }
38595 }
38596}
38597impl PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
38598 pub fn builder<'a>() -> PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
38599 PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder {
38600 inner: Self::default(),
38601 marker: ::std::marker::PhantomData,
38602 }
38603 }
38604}
38605#[repr(transparent)]
38606pub struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
38607 inner: PhysicalDevicePipelineExecutablePropertiesFeaturesKHR,
38608 marker: ::std::marker::PhantomData<&'a ()>,
38609}
38610unsafe impl ExtendsPhysicalDeviceFeatures2
38611 for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'_>
38612{
38613}
38614unsafe impl ExtendsPhysicalDeviceFeatures2
38615 for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR
38616{
38617}
38618unsafe impl ExtendsDeviceCreateInfo
38619 for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'_>
38620{
38621}
38622unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {}
38623impl<'a> ::std::ops::Deref for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
38624 type Target = PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
38625 fn deref(&self) -> &Self::Target {
38626 &self.inner
38627 }
38628}
38629impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
38630 fn deref_mut(&mut self) -> &mut Self::Target {
38631 &mut self.inner
38632 }
38633}
38634impl<'a> PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
38635 pub fn pipeline_executable_info(mut self, pipeline_executable_info: bool) -> Self {
38636 self.inner.pipeline_executable_info = pipeline_executable_info.into();
38637 self
38638 }
38639 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38640 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38641 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
38642 pub fn build(self) -> PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
38643 self.inner
38644 }
38645}
38646#[repr(C)]
38647#[cfg_attr(feature = "debug", derive(Debug))]
38648#[derive(Copy, Clone)]
38649#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineInfoKHR.html>"]
38650pub struct PipelineInfoKHR {
38651 pub s_type: StructureType,
38652 pub p_next: *const c_void,
38653 pub pipeline: Pipeline,
38654}
38655impl ::std::default::Default for PipelineInfoKHR {
38656 fn default() -> Self {
38657 Self {
38658 s_type: StructureType::PIPELINE_INFO_KHR,
38659 p_next: ::std::ptr::null(),
38660 pipeline: Pipeline::default(),
38661 }
38662 }
38663}
38664impl PipelineInfoKHR {
38665 pub fn builder<'a>() -> PipelineInfoKHRBuilder<'a> {
38666 PipelineInfoKHRBuilder {
38667 inner: Self::default(),
38668 marker: ::std::marker::PhantomData,
38669 }
38670 }
38671}
38672#[repr(transparent)]
38673pub struct PipelineInfoKHRBuilder<'a> {
38674 inner: PipelineInfoKHR,
38675 marker: ::std::marker::PhantomData<&'a ()>,
38676}
38677impl<'a> ::std::ops::Deref for PipelineInfoKHRBuilder<'a> {
38678 type Target = PipelineInfoKHR;
38679 fn deref(&self) -> &Self::Target {
38680 &self.inner
38681 }
38682}
38683impl<'a> ::std::ops::DerefMut for PipelineInfoKHRBuilder<'a> {
38684 fn deref_mut(&mut self) -> &mut Self::Target {
38685 &mut self.inner
38686 }
38687}
38688impl<'a> PipelineInfoKHRBuilder<'a> {
38689 pub fn pipeline(mut self, pipeline: Pipeline) -> Self {
38690 self.inner.pipeline = pipeline;
38691 self
38692 }
38693 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38694 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38695 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
38696 pub fn build(self) -> PipelineInfoKHR {
38697 self.inner
38698 }
38699}
38700#[repr(C)]
38701#[derive(Copy, Clone)]
38702#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineExecutablePropertiesKHR.html>"]
38703pub struct PipelineExecutablePropertiesKHR {
38704 pub s_type: StructureType,
38705 pub p_next: *mut c_void,
38706 pub stages: ShaderStageFlags,
38707 pub name: [c_char; MAX_DESCRIPTION_SIZE],
38708 pub description: [c_char; MAX_DESCRIPTION_SIZE],
38709 pub subgroup_size: u32,
38710}
38711#[cfg(feature = "debug")]
38712impl fmt::Debug for PipelineExecutablePropertiesKHR {
38713 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
38714 fmt.debug_struct("PipelineExecutablePropertiesKHR")
38715 .field("s_type", &self.s_type)
38716 .field("p_next", &self.p_next)
38717 .field("stages", &self.stages)
38718 .field("name", &unsafe {
38719 ::std::ffi::CStr::from_ptr(self.name.as_ptr())
38720 })
38721 .field("description", &unsafe {
38722 ::std::ffi::CStr::from_ptr(self.description.as_ptr())
38723 })
38724 .field("subgroup_size", &self.subgroup_size)
38725 .finish()
38726 }
38727}
38728impl ::std::default::Default for PipelineExecutablePropertiesKHR {
38729 fn default() -> Self {
38730 Self {
38731 s_type: StructureType::PIPELINE_EXECUTABLE_PROPERTIES_KHR,
38732 p_next: ::std::ptr::null_mut(),
38733 stages: ShaderStageFlags::default(),
38734 name: unsafe { ::std::mem::zeroed() },
38735 description: unsafe { ::std::mem::zeroed() },
38736 subgroup_size: u32::default(),
38737 }
38738 }
38739}
38740impl PipelineExecutablePropertiesKHR {
38741 pub fn builder<'a>() -> PipelineExecutablePropertiesKHRBuilder<'a> {
38742 PipelineExecutablePropertiesKHRBuilder {
38743 inner: Self::default(),
38744 marker: ::std::marker::PhantomData,
38745 }
38746 }
38747}
38748#[repr(transparent)]
38749pub struct PipelineExecutablePropertiesKHRBuilder<'a> {
38750 inner: PipelineExecutablePropertiesKHR,
38751 marker: ::std::marker::PhantomData<&'a ()>,
38752}
38753impl<'a> ::std::ops::Deref for PipelineExecutablePropertiesKHRBuilder<'a> {
38754 type Target = PipelineExecutablePropertiesKHR;
38755 fn deref(&self) -> &Self::Target {
38756 &self.inner
38757 }
38758}
38759impl<'a> ::std::ops::DerefMut for PipelineExecutablePropertiesKHRBuilder<'a> {
38760 fn deref_mut(&mut self) -> &mut Self::Target {
38761 &mut self.inner
38762 }
38763}
38764impl<'a> PipelineExecutablePropertiesKHRBuilder<'a> {
38765 pub fn stages(mut self, stages: ShaderStageFlags) -> Self {
38766 self.inner.stages = stages;
38767 self
38768 }
38769 pub fn name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
38770 self.inner.name = name;
38771 self
38772 }
38773 pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
38774 self.inner.description = description;
38775 self
38776 }
38777 pub fn subgroup_size(mut self, subgroup_size: u32) -> Self {
38778 self.inner.subgroup_size = subgroup_size;
38779 self
38780 }
38781 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38782 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38783 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
38784 pub fn build(self) -> PipelineExecutablePropertiesKHR {
38785 self.inner
38786 }
38787}
38788#[repr(C)]
38789#[cfg_attr(feature = "debug", derive(Debug))]
38790#[derive(Copy, Clone)]
38791#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineExecutableInfoKHR.html>"]
38792pub struct PipelineExecutableInfoKHR {
38793 pub s_type: StructureType,
38794 pub p_next: *const c_void,
38795 pub pipeline: Pipeline,
38796 pub executable_index: u32,
38797}
38798impl ::std::default::Default for PipelineExecutableInfoKHR {
38799 fn default() -> Self {
38800 Self {
38801 s_type: StructureType::PIPELINE_EXECUTABLE_INFO_KHR,
38802 p_next: ::std::ptr::null(),
38803 pipeline: Pipeline::default(),
38804 executable_index: u32::default(),
38805 }
38806 }
38807}
38808impl PipelineExecutableInfoKHR {
38809 pub fn builder<'a>() -> PipelineExecutableInfoKHRBuilder<'a> {
38810 PipelineExecutableInfoKHRBuilder {
38811 inner: Self::default(),
38812 marker: ::std::marker::PhantomData,
38813 }
38814 }
38815}
38816#[repr(transparent)]
38817pub struct PipelineExecutableInfoKHRBuilder<'a> {
38818 inner: PipelineExecutableInfoKHR,
38819 marker: ::std::marker::PhantomData<&'a ()>,
38820}
38821impl<'a> ::std::ops::Deref for PipelineExecutableInfoKHRBuilder<'a> {
38822 type Target = PipelineExecutableInfoKHR;
38823 fn deref(&self) -> &Self::Target {
38824 &self.inner
38825 }
38826}
38827impl<'a> ::std::ops::DerefMut for PipelineExecutableInfoKHRBuilder<'a> {
38828 fn deref_mut(&mut self) -> &mut Self::Target {
38829 &mut self.inner
38830 }
38831}
38832impl<'a> PipelineExecutableInfoKHRBuilder<'a> {
38833 pub fn pipeline(mut self, pipeline: Pipeline) -> Self {
38834 self.inner.pipeline = pipeline;
38835 self
38836 }
38837 pub fn executable_index(mut self, executable_index: u32) -> Self {
38838 self.inner.executable_index = executable_index;
38839 self
38840 }
38841 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38842 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38843 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
38844 pub fn build(self) -> PipelineExecutableInfoKHR {
38845 self.inner
38846 }
38847}
38848#[repr(C)]
38849#[derive(Copy, Clone)]
38850#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineExecutableStatisticValueKHR.html>"]
38851pub union PipelineExecutableStatisticValueKHR {
38852 pub b32: Bool32,
38853 pub i64: i64,
38854 pub u64: u64,
38855 pub f64: f64,
38856}
38857impl ::std::default::Default for PipelineExecutableStatisticValueKHR {
38858 fn default() -> Self {
38859 unsafe { ::std::mem::zeroed() }
38860 }
38861}
38862#[repr(C)]
38863#[derive(Copy, Clone)]
38864#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineExecutableStatisticKHR.html>"]
38865pub struct PipelineExecutableStatisticKHR {
38866 pub s_type: StructureType,
38867 pub p_next: *mut c_void,
38868 pub name: [c_char; MAX_DESCRIPTION_SIZE],
38869 pub description: [c_char; MAX_DESCRIPTION_SIZE],
38870 pub format: PipelineExecutableStatisticFormatKHR,
38871 pub value: PipelineExecutableStatisticValueKHR,
38872}
38873#[cfg(feature = "debug")]
38874impl fmt::Debug for PipelineExecutableStatisticKHR {
38875 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
38876 fmt.debug_struct("PipelineExecutableStatisticKHR")
38877 .field("s_type", &self.s_type)
38878 .field("p_next", &self.p_next)
38879 .field("name", &unsafe {
38880 ::std::ffi::CStr::from_ptr(self.name.as_ptr())
38881 })
38882 .field("description", &unsafe {
38883 ::std::ffi::CStr::from_ptr(self.description.as_ptr())
38884 })
38885 .field("format", &self.format)
38886 .field("value", &"union")
38887 .finish()
38888 }
38889}
38890impl ::std::default::Default for PipelineExecutableStatisticKHR {
38891 fn default() -> Self {
38892 Self {
38893 s_type: StructureType::PIPELINE_EXECUTABLE_STATISTIC_KHR,
38894 p_next: ::std::ptr::null_mut(),
38895 name: unsafe { ::std::mem::zeroed() },
38896 description: unsafe { ::std::mem::zeroed() },
38897 format: PipelineExecutableStatisticFormatKHR::default(),
38898 value: PipelineExecutableStatisticValueKHR::default(),
38899 }
38900 }
38901}
38902impl PipelineExecutableStatisticKHR {
38903 pub fn builder<'a>() -> PipelineExecutableStatisticKHRBuilder<'a> {
38904 PipelineExecutableStatisticKHRBuilder {
38905 inner: Self::default(),
38906 marker: ::std::marker::PhantomData,
38907 }
38908 }
38909}
38910#[repr(transparent)]
38911pub struct PipelineExecutableStatisticKHRBuilder<'a> {
38912 inner: PipelineExecutableStatisticKHR,
38913 marker: ::std::marker::PhantomData<&'a ()>,
38914}
38915impl<'a> ::std::ops::Deref for PipelineExecutableStatisticKHRBuilder<'a> {
38916 type Target = PipelineExecutableStatisticKHR;
38917 fn deref(&self) -> &Self::Target {
38918 &self.inner
38919 }
38920}
38921impl<'a> ::std::ops::DerefMut for PipelineExecutableStatisticKHRBuilder<'a> {
38922 fn deref_mut(&mut self) -> &mut Self::Target {
38923 &mut self.inner
38924 }
38925}
38926impl<'a> PipelineExecutableStatisticKHRBuilder<'a> {
38927 pub fn name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
38928 self.inner.name = name;
38929 self
38930 }
38931 pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
38932 self.inner.description = description;
38933 self
38934 }
38935 pub fn format(mut self, format: PipelineExecutableStatisticFormatKHR) -> Self {
38936 self.inner.format = format;
38937 self
38938 }
38939 pub fn value(mut self, value: PipelineExecutableStatisticValueKHR) -> Self {
38940 self.inner.value = value;
38941 self
38942 }
38943 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38944 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38945 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
38946 pub fn build(self) -> PipelineExecutableStatisticKHR {
38947 self.inner
38948 }
38949}
38950#[repr(C)]
38951#[derive(Copy, Clone)]
38952#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineExecutableInternalRepresentationKHR.html>"]
38953pub struct PipelineExecutableInternalRepresentationKHR {
38954 pub s_type: StructureType,
38955 pub p_next: *mut c_void,
38956 pub name: [c_char; MAX_DESCRIPTION_SIZE],
38957 pub description: [c_char; MAX_DESCRIPTION_SIZE],
38958 pub is_text: Bool32,
38959 pub data_size: usize,
38960 pub p_data: *mut c_void,
38961}
38962#[cfg(feature = "debug")]
38963impl fmt::Debug for PipelineExecutableInternalRepresentationKHR {
38964 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
38965 fmt.debug_struct("PipelineExecutableInternalRepresentationKHR")
38966 .field("s_type", &self.s_type)
38967 .field("p_next", &self.p_next)
38968 .field("name", &unsafe {
38969 ::std::ffi::CStr::from_ptr(self.name.as_ptr())
38970 })
38971 .field("description", &unsafe {
38972 ::std::ffi::CStr::from_ptr(self.description.as_ptr())
38973 })
38974 .field("is_text", &self.is_text)
38975 .field("data_size", &self.data_size)
38976 .field("p_data", &self.p_data)
38977 .finish()
38978 }
38979}
38980impl ::std::default::Default for PipelineExecutableInternalRepresentationKHR {
38981 fn default() -> Self {
38982 Self {
38983 s_type: StructureType::PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR,
38984 p_next: ::std::ptr::null_mut(),
38985 name: unsafe { ::std::mem::zeroed() },
38986 description: unsafe { ::std::mem::zeroed() },
38987 is_text: Bool32::default(),
38988 data_size: usize::default(),
38989 p_data: ::std::ptr::null_mut(),
38990 }
38991 }
38992}
38993impl PipelineExecutableInternalRepresentationKHR {
38994 pub fn builder<'a>() -> PipelineExecutableInternalRepresentationKHRBuilder<'a> {
38995 PipelineExecutableInternalRepresentationKHRBuilder {
38996 inner: Self::default(),
38997 marker: ::std::marker::PhantomData,
38998 }
38999 }
39000}
39001#[repr(transparent)]
39002pub struct PipelineExecutableInternalRepresentationKHRBuilder<'a> {
39003 inner: PipelineExecutableInternalRepresentationKHR,
39004 marker: ::std::marker::PhantomData<&'a ()>,
39005}
39006impl<'a> ::std::ops::Deref for PipelineExecutableInternalRepresentationKHRBuilder<'a> {
39007 type Target = PipelineExecutableInternalRepresentationKHR;
39008 fn deref(&self) -> &Self::Target {
39009 &self.inner
39010 }
39011}
39012impl<'a> ::std::ops::DerefMut for PipelineExecutableInternalRepresentationKHRBuilder<'a> {
39013 fn deref_mut(&mut self) -> &mut Self::Target {
39014 &mut self.inner
39015 }
39016}
39017impl<'a> PipelineExecutableInternalRepresentationKHRBuilder<'a> {
39018 pub fn name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
39019 self.inner.name = name;
39020 self
39021 }
39022 pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
39023 self.inner.description = description;
39024 self
39025 }
39026 pub fn is_text(mut self, is_text: bool) -> Self {
39027 self.inner.is_text = is_text.into();
39028 self
39029 }
39030 pub fn data(mut self, data: &'a mut [u8]) -> Self {
39031 self.inner.data_size = data.len();
39032 self.inner.p_data = data.as_mut_ptr() as *mut c_void;
39033 self
39034 }
39035 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39036 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39037 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
39038 pub fn build(self) -> PipelineExecutableInternalRepresentationKHR {
39039 self.inner
39040 }
39041}
39042#[repr(C)]
39043#[cfg_attr(feature = "debug", derive(Debug))]
39044#[derive(Copy, Clone)]
39045#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures.html>"]
39046pub struct PhysicalDeviceShaderDemoteToHelperInvocationFeatures {
39047 pub s_type: StructureType,
39048 pub p_next: *mut c_void,
39049 pub shader_demote_to_helper_invocation: Bool32,
39050}
39051impl ::std::default::Default for PhysicalDeviceShaderDemoteToHelperInvocationFeatures {
39052 fn default() -> Self {
39053 Self {
39054 s_type: StructureType::PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES,
39055 p_next: ::std::ptr::null_mut(),
39056 shader_demote_to_helper_invocation: Bool32::default(),
39057 }
39058 }
39059}
39060impl PhysicalDeviceShaderDemoteToHelperInvocationFeatures {
39061 pub fn builder<'a>() -> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> {
39062 PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder {
39063 inner: Self::default(),
39064 marker: ::std::marker::PhantomData,
39065 }
39066 }
39067}
39068#[repr(transparent)]
39069pub struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> {
39070 inner: PhysicalDeviceShaderDemoteToHelperInvocationFeatures,
39071 marker: ::std::marker::PhantomData<&'a ()>,
39072}
39073unsafe impl ExtendsPhysicalDeviceFeatures2
39074 for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'_>
39075{
39076}
39077unsafe impl ExtendsPhysicalDeviceFeatures2
39078 for PhysicalDeviceShaderDemoteToHelperInvocationFeatures
39079{
39080}
39081unsafe impl ExtendsDeviceCreateInfo
39082 for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'_>
39083{
39084}
39085unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDemoteToHelperInvocationFeatures {}
39086impl<'a> ::std::ops::Deref for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> {
39087 type Target = PhysicalDeviceShaderDemoteToHelperInvocationFeatures;
39088 fn deref(&self) -> &Self::Target {
39089 &self.inner
39090 }
39091}
39092impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> {
39093 fn deref_mut(&mut self) -> &mut Self::Target {
39094 &mut self.inner
39095 }
39096}
39097impl<'a> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> {
39098 pub fn shader_demote_to_helper_invocation(
39099 mut self,
39100 shader_demote_to_helper_invocation: bool,
39101 ) -> Self {
39102 self.inner.shader_demote_to_helper_invocation = shader_demote_to_helper_invocation.into();
39103 self
39104 }
39105 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39106 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39107 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
39108 pub fn build(self) -> PhysicalDeviceShaderDemoteToHelperInvocationFeatures {
39109 self.inner
39110 }
39111}
39112#[repr(C)]
39113#[cfg_attr(feature = "debug", derive(Debug))]
39114#[derive(Copy, Clone)]
39115#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT.html>"]
39116pub struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
39117 pub s_type: StructureType,
39118 pub p_next: *mut c_void,
39119 pub texel_buffer_alignment: Bool32,
39120}
39121impl ::std::default::Default for PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
39122 fn default() -> Self {
39123 Self {
39124 s_type: StructureType::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT,
39125 p_next: ::std::ptr::null_mut(),
39126 texel_buffer_alignment: Bool32::default(),
39127 }
39128 }
39129}
39130impl PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
39131 pub fn builder<'a>() -> PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
39132 PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder {
39133 inner: Self::default(),
39134 marker: ::std::marker::PhantomData,
39135 }
39136 }
39137}
39138#[repr(transparent)]
39139pub struct PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
39140 inner: PhysicalDeviceTexelBufferAlignmentFeaturesEXT,
39141 marker: ::std::marker::PhantomData<&'a ()>,
39142}
39143unsafe impl ExtendsPhysicalDeviceFeatures2
39144 for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'_>
39145{
39146}
39147unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTexelBufferAlignmentFeaturesEXT {}
39148unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'_> {}
39149unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTexelBufferAlignmentFeaturesEXT {}
39150impl<'a> ::std::ops::Deref for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
39151 type Target = PhysicalDeviceTexelBufferAlignmentFeaturesEXT;
39152 fn deref(&self) -> &Self::Target {
39153 &self.inner
39154 }
39155}
39156impl<'a> ::std::ops::DerefMut for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
39157 fn deref_mut(&mut self) -> &mut Self::Target {
39158 &mut self.inner
39159 }
39160}
39161impl<'a> PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
39162 pub fn texel_buffer_alignment(mut self, texel_buffer_alignment: bool) -> Self {
39163 self.inner.texel_buffer_alignment = texel_buffer_alignment.into();
39164 self
39165 }
39166 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39167 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39168 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
39169 pub fn build(self) -> PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
39170 self.inner
39171 }
39172}
39173#[repr(C)]
39174#[cfg_attr(feature = "debug", derive(Debug))]
39175#[derive(Copy, Clone)]
39176#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTexelBufferAlignmentProperties.html>"]
39177pub struct PhysicalDeviceTexelBufferAlignmentProperties {
39178 pub s_type: StructureType,
39179 pub p_next: *mut c_void,
39180 pub storage_texel_buffer_offset_alignment_bytes: DeviceSize,
39181 pub storage_texel_buffer_offset_single_texel_alignment: Bool32,
39182 pub uniform_texel_buffer_offset_alignment_bytes: DeviceSize,
39183 pub uniform_texel_buffer_offset_single_texel_alignment: Bool32,
39184}
39185impl ::std::default::Default for PhysicalDeviceTexelBufferAlignmentProperties {
39186 fn default() -> Self {
39187 Self {
39188 s_type: StructureType::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES,
39189 p_next: ::std::ptr::null_mut(),
39190 storage_texel_buffer_offset_alignment_bytes: DeviceSize::default(),
39191 storage_texel_buffer_offset_single_texel_alignment: Bool32::default(),
39192 uniform_texel_buffer_offset_alignment_bytes: DeviceSize::default(),
39193 uniform_texel_buffer_offset_single_texel_alignment: Bool32::default(),
39194 }
39195 }
39196}
39197impl PhysicalDeviceTexelBufferAlignmentProperties {
39198 pub fn builder<'a>() -> PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> {
39199 PhysicalDeviceTexelBufferAlignmentPropertiesBuilder {
39200 inner: Self::default(),
39201 marker: ::std::marker::PhantomData,
39202 }
39203 }
39204}
39205#[repr(transparent)]
39206pub struct PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> {
39207 inner: PhysicalDeviceTexelBufferAlignmentProperties,
39208 marker: ::std::marker::PhantomData<&'a ()>,
39209}
39210unsafe impl ExtendsPhysicalDeviceProperties2
39211 for PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'_>
39212{
39213}
39214unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTexelBufferAlignmentProperties {}
39215impl<'a> ::std::ops::Deref for PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> {
39216 type Target = PhysicalDeviceTexelBufferAlignmentProperties;
39217 fn deref(&self) -> &Self::Target {
39218 &self.inner
39219 }
39220}
39221impl<'a> ::std::ops::DerefMut for PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> {
39222 fn deref_mut(&mut self) -> &mut Self::Target {
39223 &mut self.inner
39224 }
39225}
39226impl<'a> PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> {
39227 pub fn storage_texel_buffer_offset_alignment_bytes(
39228 mut self,
39229 storage_texel_buffer_offset_alignment_bytes: DeviceSize,
39230 ) -> Self {
39231 self.inner.storage_texel_buffer_offset_alignment_bytes =
39232 storage_texel_buffer_offset_alignment_bytes;
39233 self
39234 }
39235 pub fn storage_texel_buffer_offset_single_texel_alignment(
39236 mut self,
39237 storage_texel_buffer_offset_single_texel_alignment: bool,
39238 ) -> Self {
39239 self.inner
39240 .storage_texel_buffer_offset_single_texel_alignment =
39241 storage_texel_buffer_offset_single_texel_alignment.into();
39242 self
39243 }
39244 pub fn uniform_texel_buffer_offset_alignment_bytes(
39245 mut self,
39246 uniform_texel_buffer_offset_alignment_bytes: DeviceSize,
39247 ) -> Self {
39248 self.inner.uniform_texel_buffer_offset_alignment_bytes =
39249 uniform_texel_buffer_offset_alignment_bytes;
39250 self
39251 }
39252 pub fn uniform_texel_buffer_offset_single_texel_alignment(
39253 mut self,
39254 uniform_texel_buffer_offset_single_texel_alignment: bool,
39255 ) -> Self {
39256 self.inner
39257 .uniform_texel_buffer_offset_single_texel_alignment =
39258 uniform_texel_buffer_offset_single_texel_alignment.into();
39259 self
39260 }
39261 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39262 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39263 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
39264 pub fn build(self) -> PhysicalDeviceTexelBufferAlignmentProperties {
39265 self.inner
39266 }
39267}
39268#[repr(C)]
39269#[cfg_attr(feature = "debug", derive(Debug))]
39270#[derive(Copy, Clone)]
39271#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSubgroupSizeControlFeatures.html>"]
39272pub struct PhysicalDeviceSubgroupSizeControlFeatures {
39273 pub s_type: StructureType,
39274 pub p_next: *mut c_void,
39275 pub subgroup_size_control: Bool32,
39276 pub compute_full_subgroups: Bool32,
39277}
39278impl ::std::default::Default for PhysicalDeviceSubgroupSizeControlFeatures {
39279 fn default() -> Self {
39280 Self {
39281 s_type: StructureType::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES,
39282 p_next: ::std::ptr::null_mut(),
39283 subgroup_size_control: Bool32::default(),
39284 compute_full_subgroups: Bool32::default(),
39285 }
39286 }
39287}
39288impl PhysicalDeviceSubgroupSizeControlFeatures {
39289 pub fn builder<'a>() -> PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> {
39290 PhysicalDeviceSubgroupSizeControlFeaturesBuilder {
39291 inner: Self::default(),
39292 marker: ::std::marker::PhantomData,
39293 }
39294 }
39295}
39296#[repr(transparent)]
39297pub struct PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> {
39298 inner: PhysicalDeviceSubgroupSizeControlFeatures,
39299 marker: ::std::marker::PhantomData<&'a ()>,
39300}
39301unsafe impl ExtendsPhysicalDeviceFeatures2
39302 for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'_>
39303{
39304}
39305unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSubgroupSizeControlFeatures {}
39306unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'_> {}
39307unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubgroupSizeControlFeatures {}
39308impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> {
39309 type Target = PhysicalDeviceSubgroupSizeControlFeatures;
39310 fn deref(&self) -> &Self::Target {
39311 &self.inner
39312 }
39313}
39314impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> {
39315 fn deref_mut(&mut self) -> &mut Self::Target {
39316 &mut self.inner
39317 }
39318}
39319impl<'a> PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> {
39320 pub fn subgroup_size_control(mut self, subgroup_size_control: bool) -> Self {
39321 self.inner.subgroup_size_control = subgroup_size_control.into();
39322 self
39323 }
39324 pub fn compute_full_subgroups(mut self, compute_full_subgroups: bool) -> Self {
39325 self.inner.compute_full_subgroups = compute_full_subgroups.into();
39326 self
39327 }
39328 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39329 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39330 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
39331 pub fn build(self) -> PhysicalDeviceSubgroupSizeControlFeatures {
39332 self.inner
39333 }
39334}
39335#[repr(C)]
39336#[cfg_attr(feature = "debug", derive(Debug))]
39337#[derive(Copy, Clone)]
39338#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSubgroupSizeControlProperties.html>"]
39339pub struct PhysicalDeviceSubgroupSizeControlProperties {
39340 pub s_type: StructureType,
39341 pub p_next: *mut c_void,
39342 pub min_subgroup_size: u32,
39343 pub max_subgroup_size: u32,
39344 pub max_compute_workgroup_subgroups: u32,
39345 pub required_subgroup_size_stages: ShaderStageFlags,
39346}
39347impl ::std::default::Default for PhysicalDeviceSubgroupSizeControlProperties {
39348 fn default() -> Self {
39349 Self {
39350 s_type: StructureType::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES,
39351 p_next: ::std::ptr::null_mut(),
39352 min_subgroup_size: u32::default(),
39353 max_subgroup_size: u32::default(),
39354 max_compute_workgroup_subgroups: u32::default(),
39355 required_subgroup_size_stages: ShaderStageFlags::default(),
39356 }
39357 }
39358}
39359impl PhysicalDeviceSubgroupSizeControlProperties {
39360 pub fn builder<'a>() -> PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> {
39361 PhysicalDeviceSubgroupSizeControlPropertiesBuilder {
39362 inner: Self::default(),
39363 marker: ::std::marker::PhantomData,
39364 }
39365 }
39366}
39367#[repr(transparent)]
39368pub struct PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> {
39369 inner: PhysicalDeviceSubgroupSizeControlProperties,
39370 marker: ::std::marker::PhantomData<&'a ()>,
39371}
39372unsafe impl ExtendsPhysicalDeviceProperties2
39373 for PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'_>
39374{
39375}
39376unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupSizeControlProperties {}
39377impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> {
39378 type Target = PhysicalDeviceSubgroupSizeControlProperties;
39379 fn deref(&self) -> &Self::Target {
39380 &self.inner
39381 }
39382}
39383impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> {
39384 fn deref_mut(&mut self) -> &mut Self::Target {
39385 &mut self.inner
39386 }
39387}
39388impl<'a> PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> {
39389 pub fn min_subgroup_size(mut self, min_subgroup_size: u32) -> Self {
39390 self.inner.min_subgroup_size = min_subgroup_size;
39391 self
39392 }
39393 pub fn max_subgroup_size(mut self, max_subgroup_size: u32) -> Self {
39394 self.inner.max_subgroup_size = max_subgroup_size;
39395 self
39396 }
39397 pub fn max_compute_workgroup_subgroups(mut self, max_compute_workgroup_subgroups: u32) -> Self {
39398 self.inner.max_compute_workgroup_subgroups = max_compute_workgroup_subgroups;
39399 self
39400 }
39401 pub fn required_subgroup_size_stages(
39402 mut self,
39403 required_subgroup_size_stages: ShaderStageFlags,
39404 ) -> Self {
39405 self.inner.required_subgroup_size_stages = required_subgroup_size_stages;
39406 self
39407 }
39408 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39409 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39410 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
39411 pub fn build(self) -> PhysicalDeviceSubgroupSizeControlProperties {
39412 self.inner
39413 }
39414}
39415#[repr(C)]
39416#[cfg_attr(feature = "debug", derive(Debug))]
39417#[derive(Copy, Clone)]
39418#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineShaderStageRequiredSubgroupSizeCreateInfo.html>"]
39419pub struct PipelineShaderStageRequiredSubgroupSizeCreateInfo {
39420 pub s_type: StructureType,
39421 pub p_next: *mut c_void,
39422 pub required_subgroup_size: u32,
39423}
39424impl ::std::default::Default for PipelineShaderStageRequiredSubgroupSizeCreateInfo {
39425 fn default() -> Self {
39426 Self {
39427 s_type: StructureType::PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO,
39428 p_next: ::std::ptr::null_mut(),
39429 required_subgroup_size: u32::default(),
39430 }
39431 }
39432}
39433impl PipelineShaderStageRequiredSubgroupSizeCreateInfo {
39434 pub fn builder<'a>() -> PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> {
39435 PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder {
39436 inner: Self::default(),
39437 marker: ::std::marker::PhantomData,
39438 }
39439 }
39440}
39441#[repr(transparent)]
39442pub struct PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> {
39443 inner: PipelineShaderStageRequiredSubgroupSizeCreateInfo,
39444 marker: ::std::marker::PhantomData<&'a ()>,
39445}
39446unsafe impl ExtendsPipelineShaderStageCreateInfo
39447 for PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'_>
39448{
39449}
39450unsafe impl ExtendsPipelineShaderStageCreateInfo
39451 for PipelineShaderStageRequiredSubgroupSizeCreateInfo
39452{
39453}
39454impl<'a> ::std::ops::Deref for PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> {
39455 type Target = PipelineShaderStageRequiredSubgroupSizeCreateInfo;
39456 fn deref(&self) -> &Self::Target {
39457 &self.inner
39458 }
39459}
39460impl<'a> ::std::ops::DerefMut for PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> {
39461 fn deref_mut(&mut self) -> &mut Self::Target {
39462 &mut self.inner
39463 }
39464}
39465impl<'a> PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> {
39466 pub fn required_subgroup_size(mut self, required_subgroup_size: u32) -> Self {
39467 self.inner.required_subgroup_size = required_subgroup_size;
39468 self
39469 }
39470 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39471 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39472 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
39473 pub fn build(self) -> PipelineShaderStageRequiredSubgroupSizeCreateInfo {
39474 self.inner
39475 }
39476}
39477#[repr(C)]
39478#[cfg_attr(feature = "debug", derive(Debug))]
39479#[derive(Copy, Clone)]
39480#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassShadingPipelineCreateInfoHUAWEI.html>"]
39481pub struct SubpassShadingPipelineCreateInfoHUAWEI {
39482 pub s_type: StructureType,
39483 pub p_next: *mut c_void,
39484 pub render_pass: RenderPass,
39485 pub subpass: u32,
39486}
39487impl ::std::default::Default for SubpassShadingPipelineCreateInfoHUAWEI {
39488 fn default() -> Self {
39489 Self {
39490 s_type: StructureType::SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI,
39491 p_next: ::std::ptr::null_mut(),
39492 render_pass: RenderPass::default(),
39493 subpass: u32::default(),
39494 }
39495 }
39496}
39497impl SubpassShadingPipelineCreateInfoHUAWEI {
39498 pub fn builder<'a>() -> SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> {
39499 SubpassShadingPipelineCreateInfoHUAWEIBuilder {
39500 inner: Self::default(),
39501 marker: ::std::marker::PhantomData,
39502 }
39503 }
39504}
39505#[repr(transparent)]
39506pub struct SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> {
39507 inner: SubpassShadingPipelineCreateInfoHUAWEI,
39508 marker: ::std::marker::PhantomData<&'a ()>,
39509}
39510unsafe impl ExtendsComputePipelineCreateInfo for SubpassShadingPipelineCreateInfoHUAWEIBuilder<'_> {}
39511unsafe impl ExtendsComputePipelineCreateInfo for SubpassShadingPipelineCreateInfoHUAWEI {}
39512impl<'a> ::std::ops::Deref for SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> {
39513 type Target = SubpassShadingPipelineCreateInfoHUAWEI;
39514 fn deref(&self) -> &Self::Target {
39515 &self.inner
39516 }
39517}
39518impl<'a> ::std::ops::DerefMut for SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> {
39519 fn deref_mut(&mut self) -> &mut Self::Target {
39520 &mut self.inner
39521 }
39522}
39523impl<'a> SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> {
39524 pub fn render_pass(mut self, render_pass: RenderPass) -> Self {
39525 self.inner.render_pass = render_pass;
39526 self
39527 }
39528 pub fn subpass(mut self, subpass: u32) -> Self {
39529 self.inner.subpass = subpass;
39530 self
39531 }
39532 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39533 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39534 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
39535 pub fn build(self) -> SubpassShadingPipelineCreateInfoHUAWEI {
39536 self.inner
39537 }
39538}
39539#[repr(C)]
39540#[cfg_attr(feature = "debug", derive(Debug))]
39541#[derive(Copy, Clone)]
39542#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSubpassShadingPropertiesHUAWEI.html>"]
39543pub struct PhysicalDeviceSubpassShadingPropertiesHUAWEI {
39544 pub s_type: StructureType,
39545 pub p_next: *mut c_void,
39546 pub max_subpass_shading_workgroup_size_aspect_ratio: u32,
39547}
39548impl ::std::default::Default for PhysicalDeviceSubpassShadingPropertiesHUAWEI {
39549 fn default() -> Self {
39550 Self {
39551 s_type: StructureType::PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI,
39552 p_next: ::std::ptr::null_mut(),
39553 max_subpass_shading_workgroup_size_aspect_ratio: u32::default(),
39554 }
39555 }
39556}
39557impl PhysicalDeviceSubpassShadingPropertiesHUAWEI {
39558 pub fn builder<'a>() -> PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> {
39559 PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder {
39560 inner: Self::default(),
39561 marker: ::std::marker::PhantomData,
39562 }
39563 }
39564}
39565#[repr(transparent)]
39566pub struct PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> {
39567 inner: PhysicalDeviceSubpassShadingPropertiesHUAWEI,
39568 marker: ::std::marker::PhantomData<&'a ()>,
39569}
39570unsafe impl ExtendsPhysicalDeviceProperties2
39571 for PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'_>
39572{
39573}
39574unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubpassShadingPropertiesHUAWEI {}
39575impl<'a> ::std::ops::Deref for PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> {
39576 type Target = PhysicalDeviceSubpassShadingPropertiesHUAWEI;
39577 fn deref(&self) -> &Self::Target {
39578 &self.inner
39579 }
39580}
39581impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> {
39582 fn deref_mut(&mut self) -> &mut Self::Target {
39583 &mut self.inner
39584 }
39585}
39586impl<'a> PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> {
39587 pub fn max_subpass_shading_workgroup_size_aspect_ratio(
39588 mut self,
39589 max_subpass_shading_workgroup_size_aspect_ratio: u32,
39590 ) -> Self {
39591 self.inner.max_subpass_shading_workgroup_size_aspect_ratio =
39592 max_subpass_shading_workgroup_size_aspect_ratio;
39593 self
39594 }
39595 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39596 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39597 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
39598 pub fn build(self) -> PhysicalDeviceSubpassShadingPropertiesHUAWEI {
39599 self.inner
39600 }
39601}
39602#[repr(C)]
39603#[cfg_attr(feature = "debug", derive(Debug))]
39604#[derive(Copy, Clone)]
39605#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryOpaqueCaptureAddressAllocateInfo.html>"]
39606pub struct MemoryOpaqueCaptureAddressAllocateInfo {
39607 pub s_type: StructureType,
39608 pub p_next: *const c_void,
39609 pub opaque_capture_address: u64,
39610}
39611impl ::std::default::Default for MemoryOpaqueCaptureAddressAllocateInfo {
39612 fn default() -> Self {
39613 Self {
39614 s_type: StructureType::MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO,
39615 p_next: ::std::ptr::null(),
39616 opaque_capture_address: u64::default(),
39617 }
39618 }
39619}
39620impl MemoryOpaqueCaptureAddressAllocateInfo {
39621 pub fn builder<'a>() -> MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
39622 MemoryOpaqueCaptureAddressAllocateInfoBuilder {
39623 inner: Self::default(),
39624 marker: ::std::marker::PhantomData,
39625 }
39626 }
39627}
39628#[repr(transparent)]
39629pub struct MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
39630 inner: MemoryOpaqueCaptureAddressAllocateInfo,
39631 marker: ::std::marker::PhantomData<&'a ()>,
39632}
39633unsafe impl ExtendsMemoryAllocateInfo for MemoryOpaqueCaptureAddressAllocateInfoBuilder<'_> {}
39634unsafe impl ExtendsMemoryAllocateInfo for MemoryOpaqueCaptureAddressAllocateInfo {}
39635impl<'a> ::std::ops::Deref for MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
39636 type Target = MemoryOpaqueCaptureAddressAllocateInfo;
39637 fn deref(&self) -> &Self::Target {
39638 &self.inner
39639 }
39640}
39641impl<'a> ::std::ops::DerefMut for MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
39642 fn deref_mut(&mut self) -> &mut Self::Target {
39643 &mut self.inner
39644 }
39645}
39646impl<'a> MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
39647 pub fn opaque_capture_address(mut self, opaque_capture_address: u64) -> Self {
39648 self.inner.opaque_capture_address = opaque_capture_address;
39649 self
39650 }
39651 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39652 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39653 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
39654 pub fn build(self) -> MemoryOpaqueCaptureAddressAllocateInfo {
39655 self.inner
39656 }
39657}
39658#[repr(C)]
39659#[cfg_attr(feature = "debug", derive(Debug))]
39660#[derive(Copy, Clone)]
39661#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceMemoryOpaqueCaptureAddressInfo.html>"]
39662pub struct DeviceMemoryOpaqueCaptureAddressInfo {
39663 pub s_type: StructureType,
39664 pub p_next: *const c_void,
39665 pub memory: DeviceMemory,
39666}
39667impl ::std::default::Default for DeviceMemoryOpaqueCaptureAddressInfo {
39668 fn default() -> Self {
39669 Self {
39670 s_type: StructureType::DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO,
39671 p_next: ::std::ptr::null(),
39672 memory: DeviceMemory::default(),
39673 }
39674 }
39675}
39676impl DeviceMemoryOpaqueCaptureAddressInfo {
39677 pub fn builder<'a>() -> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
39678 DeviceMemoryOpaqueCaptureAddressInfoBuilder {
39679 inner: Self::default(),
39680 marker: ::std::marker::PhantomData,
39681 }
39682 }
39683}
39684#[repr(transparent)]
39685pub struct DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
39686 inner: DeviceMemoryOpaqueCaptureAddressInfo,
39687 marker: ::std::marker::PhantomData<&'a ()>,
39688}
39689impl<'a> ::std::ops::Deref for DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
39690 type Target = DeviceMemoryOpaqueCaptureAddressInfo;
39691 fn deref(&self) -> &Self::Target {
39692 &self.inner
39693 }
39694}
39695impl<'a> ::std::ops::DerefMut for DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
39696 fn deref_mut(&mut self) -> &mut Self::Target {
39697 &mut self.inner
39698 }
39699}
39700impl<'a> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
39701 pub fn memory(mut self, memory: DeviceMemory) -> Self {
39702 self.inner.memory = memory;
39703 self
39704 }
39705 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39706 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39707 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
39708 pub fn build(self) -> DeviceMemoryOpaqueCaptureAddressInfo {
39709 self.inner
39710 }
39711}
39712#[repr(C)]
39713#[cfg_attr(feature = "debug", derive(Debug))]
39714#[derive(Copy, Clone)]
39715#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceLineRasterizationFeaturesEXT.html>"]
39716pub struct PhysicalDeviceLineRasterizationFeaturesEXT {
39717 pub s_type: StructureType,
39718 pub p_next: *mut c_void,
39719 pub rectangular_lines: Bool32,
39720 pub bresenham_lines: Bool32,
39721 pub smooth_lines: Bool32,
39722 pub stippled_rectangular_lines: Bool32,
39723 pub stippled_bresenham_lines: Bool32,
39724 pub stippled_smooth_lines: Bool32,
39725}
39726impl ::std::default::Default for PhysicalDeviceLineRasterizationFeaturesEXT {
39727 fn default() -> Self {
39728 Self {
39729 s_type: StructureType::PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT,
39730 p_next: ::std::ptr::null_mut(),
39731 rectangular_lines: Bool32::default(),
39732 bresenham_lines: Bool32::default(),
39733 smooth_lines: Bool32::default(),
39734 stippled_rectangular_lines: Bool32::default(),
39735 stippled_bresenham_lines: Bool32::default(),
39736 stippled_smooth_lines: Bool32::default(),
39737 }
39738 }
39739}
39740impl PhysicalDeviceLineRasterizationFeaturesEXT {
39741 pub fn builder<'a>() -> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
39742 PhysicalDeviceLineRasterizationFeaturesEXTBuilder {
39743 inner: Self::default(),
39744 marker: ::std::marker::PhantomData,
39745 }
39746 }
39747}
39748#[repr(transparent)]
39749pub struct PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
39750 inner: PhysicalDeviceLineRasterizationFeaturesEXT,
39751 marker: ::std::marker::PhantomData<&'a ()>,
39752}
39753unsafe impl ExtendsPhysicalDeviceFeatures2
39754 for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'_>
39755{
39756}
39757unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLineRasterizationFeaturesEXT {}
39758unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'_> {}
39759unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLineRasterizationFeaturesEXT {}
39760impl<'a> ::std::ops::Deref for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
39761 type Target = PhysicalDeviceLineRasterizationFeaturesEXT;
39762 fn deref(&self) -> &Self::Target {
39763 &self.inner
39764 }
39765}
39766impl<'a> ::std::ops::DerefMut for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
39767 fn deref_mut(&mut self) -> &mut Self::Target {
39768 &mut self.inner
39769 }
39770}
39771impl<'a> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
39772 pub fn rectangular_lines(mut self, rectangular_lines: bool) -> Self {
39773 self.inner.rectangular_lines = rectangular_lines.into();
39774 self
39775 }
39776 pub fn bresenham_lines(mut self, bresenham_lines: bool) -> Self {
39777 self.inner.bresenham_lines = bresenham_lines.into();
39778 self
39779 }
39780 pub fn smooth_lines(mut self, smooth_lines: bool) -> Self {
39781 self.inner.smooth_lines = smooth_lines.into();
39782 self
39783 }
39784 pub fn stippled_rectangular_lines(mut self, stippled_rectangular_lines: bool) -> Self {
39785 self.inner.stippled_rectangular_lines = stippled_rectangular_lines.into();
39786 self
39787 }
39788 pub fn stippled_bresenham_lines(mut self, stippled_bresenham_lines: bool) -> Self {
39789 self.inner.stippled_bresenham_lines = stippled_bresenham_lines.into();
39790 self
39791 }
39792 pub fn stippled_smooth_lines(mut self, stippled_smooth_lines: bool) -> Self {
39793 self.inner.stippled_smooth_lines = stippled_smooth_lines.into();
39794 self
39795 }
39796 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39797 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39798 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
39799 pub fn build(self) -> PhysicalDeviceLineRasterizationFeaturesEXT {
39800 self.inner
39801 }
39802}
39803#[repr(C)]
39804#[cfg_attr(feature = "debug", derive(Debug))]
39805#[derive(Copy, Clone)]
39806#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceLineRasterizationPropertiesEXT.html>"]
39807pub struct PhysicalDeviceLineRasterizationPropertiesEXT {
39808 pub s_type: StructureType,
39809 pub p_next: *mut c_void,
39810 pub line_sub_pixel_precision_bits: u32,
39811}
39812impl ::std::default::Default for PhysicalDeviceLineRasterizationPropertiesEXT {
39813 fn default() -> Self {
39814 Self {
39815 s_type: StructureType::PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT,
39816 p_next: ::std::ptr::null_mut(),
39817 line_sub_pixel_precision_bits: u32::default(),
39818 }
39819 }
39820}
39821impl PhysicalDeviceLineRasterizationPropertiesEXT {
39822 pub fn builder<'a>() -> PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
39823 PhysicalDeviceLineRasterizationPropertiesEXTBuilder {
39824 inner: Self::default(),
39825 marker: ::std::marker::PhantomData,
39826 }
39827 }
39828}
39829#[repr(transparent)]
39830pub struct PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
39831 inner: PhysicalDeviceLineRasterizationPropertiesEXT,
39832 marker: ::std::marker::PhantomData<&'a ()>,
39833}
39834unsafe impl ExtendsPhysicalDeviceProperties2
39835 for PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'_>
39836{
39837}
39838unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceLineRasterizationPropertiesEXT {}
39839impl<'a> ::std::ops::Deref for PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
39840 type Target = PhysicalDeviceLineRasterizationPropertiesEXT;
39841 fn deref(&self) -> &Self::Target {
39842 &self.inner
39843 }
39844}
39845impl<'a> ::std::ops::DerefMut for PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
39846 fn deref_mut(&mut self) -> &mut Self::Target {
39847 &mut self.inner
39848 }
39849}
39850impl<'a> PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
39851 pub fn line_sub_pixel_precision_bits(mut self, line_sub_pixel_precision_bits: u32) -> Self {
39852 self.inner.line_sub_pixel_precision_bits = line_sub_pixel_precision_bits;
39853 self
39854 }
39855 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39856 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39857 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
39858 pub fn build(self) -> PhysicalDeviceLineRasterizationPropertiesEXT {
39859 self.inner
39860 }
39861}
39862#[repr(C)]
39863#[cfg_attr(feature = "debug", derive(Debug))]
39864#[derive(Copy, Clone)]
39865#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationLineStateCreateInfoEXT.html>"]
39866pub struct PipelineRasterizationLineStateCreateInfoEXT {
39867 pub s_type: StructureType,
39868 pub p_next: *const c_void,
39869 pub line_rasterization_mode: LineRasterizationModeEXT,
39870 pub stippled_line_enable: Bool32,
39871 pub line_stipple_factor: u32,
39872 pub line_stipple_pattern: u16,
39873}
39874impl ::std::default::Default for PipelineRasterizationLineStateCreateInfoEXT {
39875 fn default() -> Self {
39876 Self {
39877 s_type: StructureType::PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT,
39878 p_next: ::std::ptr::null(),
39879 line_rasterization_mode: LineRasterizationModeEXT::default(),
39880 stippled_line_enable: Bool32::default(),
39881 line_stipple_factor: u32::default(),
39882 line_stipple_pattern: u16::default(),
39883 }
39884 }
39885}
39886impl PipelineRasterizationLineStateCreateInfoEXT {
39887 pub fn builder<'a>() -> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
39888 PipelineRasterizationLineStateCreateInfoEXTBuilder {
39889 inner: Self::default(),
39890 marker: ::std::marker::PhantomData,
39891 }
39892 }
39893}
39894#[repr(transparent)]
39895pub struct PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
39896 inner: PipelineRasterizationLineStateCreateInfoEXT,
39897 marker: ::std::marker::PhantomData<&'a ()>,
39898}
39899unsafe impl ExtendsPipelineRasterizationStateCreateInfo
39900 for PipelineRasterizationLineStateCreateInfoEXTBuilder<'_>
39901{
39902}
39903unsafe impl ExtendsPipelineRasterizationStateCreateInfo
39904 for PipelineRasterizationLineStateCreateInfoEXT
39905{
39906}
39907impl<'a> ::std::ops::Deref for PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
39908 type Target = PipelineRasterizationLineStateCreateInfoEXT;
39909 fn deref(&self) -> &Self::Target {
39910 &self.inner
39911 }
39912}
39913impl<'a> ::std::ops::DerefMut for PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
39914 fn deref_mut(&mut self) -> &mut Self::Target {
39915 &mut self.inner
39916 }
39917}
39918impl<'a> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
39919 pub fn line_rasterization_mode(
39920 mut self,
39921 line_rasterization_mode: LineRasterizationModeEXT,
39922 ) -> Self {
39923 self.inner.line_rasterization_mode = line_rasterization_mode;
39924 self
39925 }
39926 pub fn stippled_line_enable(mut self, stippled_line_enable: bool) -> Self {
39927 self.inner.stippled_line_enable = stippled_line_enable.into();
39928 self
39929 }
39930 pub fn line_stipple_factor(mut self, line_stipple_factor: u32) -> Self {
39931 self.inner.line_stipple_factor = line_stipple_factor;
39932 self
39933 }
39934 pub fn line_stipple_pattern(mut self, line_stipple_pattern: u16) -> Self {
39935 self.inner.line_stipple_pattern = line_stipple_pattern;
39936 self
39937 }
39938 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39939 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39940 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
39941 pub fn build(self) -> PipelineRasterizationLineStateCreateInfoEXT {
39942 self.inner
39943 }
39944}
39945#[repr(C)]
39946#[cfg_attr(feature = "debug", derive(Debug))]
39947#[derive(Copy, Clone)]
39948#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePipelineCreationCacheControlFeatures.html>"]
39949pub struct PhysicalDevicePipelineCreationCacheControlFeatures {
39950 pub s_type: StructureType,
39951 pub p_next: *mut c_void,
39952 pub pipeline_creation_cache_control: Bool32,
39953}
39954impl ::std::default::Default for PhysicalDevicePipelineCreationCacheControlFeatures {
39955 fn default() -> Self {
39956 Self {
39957 s_type: StructureType::PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES,
39958 p_next: ::std::ptr::null_mut(),
39959 pipeline_creation_cache_control: Bool32::default(),
39960 }
39961 }
39962}
39963impl PhysicalDevicePipelineCreationCacheControlFeatures {
39964 pub fn builder<'a>() -> PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> {
39965 PhysicalDevicePipelineCreationCacheControlFeaturesBuilder {
39966 inner: Self::default(),
39967 marker: ::std::marker::PhantomData,
39968 }
39969 }
39970}
39971#[repr(transparent)]
39972pub struct PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> {
39973 inner: PhysicalDevicePipelineCreationCacheControlFeatures,
39974 marker: ::std::marker::PhantomData<&'a ()>,
39975}
39976unsafe impl ExtendsPhysicalDeviceFeatures2
39977 for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'_>
39978{
39979}
39980unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelineCreationCacheControlFeatures {}
39981unsafe impl ExtendsDeviceCreateInfo
39982 for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'_>
39983{
39984}
39985unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineCreationCacheControlFeatures {}
39986impl<'a> ::std::ops::Deref for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> {
39987 type Target = PhysicalDevicePipelineCreationCacheControlFeatures;
39988 fn deref(&self) -> &Self::Target {
39989 &self.inner
39990 }
39991}
39992impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> {
39993 fn deref_mut(&mut self) -> &mut Self::Target {
39994 &mut self.inner
39995 }
39996}
39997impl<'a> PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> {
39998 pub fn pipeline_creation_cache_control(
39999 mut self,
40000 pipeline_creation_cache_control: bool,
40001 ) -> Self {
40002 self.inner.pipeline_creation_cache_control = pipeline_creation_cache_control.into();
40003 self
40004 }
40005 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40006 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40007 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
40008 pub fn build(self) -> PhysicalDevicePipelineCreationCacheControlFeatures {
40009 self.inner
40010 }
40011}
40012#[repr(C)]
40013#[cfg_attr(feature = "debug", derive(Debug))]
40014#[derive(Copy, Clone)]
40015#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkan11Features.html>"]
40016pub struct PhysicalDeviceVulkan11Features {
40017 pub s_type: StructureType,
40018 pub p_next: *mut c_void,
40019 pub storage_buffer16_bit_access: Bool32,
40020 pub uniform_and_storage_buffer16_bit_access: Bool32,
40021 pub storage_push_constant16: Bool32,
40022 pub storage_input_output16: Bool32,
40023 pub multiview: Bool32,
40024 pub multiview_geometry_shader: Bool32,
40025 pub multiview_tessellation_shader: Bool32,
40026 pub variable_pointers_storage_buffer: Bool32,
40027 pub variable_pointers: Bool32,
40028 pub protected_memory: Bool32,
40029 pub sampler_ycbcr_conversion: Bool32,
40030 pub shader_draw_parameters: Bool32,
40031}
40032impl ::std::default::Default for PhysicalDeviceVulkan11Features {
40033 fn default() -> Self {
40034 Self {
40035 s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_1_FEATURES,
40036 p_next: ::std::ptr::null_mut(),
40037 storage_buffer16_bit_access: Bool32::default(),
40038 uniform_and_storage_buffer16_bit_access: Bool32::default(),
40039 storage_push_constant16: Bool32::default(),
40040 storage_input_output16: Bool32::default(),
40041 multiview: Bool32::default(),
40042 multiview_geometry_shader: Bool32::default(),
40043 multiview_tessellation_shader: Bool32::default(),
40044 variable_pointers_storage_buffer: Bool32::default(),
40045 variable_pointers: Bool32::default(),
40046 protected_memory: Bool32::default(),
40047 sampler_ycbcr_conversion: Bool32::default(),
40048 shader_draw_parameters: Bool32::default(),
40049 }
40050 }
40051}
40052impl PhysicalDeviceVulkan11Features {
40053 pub fn builder<'a>() -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
40054 PhysicalDeviceVulkan11FeaturesBuilder {
40055 inner: Self::default(),
40056 marker: ::std::marker::PhantomData,
40057 }
40058 }
40059}
40060#[repr(transparent)]
40061pub struct PhysicalDeviceVulkan11FeaturesBuilder<'a> {
40062 inner: PhysicalDeviceVulkan11Features,
40063 marker: ::std::marker::PhantomData<&'a ()>,
40064}
40065unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan11FeaturesBuilder<'_> {}
40066unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan11Features {}
40067unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan11FeaturesBuilder<'_> {}
40068unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan11Features {}
40069impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan11FeaturesBuilder<'a> {
40070 type Target = PhysicalDeviceVulkan11Features;
40071 fn deref(&self) -> &Self::Target {
40072 &self.inner
40073 }
40074}
40075impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan11FeaturesBuilder<'a> {
40076 fn deref_mut(&mut self) -> &mut Self::Target {
40077 &mut self.inner
40078 }
40079}
40080impl<'a> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
40081 pub fn storage_buffer16_bit_access(mut self, storage_buffer16_bit_access: bool) -> Self {
40082 self.inner.storage_buffer16_bit_access = storage_buffer16_bit_access.into();
40083 self
40084 }
40085 pub fn uniform_and_storage_buffer16_bit_access(
40086 mut self,
40087 uniform_and_storage_buffer16_bit_access: bool,
40088 ) -> Self {
40089 self.inner.uniform_and_storage_buffer16_bit_access =
40090 uniform_and_storage_buffer16_bit_access.into();
40091 self
40092 }
40093 pub fn storage_push_constant16(mut self, storage_push_constant16: bool) -> Self {
40094 self.inner.storage_push_constant16 = storage_push_constant16.into();
40095 self
40096 }
40097 pub fn storage_input_output16(mut self, storage_input_output16: bool) -> Self {
40098 self.inner.storage_input_output16 = storage_input_output16.into();
40099 self
40100 }
40101 pub fn multiview(mut self, multiview: bool) -> Self {
40102 self.inner.multiview = multiview.into();
40103 self
40104 }
40105 pub fn multiview_geometry_shader(mut self, multiview_geometry_shader: bool) -> Self {
40106 self.inner.multiview_geometry_shader = multiview_geometry_shader.into();
40107 self
40108 }
40109 pub fn multiview_tessellation_shader(mut self, multiview_tessellation_shader: bool) -> Self {
40110 self.inner.multiview_tessellation_shader = multiview_tessellation_shader.into();
40111 self
40112 }
40113 pub fn variable_pointers_storage_buffer(
40114 mut self,
40115 variable_pointers_storage_buffer: bool,
40116 ) -> Self {
40117 self.inner.variable_pointers_storage_buffer = variable_pointers_storage_buffer.into();
40118 self
40119 }
40120 pub fn variable_pointers(mut self, variable_pointers: bool) -> Self {
40121 self.inner.variable_pointers = variable_pointers.into();
40122 self
40123 }
40124 pub fn protected_memory(mut self, protected_memory: bool) -> Self {
40125 self.inner.protected_memory = protected_memory.into();
40126 self
40127 }
40128 pub fn sampler_ycbcr_conversion(mut self, sampler_ycbcr_conversion: bool) -> Self {
40129 self.inner.sampler_ycbcr_conversion = sampler_ycbcr_conversion.into();
40130 self
40131 }
40132 pub fn shader_draw_parameters(mut self, shader_draw_parameters: bool) -> Self {
40133 self.inner.shader_draw_parameters = shader_draw_parameters.into();
40134 self
40135 }
40136 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40137 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40138 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
40139 pub fn build(self) -> PhysicalDeviceVulkan11Features {
40140 self.inner
40141 }
40142}
40143#[repr(C)]
40144#[cfg_attr(feature = "debug", derive(Debug))]
40145#[derive(Copy, Clone)]
40146#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkan11Properties.html>"]
40147pub struct PhysicalDeviceVulkan11Properties {
40148 pub s_type: StructureType,
40149 pub p_next: *mut c_void,
40150 pub device_uuid: [u8; UUID_SIZE],
40151 pub driver_uuid: [u8; UUID_SIZE],
40152 pub device_luid: [u8; LUID_SIZE],
40153 pub device_node_mask: u32,
40154 pub device_luid_valid: Bool32,
40155 pub subgroup_size: u32,
40156 pub subgroup_supported_stages: ShaderStageFlags,
40157 pub subgroup_supported_operations: SubgroupFeatureFlags,
40158 pub subgroup_quad_operations_in_all_stages: Bool32,
40159 pub point_clipping_behavior: PointClippingBehavior,
40160 pub max_multiview_view_count: u32,
40161 pub max_multiview_instance_index: u32,
40162 pub protected_no_fault: Bool32,
40163 pub max_per_set_descriptors: u32,
40164 pub max_memory_allocation_size: DeviceSize,
40165}
40166impl ::std::default::Default for PhysicalDeviceVulkan11Properties {
40167 fn default() -> Self {
40168 Self {
40169 s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES,
40170 p_next: ::std::ptr::null_mut(),
40171 device_uuid: unsafe { ::std::mem::zeroed() },
40172 driver_uuid: unsafe { ::std::mem::zeroed() },
40173 device_luid: unsafe { ::std::mem::zeroed() },
40174 device_node_mask: u32::default(),
40175 device_luid_valid: Bool32::default(),
40176 subgroup_size: u32::default(),
40177 subgroup_supported_stages: ShaderStageFlags::default(),
40178 subgroup_supported_operations: SubgroupFeatureFlags::default(),
40179 subgroup_quad_operations_in_all_stages: Bool32::default(),
40180 point_clipping_behavior: PointClippingBehavior::default(),
40181 max_multiview_view_count: u32::default(),
40182 max_multiview_instance_index: u32::default(),
40183 protected_no_fault: Bool32::default(),
40184 max_per_set_descriptors: u32::default(),
40185 max_memory_allocation_size: DeviceSize::default(),
40186 }
40187 }
40188}
40189impl PhysicalDeviceVulkan11Properties {
40190 pub fn builder<'a>() -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
40191 PhysicalDeviceVulkan11PropertiesBuilder {
40192 inner: Self::default(),
40193 marker: ::std::marker::PhantomData,
40194 }
40195 }
40196}
40197#[repr(transparent)]
40198pub struct PhysicalDeviceVulkan11PropertiesBuilder<'a> {
40199 inner: PhysicalDeviceVulkan11Properties,
40200 marker: ::std::marker::PhantomData<&'a ()>,
40201}
40202unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan11PropertiesBuilder<'_> {}
40203unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan11Properties {}
40204impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan11PropertiesBuilder<'a> {
40205 type Target = PhysicalDeviceVulkan11Properties;
40206 fn deref(&self) -> &Self::Target {
40207 &self.inner
40208 }
40209}
40210impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan11PropertiesBuilder<'a> {
40211 fn deref_mut(&mut self) -> &mut Self::Target {
40212 &mut self.inner
40213 }
40214}
40215impl<'a> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
40216 pub fn device_uuid(mut self, device_uuid: [u8; UUID_SIZE]) -> Self {
40217 self.inner.device_uuid = device_uuid;
40218 self
40219 }
40220 pub fn driver_uuid(mut self, driver_uuid: [u8; UUID_SIZE]) -> Self {
40221 self.inner.driver_uuid = driver_uuid;
40222 self
40223 }
40224 pub fn device_luid(mut self, device_luid: [u8; LUID_SIZE]) -> Self {
40225 self.inner.device_luid = device_luid;
40226 self
40227 }
40228 pub fn device_node_mask(mut self, device_node_mask: u32) -> Self {
40229 self.inner.device_node_mask = device_node_mask;
40230 self
40231 }
40232 pub fn device_luid_valid(mut self, device_luid_valid: bool) -> Self {
40233 self.inner.device_luid_valid = device_luid_valid.into();
40234 self
40235 }
40236 pub fn subgroup_size(mut self, subgroup_size: u32) -> Self {
40237 self.inner.subgroup_size = subgroup_size;
40238 self
40239 }
40240 pub fn subgroup_supported_stages(
40241 mut self,
40242 subgroup_supported_stages: ShaderStageFlags,
40243 ) -> Self {
40244 self.inner.subgroup_supported_stages = subgroup_supported_stages;
40245 self
40246 }
40247 pub fn subgroup_supported_operations(
40248 mut self,
40249 subgroup_supported_operations: SubgroupFeatureFlags,
40250 ) -> Self {
40251 self.inner.subgroup_supported_operations = subgroup_supported_operations;
40252 self
40253 }
40254 pub fn subgroup_quad_operations_in_all_stages(
40255 mut self,
40256 subgroup_quad_operations_in_all_stages: bool,
40257 ) -> Self {
40258 self.inner.subgroup_quad_operations_in_all_stages =
40259 subgroup_quad_operations_in_all_stages.into();
40260 self
40261 }
40262 pub fn point_clipping_behavior(
40263 mut self,
40264 point_clipping_behavior: PointClippingBehavior,
40265 ) -> Self {
40266 self.inner.point_clipping_behavior = point_clipping_behavior;
40267 self
40268 }
40269 pub fn max_multiview_view_count(mut self, max_multiview_view_count: u32) -> Self {
40270 self.inner.max_multiview_view_count = max_multiview_view_count;
40271 self
40272 }
40273 pub fn max_multiview_instance_index(mut self, max_multiview_instance_index: u32) -> Self {
40274 self.inner.max_multiview_instance_index = max_multiview_instance_index;
40275 self
40276 }
40277 pub fn protected_no_fault(mut self, protected_no_fault: bool) -> Self {
40278 self.inner.protected_no_fault = protected_no_fault.into();
40279 self
40280 }
40281 pub fn max_per_set_descriptors(mut self, max_per_set_descriptors: u32) -> Self {
40282 self.inner.max_per_set_descriptors = max_per_set_descriptors;
40283 self
40284 }
40285 pub fn max_memory_allocation_size(mut self, max_memory_allocation_size: DeviceSize) -> Self {
40286 self.inner.max_memory_allocation_size = max_memory_allocation_size;
40287 self
40288 }
40289 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40290 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40291 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
40292 pub fn build(self) -> PhysicalDeviceVulkan11Properties {
40293 self.inner
40294 }
40295}
40296#[repr(C)]
40297#[cfg_attr(feature = "debug", derive(Debug))]
40298#[derive(Copy, Clone)]
40299#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkan12Features.html>"]
40300pub struct PhysicalDeviceVulkan12Features {
40301 pub s_type: StructureType,
40302 pub p_next: *mut c_void,
40303 pub sampler_mirror_clamp_to_edge: Bool32,
40304 pub draw_indirect_count: Bool32,
40305 pub storage_buffer8_bit_access: Bool32,
40306 pub uniform_and_storage_buffer8_bit_access: Bool32,
40307 pub storage_push_constant8: Bool32,
40308 pub shader_buffer_int64_atomics: Bool32,
40309 pub shader_shared_int64_atomics: Bool32,
40310 pub shader_float16: Bool32,
40311 pub shader_int8: Bool32,
40312 pub descriptor_indexing: Bool32,
40313 pub shader_input_attachment_array_dynamic_indexing: Bool32,
40314 pub shader_uniform_texel_buffer_array_dynamic_indexing: Bool32,
40315 pub shader_storage_texel_buffer_array_dynamic_indexing: Bool32,
40316 pub shader_uniform_buffer_array_non_uniform_indexing: Bool32,
40317 pub shader_sampled_image_array_non_uniform_indexing: Bool32,
40318 pub shader_storage_buffer_array_non_uniform_indexing: Bool32,
40319 pub shader_storage_image_array_non_uniform_indexing: Bool32,
40320 pub shader_input_attachment_array_non_uniform_indexing: Bool32,
40321 pub shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32,
40322 pub shader_storage_texel_buffer_array_non_uniform_indexing: Bool32,
40323 pub descriptor_binding_uniform_buffer_update_after_bind: Bool32,
40324 pub descriptor_binding_sampled_image_update_after_bind: Bool32,
40325 pub descriptor_binding_storage_image_update_after_bind: Bool32,
40326 pub descriptor_binding_storage_buffer_update_after_bind: Bool32,
40327 pub descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32,
40328 pub descriptor_binding_storage_texel_buffer_update_after_bind: Bool32,
40329 pub descriptor_binding_update_unused_while_pending: Bool32,
40330 pub descriptor_binding_partially_bound: Bool32,
40331 pub descriptor_binding_variable_descriptor_count: Bool32,
40332 pub runtime_descriptor_array: Bool32,
40333 pub sampler_filter_minmax: Bool32,
40334 pub scalar_block_layout: Bool32,
40335 pub imageless_framebuffer: Bool32,
40336 pub uniform_buffer_standard_layout: Bool32,
40337 pub shader_subgroup_extended_types: Bool32,
40338 pub separate_depth_stencil_layouts: Bool32,
40339 pub host_query_reset: Bool32,
40340 pub timeline_semaphore: Bool32,
40341 pub buffer_device_address: Bool32,
40342 pub buffer_device_address_capture_replay: Bool32,
40343 pub buffer_device_address_multi_device: Bool32,
40344 pub vulkan_memory_model: Bool32,
40345 pub vulkan_memory_model_device_scope: Bool32,
40346 pub vulkan_memory_model_availability_visibility_chains: Bool32,
40347 pub shader_output_viewport_index: Bool32,
40348 pub shader_output_layer: Bool32,
40349 pub subgroup_broadcast_dynamic_id: Bool32,
40350}
40351impl ::std::default::Default for PhysicalDeviceVulkan12Features {
40352 fn default() -> Self {
40353 Self {
40354 s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_2_FEATURES,
40355 p_next: ::std::ptr::null_mut(),
40356 sampler_mirror_clamp_to_edge: Bool32::default(),
40357 draw_indirect_count: Bool32::default(),
40358 storage_buffer8_bit_access: Bool32::default(),
40359 uniform_and_storage_buffer8_bit_access: Bool32::default(),
40360 storage_push_constant8: Bool32::default(),
40361 shader_buffer_int64_atomics: Bool32::default(),
40362 shader_shared_int64_atomics: Bool32::default(),
40363 shader_float16: Bool32::default(),
40364 shader_int8: Bool32::default(),
40365 descriptor_indexing: Bool32::default(),
40366 shader_input_attachment_array_dynamic_indexing: Bool32::default(),
40367 shader_uniform_texel_buffer_array_dynamic_indexing: Bool32::default(),
40368 shader_storage_texel_buffer_array_dynamic_indexing: Bool32::default(),
40369 shader_uniform_buffer_array_non_uniform_indexing: Bool32::default(),
40370 shader_sampled_image_array_non_uniform_indexing: Bool32::default(),
40371 shader_storage_buffer_array_non_uniform_indexing: Bool32::default(),
40372 shader_storage_image_array_non_uniform_indexing: Bool32::default(),
40373 shader_input_attachment_array_non_uniform_indexing: Bool32::default(),
40374 shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32::default(),
40375 shader_storage_texel_buffer_array_non_uniform_indexing: Bool32::default(),
40376 descriptor_binding_uniform_buffer_update_after_bind: Bool32::default(),
40377 descriptor_binding_sampled_image_update_after_bind: Bool32::default(),
40378 descriptor_binding_storage_image_update_after_bind: Bool32::default(),
40379 descriptor_binding_storage_buffer_update_after_bind: Bool32::default(),
40380 descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32::default(),
40381 descriptor_binding_storage_texel_buffer_update_after_bind: Bool32::default(),
40382 descriptor_binding_update_unused_while_pending: Bool32::default(),
40383 descriptor_binding_partially_bound: Bool32::default(),
40384 descriptor_binding_variable_descriptor_count: Bool32::default(),
40385 runtime_descriptor_array: Bool32::default(),
40386 sampler_filter_minmax: Bool32::default(),
40387 scalar_block_layout: Bool32::default(),
40388 imageless_framebuffer: Bool32::default(),
40389 uniform_buffer_standard_layout: Bool32::default(),
40390 shader_subgroup_extended_types: Bool32::default(),
40391 separate_depth_stencil_layouts: Bool32::default(),
40392 host_query_reset: Bool32::default(),
40393 timeline_semaphore: Bool32::default(),
40394 buffer_device_address: Bool32::default(),
40395 buffer_device_address_capture_replay: Bool32::default(),
40396 buffer_device_address_multi_device: Bool32::default(),
40397 vulkan_memory_model: Bool32::default(),
40398 vulkan_memory_model_device_scope: Bool32::default(),
40399 vulkan_memory_model_availability_visibility_chains: Bool32::default(),
40400 shader_output_viewport_index: Bool32::default(),
40401 shader_output_layer: Bool32::default(),
40402 subgroup_broadcast_dynamic_id: Bool32::default(),
40403 }
40404 }
40405}
40406impl PhysicalDeviceVulkan12Features {
40407 pub fn builder<'a>() -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
40408 PhysicalDeviceVulkan12FeaturesBuilder {
40409 inner: Self::default(),
40410 marker: ::std::marker::PhantomData,
40411 }
40412 }
40413}
40414#[repr(transparent)]
40415pub struct PhysicalDeviceVulkan12FeaturesBuilder<'a> {
40416 inner: PhysicalDeviceVulkan12Features,
40417 marker: ::std::marker::PhantomData<&'a ()>,
40418}
40419unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan12FeaturesBuilder<'_> {}
40420unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan12Features {}
40421unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan12FeaturesBuilder<'_> {}
40422unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan12Features {}
40423impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan12FeaturesBuilder<'a> {
40424 type Target = PhysicalDeviceVulkan12Features;
40425 fn deref(&self) -> &Self::Target {
40426 &self.inner
40427 }
40428}
40429impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan12FeaturesBuilder<'a> {
40430 fn deref_mut(&mut self) -> &mut Self::Target {
40431 &mut self.inner
40432 }
40433}
40434impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
40435 pub fn sampler_mirror_clamp_to_edge(mut self, sampler_mirror_clamp_to_edge: bool) -> Self {
40436 self.inner.sampler_mirror_clamp_to_edge = sampler_mirror_clamp_to_edge.into();
40437 self
40438 }
40439 pub fn draw_indirect_count(mut self, draw_indirect_count: bool) -> Self {
40440 self.inner.draw_indirect_count = draw_indirect_count.into();
40441 self
40442 }
40443 pub fn storage_buffer8_bit_access(mut self, storage_buffer8_bit_access: bool) -> Self {
40444 self.inner.storage_buffer8_bit_access = storage_buffer8_bit_access.into();
40445 self
40446 }
40447 pub fn uniform_and_storage_buffer8_bit_access(
40448 mut self,
40449 uniform_and_storage_buffer8_bit_access: bool,
40450 ) -> Self {
40451 self.inner.uniform_and_storage_buffer8_bit_access =
40452 uniform_and_storage_buffer8_bit_access.into();
40453 self
40454 }
40455 pub fn storage_push_constant8(mut self, storage_push_constant8: bool) -> Self {
40456 self.inner.storage_push_constant8 = storage_push_constant8.into();
40457 self
40458 }
40459 pub fn shader_buffer_int64_atomics(mut self, shader_buffer_int64_atomics: bool) -> Self {
40460 self.inner.shader_buffer_int64_atomics = shader_buffer_int64_atomics.into();
40461 self
40462 }
40463 pub fn shader_shared_int64_atomics(mut self, shader_shared_int64_atomics: bool) -> Self {
40464 self.inner.shader_shared_int64_atomics = shader_shared_int64_atomics.into();
40465 self
40466 }
40467 pub fn shader_float16(mut self, shader_float16: bool) -> Self {
40468 self.inner.shader_float16 = shader_float16.into();
40469 self
40470 }
40471 pub fn shader_int8(mut self, shader_int8: bool) -> Self {
40472 self.inner.shader_int8 = shader_int8.into();
40473 self
40474 }
40475 pub fn descriptor_indexing(mut self, descriptor_indexing: bool) -> Self {
40476 self.inner.descriptor_indexing = descriptor_indexing.into();
40477 self
40478 }
40479 pub fn shader_input_attachment_array_dynamic_indexing(
40480 mut self,
40481 shader_input_attachment_array_dynamic_indexing: bool,
40482 ) -> Self {
40483 self.inner.shader_input_attachment_array_dynamic_indexing =
40484 shader_input_attachment_array_dynamic_indexing.into();
40485 self
40486 }
40487 pub fn shader_uniform_texel_buffer_array_dynamic_indexing(
40488 mut self,
40489 shader_uniform_texel_buffer_array_dynamic_indexing: bool,
40490 ) -> Self {
40491 self.inner
40492 .shader_uniform_texel_buffer_array_dynamic_indexing =
40493 shader_uniform_texel_buffer_array_dynamic_indexing.into();
40494 self
40495 }
40496 pub fn shader_storage_texel_buffer_array_dynamic_indexing(
40497 mut self,
40498 shader_storage_texel_buffer_array_dynamic_indexing: bool,
40499 ) -> Self {
40500 self.inner
40501 .shader_storage_texel_buffer_array_dynamic_indexing =
40502 shader_storage_texel_buffer_array_dynamic_indexing.into();
40503 self
40504 }
40505 pub fn shader_uniform_buffer_array_non_uniform_indexing(
40506 mut self,
40507 shader_uniform_buffer_array_non_uniform_indexing: bool,
40508 ) -> Self {
40509 self.inner.shader_uniform_buffer_array_non_uniform_indexing =
40510 shader_uniform_buffer_array_non_uniform_indexing.into();
40511 self
40512 }
40513 pub fn shader_sampled_image_array_non_uniform_indexing(
40514 mut self,
40515 shader_sampled_image_array_non_uniform_indexing: bool,
40516 ) -> Self {
40517 self.inner.shader_sampled_image_array_non_uniform_indexing =
40518 shader_sampled_image_array_non_uniform_indexing.into();
40519 self
40520 }
40521 pub fn shader_storage_buffer_array_non_uniform_indexing(
40522 mut self,
40523 shader_storage_buffer_array_non_uniform_indexing: bool,
40524 ) -> Self {
40525 self.inner.shader_storage_buffer_array_non_uniform_indexing =
40526 shader_storage_buffer_array_non_uniform_indexing.into();
40527 self
40528 }
40529 pub fn shader_storage_image_array_non_uniform_indexing(
40530 mut self,
40531 shader_storage_image_array_non_uniform_indexing: bool,
40532 ) -> Self {
40533 self.inner.shader_storage_image_array_non_uniform_indexing =
40534 shader_storage_image_array_non_uniform_indexing.into();
40535 self
40536 }
40537 pub fn shader_input_attachment_array_non_uniform_indexing(
40538 mut self,
40539 shader_input_attachment_array_non_uniform_indexing: bool,
40540 ) -> Self {
40541 self.inner
40542 .shader_input_attachment_array_non_uniform_indexing =
40543 shader_input_attachment_array_non_uniform_indexing.into();
40544 self
40545 }
40546 pub fn shader_uniform_texel_buffer_array_non_uniform_indexing(
40547 mut self,
40548 shader_uniform_texel_buffer_array_non_uniform_indexing: bool,
40549 ) -> Self {
40550 self.inner
40551 .shader_uniform_texel_buffer_array_non_uniform_indexing =
40552 shader_uniform_texel_buffer_array_non_uniform_indexing.into();
40553 self
40554 }
40555 pub fn shader_storage_texel_buffer_array_non_uniform_indexing(
40556 mut self,
40557 shader_storage_texel_buffer_array_non_uniform_indexing: bool,
40558 ) -> Self {
40559 self.inner
40560 .shader_storage_texel_buffer_array_non_uniform_indexing =
40561 shader_storage_texel_buffer_array_non_uniform_indexing.into();
40562 self
40563 }
40564 pub fn descriptor_binding_uniform_buffer_update_after_bind(
40565 mut self,
40566 descriptor_binding_uniform_buffer_update_after_bind: bool,
40567 ) -> Self {
40568 self.inner
40569 .descriptor_binding_uniform_buffer_update_after_bind =
40570 descriptor_binding_uniform_buffer_update_after_bind.into();
40571 self
40572 }
40573 pub fn descriptor_binding_sampled_image_update_after_bind(
40574 mut self,
40575 descriptor_binding_sampled_image_update_after_bind: bool,
40576 ) -> Self {
40577 self.inner
40578 .descriptor_binding_sampled_image_update_after_bind =
40579 descriptor_binding_sampled_image_update_after_bind.into();
40580 self
40581 }
40582 pub fn descriptor_binding_storage_image_update_after_bind(
40583 mut self,
40584 descriptor_binding_storage_image_update_after_bind: bool,
40585 ) -> Self {
40586 self.inner
40587 .descriptor_binding_storage_image_update_after_bind =
40588 descriptor_binding_storage_image_update_after_bind.into();
40589 self
40590 }
40591 pub fn descriptor_binding_storage_buffer_update_after_bind(
40592 mut self,
40593 descriptor_binding_storage_buffer_update_after_bind: bool,
40594 ) -> Self {
40595 self.inner
40596 .descriptor_binding_storage_buffer_update_after_bind =
40597 descriptor_binding_storage_buffer_update_after_bind.into();
40598 self
40599 }
40600 pub fn descriptor_binding_uniform_texel_buffer_update_after_bind(
40601 mut self,
40602 descriptor_binding_uniform_texel_buffer_update_after_bind: bool,
40603 ) -> Self {
40604 self.inner
40605 .descriptor_binding_uniform_texel_buffer_update_after_bind =
40606 descriptor_binding_uniform_texel_buffer_update_after_bind.into();
40607 self
40608 }
40609 pub fn descriptor_binding_storage_texel_buffer_update_after_bind(
40610 mut self,
40611 descriptor_binding_storage_texel_buffer_update_after_bind: bool,
40612 ) -> Self {
40613 self.inner
40614 .descriptor_binding_storage_texel_buffer_update_after_bind =
40615 descriptor_binding_storage_texel_buffer_update_after_bind.into();
40616 self
40617 }
40618 pub fn descriptor_binding_update_unused_while_pending(
40619 mut self,
40620 descriptor_binding_update_unused_while_pending: bool,
40621 ) -> Self {
40622 self.inner.descriptor_binding_update_unused_while_pending =
40623 descriptor_binding_update_unused_while_pending.into();
40624 self
40625 }
40626 pub fn descriptor_binding_partially_bound(
40627 mut self,
40628 descriptor_binding_partially_bound: bool,
40629 ) -> Self {
40630 self.inner.descriptor_binding_partially_bound = descriptor_binding_partially_bound.into();
40631 self
40632 }
40633 pub fn descriptor_binding_variable_descriptor_count(
40634 mut self,
40635 descriptor_binding_variable_descriptor_count: bool,
40636 ) -> Self {
40637 self.inner.descriptor_binding_variable_descriptor_count =
40638 descriptor_binding_variable_descriptor_count.into();
40639 self
40640 }
40641 pub fn runtime_descriptor_array(mut self, runtime_descriptor_array: bool) -> Self {
40642 self.inner.runtime_descriptor_array = runtime_descriptor_array.into();
40643 self
40644 }
40645 pub fn sampler_filter_minmax(mut self, sampler_filter_minmax: bool) -> Self {
40646 self.inner.sampler_filter_minmax = sampler_filter_minmax.into();
40647 self
40648 }
40649 pub fn scalar_block_layout(mut self, scalar_block_layout: bool) -> Self {
40650 self.inner.scalar_block_layout = scalar_block_layout.into();
40651 self
40652 }
40653 pub fn imageless_framebuffer(mut self, imageless_framebuffer: bool) -> Self {
40654 self.inner.imageless_framebuffer = imageless_framebuffer.into();
40655 self
40656 }
40657 pub fn uniform_buffer_standard_layout(mut self, uniform_buffer_standard_layout: bool) -> Self {
40658 self.inner.uniform_buffer_standard_layout = uniform_buffer_standard_layout.into();
40659 self
40660 }
40661 pub fn shader_subgroup_extended_types(mut self, shader_subgroup_extended_types: bool) -> Self {
40662 self.inner.shader_subgroup_extended_types = shader_subgroup_extended_types.into();
40663 self
40664 }
40665 pub fn separate_depth_stencil_layouts(mut self, separate_depth_stencil_layouts: bool) -> Self {
40666 self.inner.separate_depth_stencil_layouts = separate_depth_stencil_layouts.into();
40667 self
40668 }
40669 pub fn host_query_reset(mut self, host_query_reset: bool) -> Self {
40670 self.inner.host_query_reset = host_query_reset.into();
40671 self
40672 }
40673 pub fn timeline_semaphore(mut self, timeline_semaphore: bool) -> Self {
40674 self.inner.timeline_semaphore = timeline_semaphore.into();
40675 self
40676 }
40677 pub fn buffer_device_address(mut self, buffer_device_address: bool) -> Self {
40678 self.inner.buffer_device_address = buffer_device_address.into();
40679 self
40680 }
40681 pub fn buffer_device_address_capture_replay(
40682 mut self,
40683 buffer_device_address_capture_replay: bool,
40684 ) -> Self {
40685 self.inner.buffer_device_address_capture_replay =
40686 buffer_device_address_capture_replay.into();
40687 self
40688 }
40689 pub fn buffer_device_address_multi_device(
40690 mut self,
40691 buffer_device_address_multi_device: bool,
40692 ) -> Self {
40693 self.inner.buffer_device_address_multi_device = buffer_device_address_multi_device.into();
40694 self
40695 }
40696 pub fn vulkan_memory_model(mut self, vulkan_memory_model: bool) -> Self {
40697 self.inner.vulkan_memory_model = vulkan_memory_model.into();
40698 self
40699 }
40700 pub fn vulkan_memory_model_device_scope(
40701 mut self,
40702 vulkan_memory_model_device_scope: bool,
40703 ) -> Self {
40704 self.inner.vulkan_memory_model_device_scope = vulkan_memory_model_device_scope.into();
40705 self
40706 }
40707 pub fn vulkan_memory_model_availability_visibility_chains(
40708 mut self,
40709 vulkan_memory_model_availability_visibility_chains: bool,
40710 ) -> Self {
40711 self.inner
40712 .vulkan_memory_model_availability_visibility_chains =
40713 vulkan_memory_model_availability_visibility_chains.into();
40714 self
40715 }
40716 pub fn shader_output_viewport_index(mut self, shader_output_viewport_index: bool) -> Self {
40717 self.inner.shader_output_viewport_index = shader_output_viewport_index.into();
40718 self
40719 }
40720 pub fn shader_output_layer(mut self, shader_output_layer: bool) -> Self {
40721 self.inner.shader_output_layer = shader_output_layer.into();
40722 self
40723 }
40724 pub fn subgroup_broadcast_dynamic_id(mut self, subgroup_broadcast_dynamic_id: bool) -> Self {
40725 self.inner.subgroup_broadcast_dynamic_id = subgroup_broadcast_dynamic_id.into();
40726 self
40727 }
40728 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40729 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40730 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
40731 pub fn build(self) -> PhysicalDeviceVulkan12Features {
40732 self.inner
40733 }
40734}
40735#[repr(C)]
40736#[derive(Copy, Clone)]
40737#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html>"]
40738pub struct PhysicalDeviceVulkan12Properties {
40739 pub s_type: StructureType,
40740 pub p_next: *mut c_void,
40741 pub driver_id: DriverId,
40742 pub driver_name: [c_char; MAX_DRIVER_NAME_SIZE],
40743 pub driver_info: [c_char; MAX_DRIVER_INFO_SIZE],
40744 pub conformance_version: ConformanceVersion,
40745 pub denorm_behavior_independence: ShaderFloatControlsIndependence,
40746 pub rounding_mode_independence: ShaderFloatControlsIndependence,
40747 pub shader_signed_zero_inf_nan_preserve_float16: Bool32,
40748 pub shader_signed_zero_inf_nan_preserve_float32: Bool32,
40749 pub shader_signed_zero_inf_nan_preserve_float64: Bool32,
40750 pub shader_denorm_preserve_float16: Bool32,
40751 pub shader_denorm_preserve_float32: Bool32,
40752 pub shader_denorm_preserve_float64: Bool32,
40753 pub shader_denorm_flush_to_zero_float16: Bool32,
40754 pub shader_denorm_flush_to_zero_float32: Bool32,
40755 pub shader_denorm_flush_to_zero_float64: Bool32,
40756 pub shader_rounding_mode_rte_float16: Bool32,
40757 pub shader_rounding_mode_rte_float32: Bool32,
40758 pub shader_rounding_mode_rte_float64: Bool32,
40759 pub shader_rounding_mode_rtz_float16: Bool32,
40760 pub shader_rounding_mode_rtz_float32: Bool32,
40761 pub shader_rounding_mode_rtz_float64: Bool32,
40762 pub max_update_after_bind_descriptors_in_all_pools: u32,
40763 pub shader_uniform_buffer_array_non_uniform_indexing_native: Bool32,
40764 pub shader_sampled_image_array_non_uniform_indexing_native: Bool32,
40765 pub shader_storage_buffer_array_non_uniform_indexing_native: Bool32,
40766 pub shader_storage_image_array_non_uniform_indexing_native: Bool32,
40767 pub shader_input_attachment_array_non_uniform_indexing_native: Bool32,
40768 pub robust_buffer_access_update_after_bind: Bool32,
40769 pub quad_divergent_implicit_lod: Bool32,
40770 pub max_per_stage_descriptor_update_after_bind_samplers: u32,
40771 pub max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
40772 pub max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
40773 pub max_per_stage_descriptor_update_after_bind_sampled_images: u32,
40774 pub max_per_stage_descriptor_update_after_bind_storage_images: u32,
40775 pub max_per_stage_descriptor_update_after_bind_input_attachments: u32,
40776 pub max_per_stage_update_after_bind_resources: u32,
40777 pub max_descriptor_set_update_after_bind_samplers: u32,
40778 pub max_descriptor_set_update_after_bind_uniform_buffers: u32,
40779 pub max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
40780 pub max_descriptor_set_update_after_bind_storage_buffers: u32,
40781 pub max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
40782 pub max_descriptor_set_update_after_bind_sampled_images: u32,
40783 pub max_descriptor_set_update_after_bind_storage_images: u32,
40784 pub max_descriptor_set_update_after_bind_input_attachments: u32,
40785 pub supported_depth_resolve_modes: ResolveModeFlags,
40786 pub supported_stencil_resolve_modes: ResolveModeFlags,
40787 pub independent_resolve_none: Bool32,
40788 pub independent_resolve: Bool32,
40789 pub filter_minmax_single_component_formats: Bool32,
40790 pub filter_minmax_image_component_mapping: Bool32,
40791 pub max_timeline_semaphore_value_difference: u64,
40792 pub framebuffer_integer_color_sample_counts: SampleCountFlags,
40793}
40794#[cfg(feature = "debug")]
40795impl fmt::Debug for PhysicalDeviceVulkan12Properties {
40796 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
40797 fmt.debug_struct("PhysicalDeviceVulkan12Properties")
40798 .field("s_type", &self.s_type)
40799 .field("p_next", &self.p_next)
40800 .field("driver_id", &self.driver_id)
40801 .field("driver_name", &unsafe {
40802 ::std::ffi::CStr::from_ptr(self.driver_name.as_ptr())
40803 })
40804 .field("driver_info", &unsafe {
40805 ::std::ffi::CStr::from_ptr(self.driver_info.as_ptr())
40806 })
40807 .field("conformance_version", &self.conformance_version)
40808 .field(
40809 "denorm_behavior_independence",
40810 &self.denorm_behavior_independence,
40811 )
40812 .field(
40813 "rounding_mode_independence",
40814 &self.rounding_mode_independence,
40815 )
40816 .field(
40817 "shader_signed_zero_inf_nan_preserve_float16",
40818 &self.shader_signed_zero_inf_nan_preserve_float16,
40819 )
40820 .field(
40821 "shader_signed_zero_inf_nan_preserve_float32",
40822 &self.shader_signed_zero_inf_nan_preserve_float32,
40823 )
40824 .field(
40825 "shader_signed_zero_inf_nan_preserve_float64",
40826 &self.shader_signed_zero_inf_nan_preserve_float64,
40827 )
40828 .field(
40829 "shader_denorm_preserve_float16",
40830 &self.shader_denorm_preserve_float16,
40831 )
40832 .field(
40833 "shader_denorm_preserve_float32",
40834 &self.shader_denorm_preserve_float32,
40835 )
40836 .field(
40837 "shader_denorm_preserve_float64",
40838 &self.shader_denorm_preserve_float64,
40839 )
40840 .field(
40841 "shader_denorm_flush_to_zero_float16",
40842 &self.shader_denorm_flush_to_zero_float16,
40843 )
40844 .field(
40845 "shader_denorm_flush_to_zero_float32",
40846 &self.shader_denorm_flush_to_zero_float32,
40847 )
40848 .field(
40849 "shader_denorm_flush_to_zero_float64",
40850 &self.shader_denorm_flush_to_zero_float64,
40851 )
40852 .field(
40853 "shader_rounding_mode_rte_float16",
40854 &self.shader_rounding_mode_rte_float16,
40855 )
40856 .field(
40857 "shader_rounding_mode_rte_float32",
40858 &self.shader_rounding_mode_rte_float32,
40859 )
40860 .field(
40861 "shader_rounding_mode_rte_float64",
40862 &self.shader_rounding_mode_rte_float64,
40863 )
40864 .field(
40865 "shader_rounding_mode_rtz_float16",
40866 &self.shader_rounding_mode_rtz_float16,
40867 )
40868 .field(
40869 "shader_rounding_mode_rtz_float32",
40870 &self.shader_rounding_mode_rtz_float32,
40871 )
40872 .field(
40873 "shader_rounding_mode_rtz_float64",
40874 &self.shader_rounding_mode_rtz_float64,
40875 )
40876 .field(
40877 "max_update_after_bind_descriptors_in_all_pools",
40878 &self.max_update_after_bind_descriptors_in_all_pools,
40879 )
40880 .field(
40881 "shader_uniform_buffer_array_non_uniform_indexing_native",
40882 &self.shader_uniform_buffer_array_non_uniform_indexing_native,
40883 )
40884 .field(
40885 "shader_sampled_image_array_non_uniform_indexing_native",
40886 &self.shader_sampled_image_array_non_uniform_indexing_native,
40887 )
40888 .field(
40889 "shader_storage_buffer_array_non_uniform_indexing_native",
40890 &self.shader_storage_buffer_array_non_uniform_indexing_native,
40891 )
40892 .field(
40893 "shader_storage_image_array_non_uniform_indexing_native",
40894 &self.shader_storage_image_array_non_uniform_indexing_native,
40895 )
40896 .field(
40897 "shader_input_attachment_array_non_uniform_indexing_native",
40898 &self.shader_input_attachment_array_non_uniform_indexing_native,
40899 )
40900 .field(
40901 "robust_buffer_access_update_after_bind",
40902 &self.robust_buffer_access_update_after_bind,
40903 )
40904 .field(
40905 "quad_divergent_implicit_lod",
40906 &self.quad_divergent_implicit_lod,
40907 )
40908 .field(
40909 "max_per_stage_descriptor_update_after_bind_samplers",
40910 &self.max_per_stage_descriptor_update_after_bind_samplers,
40911 )
40912 .field(
40913 "max_per_stage_descriptor_update_after_bind_uniform_buffers",
40914 &self.max_per_stage_descriptor_update_after_bind_uniform_buffers,
40915 )
40916 .field(
40917 "max_per_stage_descriptor_update_after_bind_storage_buffers",
40918 &self.max_per_stage_descriptor_update_after_bind_storage_buffers,
40919 )
40920 .field(
40921 "max_per_stage_descriptor_update_after_bind_sampled_images",
40922 &self.max_per_stage_descriptor_update_after_bind_sampled_images,
40923 )
40924 .field(
40925 "max_per_stage_descriptor_update_after_bind_storage_images",
40926 &self.max_per_stage_descriptor_update_after_bind_storage_images,
40927 )
40928 .field(
40929 "max_per_stage_descriptor_update_after_bind_input_attachments",
40930 &self.max_per_stage_descriptor_update_after_bind_input_attachments,
40931 )
40932 .field(
40933 "max_per_stage_update_after_bind_resources",
40934 &self.max_per_stage_update_after_bind_resources,
40935 )
40936 .field(
40937 "max_descriptor_set_update_after_bind_samplers",
40938 &self.max_descriptor_set_update_after_bind_samplers,
40939 )
40940 .field(
40941 "max_descriptor_set_update_after_bind_uniform_buffers",
40942 &self.max_descriptor_set_update_after_bind_uniform_buffers,
40943 )
40944 .field(
40945 "max_descriptor_set_update_after_bind_uniform_buffers_dynamic",
40946 &self.max_descriptor_set_update_after_bind_uniform_buffers_dynamic,
40947 )
40948 .field(
40949 "max_descriptor_set_update_after_bind_storage_buffers",
40950 &self.max_descriptor_set_update_after_bind_storage_buffers,
40951 )
40952 .field(
40953 "max_descriptor_set_update_after_bind_storage_buffers_dynamic",
40954 &self.max_descriptor_set_update_after_bind_storage_buffers_dynamic,
40955 )
40956 .field(
40957 "max_descriptor_set_update_after_bind_sampled_images",
40958 &self.max_descriptor_set_update_after_bind_sampled_images,
40959 )
40960 .field(
40961 "max_descriptor_set_update_after_bind_storage_images",
40962 &self.max_descriptor_set_update_after_bind_storage_images,
40963 )
40964 .field(
40965 "max_descriptor_set_update_after_bind_input_attachments",
40966 &self.max_descriptor_set_update_after_bind_input_attachments,
40967 )
40968 .field(
40969 "supported_depth_resolve_modes",
40970 &self.supported_depth_resolve_modes,
40971 )
40972 .field(
40973 "supported_stencil_resolve_modes",
40974 &self.supported_stencil_resolve_modes,
40975 )
40976 .field("independent_resolve_none", &self.independent_resolve_none)
40977 .field("independent_resolve", &self.independent_resolve)
40978 .field(
40979 "filter_minmax_single_component_formats",
40980 &self.filter_minmax_single_component_formats,
40981 )
40982 .field(
40983 "filter_minmax_image_component_mapping",
40984 &self.filter_minmax_image_component_mapping,
40985 )
40986 .field(
40987 "max_timeline_semaphore_value_difference",
40988 &self.max_timeline_semaphore_value_difference,
40989 )
40990 .field(
40991 "framebuffer_integer_color_sample_counts",
40992 &self.framebuffer_integer_color_sample_counts,
40993 )
40994 .finish()
40995 }
40996}
40997impl ::std::default::Default for PhysicalDeviceVulkan12Properties {
40998 fn default() -> Self {
40999 Self {
41000 s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES,
41001 p_next: ::std::ptr::null_mut(),
41002 driver_id: DriverId::default(),
41003 driver_name: unsafe { ::std::mem::zeroed() },
41004 driver_info: unsafe { ::std::mem::zeroed() },
41005 conformance_version: ConformanceVersion::default(),
41006 denorm_behavior_independence: ShaderFloatControlsIndependence::default(),
41007 rounding_mode_independence: ShaderFloatControlsIndependence::default(),
41008 shader_signed_zero_inf_nan_preserve_float16: Bool32::default(),
41009 shader_signed_zero_inf_nan_preserve_float32: Bool32::default(),
41010 shader_signed_zero_inf_nan_preserve_float64: Bool32::default(),
41011 shader_denorm_preserve_float16: Bool32::default(),
41012 shader_denorm_preserve_float32: Bool32::default(),
41013 shader_denorm_preserve_float64: Bool32::default(),
41014 shader_denorm_flush_to_zero_float16: Bool32::default(),
41015 shader_denorm_flush_to_zero_float32: Bool32::default(),
41016 shader_denorm_flush_to_zero_float64: Bool32::default(),
41017 shader_rounding_mode_rte_float16: Bool32::default(),
41018 shader_rounding_mode_rte_float32: Bool32::default(),
41019 shader_rounding_mode_rte_float64: Bool32::default(),
41020 shader_rounding_mode_rtz_float16: Bool32::default(),
41021 shader_rounding_mode_rtz_float32: Bool32::default(),
41022 shader_rounding_mode_rtz_float64: Bool32::default(),
41023 max_update_after_bind_descriptors_in_all_pools: u32::default(),
41024 shader_uniform_buffer_array_non_uniform_indexing_native: Bool32::default(),
41025 shader_sampled_image_array_non_uniform_indexing_native: Bool32::default(),
41026 shader_storage_buffer_array_non_uniform_indexing_native: Bool32::default(),
41027 shader_storage_image_array_non_uniform_indexing_native: Bool32::default(),
41028 shader_input_attachment_array_non_uniform_indexing_native: Bool32::default(),
41029 robust_buffer_access_update_after_bind: Bool32::default(),
41030 quad_divergent_implicit_lod: Bool32::default(),
41031 max_per_stage_descriptor_update_after_bind_samplers: u32::default(),
41032 max_per_stage_descriptor_update_after_bind_uniform_buffers: u32::default(),
41033 max_per_stage_descriptor_update_after_bind_storage_buffers: u32::default(),
41034 max_per_stage_descriptor_update_after_bind_sampled_images: u32::default(),
41035 max_per_stage_descriptor_update_after_bind_storage_images: u32::default(),
41036 max_per_stage_descriptor_update_after_bind_input_attachments: u32::default(),
41037 max_per_stage_update_after_bind_resources: u32::default(),
41038 max_descriptor_set_update_after_bind_samplers: u32::default(),
41039 max_descriptor_set_update_after_bind_uniform_buffers: u32::default(),
41040 max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32::default(),
41041 max_descriptor_set_update_after_bind_storage_buffers: u32::default(),
41042 max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32::default(),
41043 max_descriptor_set_update_after_bind_sampled_images: u32::default(),
41044 max_descriptor_set_update_after_bind_storage_images: u32::default(),
41045 max_descriptor_set_update_after_bind_input_attachments: u32::default(),
41046 supported_depth_resolve_modes: ResolveModeFlags::default(),
41047 supported_stencil_resolve_modes: ResolveModeFlags::default(),
41048 independent_resolve_none: Bool32::default(),
41049 independent_resolve: Bool32::default(),
41050 filter_minmax_single_component_formats: Bool32::default(),
41051 filter_minmax_image_component_mapping: Bool32::default(),
41052 max_timeline_semaphore_value_difference: u64::default(),
41053 framebuffer_integer_color_sample_counts: SampleCountFlags::default(),
41054 }
41055 }
41056}
41057impl PhysicalDeviceVulkan12Properties {
41058 pub fn builder<'a>() -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
41059 PhysicalDeviceVulkan12PropertiesBuilder {
41060 inner: Self::default(),
41061 marker: ::std::marker::PhantomData,
41062 }
41063 }
41064}
41065#[repr(transparent)]
41066pub struct PhysicalDeviceVulkan12PropertiesBuilder<'a> {
41067 inner: PhysicalDeviceVulkan12Properties,
41068 marker: ::std::marker::PhantomData<&'a ()>,
41069}
41070unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan12PropertiesBuilder<'_> {}
41071unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan12Properties {}
41072impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan12PropertiesBuilder<'a> {
41073 type Target = PhysicalDeviceVulkan12Properties;
41074 fn deref(&self) -> &Self::Target {
41075 &self.inner
41076 }
41077}
41078impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan12PropertiesBuilder<'a> {
41079 fn deref_mut(&mut self) -> &mut Self::Target {
41080 &mut self.inner
41081 }
41082}
41083impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
41084 pub fn driver_id(mut self, driver_id: DriverId) -> Self {
41085 self.inner.driver_id = driver_id;
41086 self
41087 }
41088 pub fn driver_name(mut self, driver_name: [c_char; MAX_DRIVER_NAME_SIZE]) -> Self {
41089 self.inner.driver_name = driver_name;
41090 self
41091 }
41092 pub fn driver_info(mut self, driver_info: [c_char; MAX_DRIVER_INFO_SIZE]) -> Self {
41093 self.inner.driver_info = driver_info;
41094 self
41095 }
41096 pub fn conformance_version(mut self, conformance_version: ConformanceVersion) -> Self {
41097 self.inner.conformance_version = conformance_version;
41098 self
41099 }
41100 pub fn denorm_behavior_independence(
41101 mut self,
41102 denorm_behavior_independence: ShaderFloatControlsIndependence,
41103 ) -> Self {
41104 self.inner.denorm_behavior_independence = denorm_behavior_independence;
41105 self
41106 }
41107 pub fn rounding_mode_independence(
41108 mut self,
41109 rounding_mode_independence: ShaderFloatControlsIndependence,
41110 ) -> Self {
41111 self.inner.rounding_mode_independence = rounding_mode_independence;
41112 self
41113 }
41114 pub fn shader_signed_zero_inf_nan_preserve_float16(
41115 mut self,
41116 shader_signed_zero_inf_nan_preserve_float16: bool,
41117 ) -> Self {
41118 self.inner.shader_signed_zero_inf_nan_preserve_float16 =
41119 shader_signed_zero_inf_nan_preserve_float16.into();
41120 self
41121 }
41122 pub fn shader_signed_zero_inf_nan_preserve_float32(
41123 mut self,
41124 shader_signed_zero_inf_nan_preserve_float32: bool,
41125 ) -> Self {
41126 self.inner.shader_signed_zero_inf_nan_preserve_float32 =
41127 shader_signed_zero_inf_nan_preserve_float32.into();
41128 self
41129 }
41130 pub fn shader_signed_zero_inf_nan_preserve_float64(
41131 mut self,
41132 shader_signed_zero_inf_nan_preserve_float64: bool,
41133 ) -> Self {
41134 self.inner.shader_signed_zero_inf_nan_preserve_float64 =
41135 shader_signed_zero_inf_nan_preserve_float64.into();
41136 self
41137 }
41138 pub fn shader_denorm_preserve_float16(mut self, shader_denorm_preserve_float16: bool) -> Self {
41139 self.inner.shader_denorm_preserve_float16 = shader_denorm_preserve_float16.into();
41140 self
41141 }
41142 pub fn shader_denorm_preserve_float32(mut self, shader_denorm_preserve_float32: bool) -> Self {
41143 self.inner.shader_denorm_preserve_float32 = shader_denorm_preserve_float32.into();
41144 self
41145 }
41146 pub fn shader_denorm_preserve_float64(mut self, shader_denorm_preserve_float64: bool) -> Self {
41147 self.inner.shader_denorm_preserve_float64 = shader_denorm_preserve_float64.into();
41148 self
41149 }
41150 pub fn shader_denorm_flush_to_zero_float16(
41151 mut self,
41152 shader_denorm_flush_to_zero_float16: bool,
41153 ) -> Self {
41154 self.inner.shader_denorm_flush_to_zero_float16 = shader_denorm_flush_to_zero_float16.into();
41155 self
41156 }
41157 pub fn shader_denorm_flush_to_zero_float32(
41158 mut self,
41159 shader_denorm_flush_to_zero_float32: bool,
41160 ) -> Self {
41161 self.inner.shader_denorm_flush_to_zero_float32 = shader_denorm_flush_to_zero_float32.into();
41162 self
41163 }
41164 pub fn shader_denorm_flush_to_zero_float64(
41165 mut self,
41166 shader_denorm_flush_to_zero_float64: bool,
41167 ) -> Self {
41168 self.inner.shader_denorm_flush_to_zero_float64 = shader_denorm_flush_to_zero_float64.into();
41169 self
41170 }
41171 pub fn shader_rounding_mode_rte_float16(
41172 mut self,
41173 shader_rounding_mode_rte_float16: bool,
41174 ) -> Self {
41175 self.inner.shader_rounding_mode_rte_float16 = shader_rounding_mode_rte_float16.into();
41176 self
41177 }
41178 pub fn shader_rounding_mode_rte_float32(
41179 mut self,
41180 shader_rounding_mode_rte_float32: bool,
41181 ) -> Self {
41182 self.inner.shader_rounding_mode_rte_float32 = shader_rounding_mode_rte_float32.into();
41183 self
41184 }
41185 pub fn shader_rounding_mode_rte_float64(
41186 mut self,
41187 shader_rounding_mode_rte_float64: bool,
41188 ) -> Self {
41189 self.inner.shader_rounding_mode_rte_float64 = shader_rounding_mode_rte_float64.into();
41190 self
41191 }
41192 pub fn shader_rounding_mode_rtz_float16(
41193 mut self,
41194 shader_rounding_mode_rtz_float16: bool,
41195 ) -> Self {
41196 self.inner.shader_rounding_mode_rtz_float16 = shader_rounding_mode_rtz_float16.into();
41197 self
41198 }
41199 pub fn shader_rounding_mode_rtz_float32(
41200 mut self,
41201 shader_rounding_mode_rtz_float32: bool,
41202 ) -> Self {
41203 self.inner.shader_rounding_mode_rtz_float32 = shader_rounding_mode_rtz_float32.into();
41204 self
41205 }
41206 pub fn shader_rounding_mode_rtz_float64(
41207 mut self,
41208 shader_rounding_mode_rtz_float64: bool,
41209 ) -> Self {
41210 self.inner.shader_rounding_mode_rtz_float64 = shader_rounding_mode_rtz_float64.into();
41211 self
41212 }
41213 pub fn max_update_after_bind_descriptors_in_all_pools(
41214 mut self,
41215 max_update_after_bind_descriptors_in_all_pools: u32,
41216 ) -> Self {
41217 self.inner.max_update_after_bind_descriptors_in_all_pools =
41218 max_update_after_bind_descriptors_in_all_pools;
41219 self
41220 }
41221 pub fn shader_uniform_buffer_array_non_uniform_indexing_native(
41222 mut self,
41223 shader_uniform_buffer_array_non_uniform_indexing_native: bool,
41224 ) -> Self {
41225 self.inner
41226 .shader_uniform_buffer_array_non_uniform_indexing_native =
41227 shader_uniform_buffer_array_non_uniform_indexing_native.into();
41228 self
41229 }
41230 pub fn shader_sampled_image_array_non_uniform_indexing_native(
41231 mut self,
41232 shader_sampled_image_array_non_uniform_indexing_native: bool,
41233 ) -> Self {
41234 self.inner
41235 .shader_sampled_image_array_non_uniform_indexing_native =
41236 shader_sampled_image_array_non_uniform_indexing_native.into();
41237 self
41238 }
41239 pub fn shader_storage_buffer_array_non_uniform_indexing_native(
41240 mut self,
41241 shader_storage_buffer_array_non_uniform_indexing_native: bool,
41242 ) -> Self {
41243 self.inner
41244 .shader_storage_buffer_array_non_uniform_indexing_native =
41245 shader_storage_buffer_array_non_uniform_indexing_native.into();
41246 self
41247 }
41248 pub fn shader_storage_image_array_non_uniform_indexing_native(
41249 mut self,
41250 shader_storage_image_array_non_uniform_indexing_native: bool,
41251 ) -> Self {
41252 self.inner
41253 .shader_storage_image_array_non_uniform_indexing_native =
41254 shader_storage_image_array_non_uniform_indexing_native.into();
41255 self
41256 }
41257 pub fn shader_input_attachment_array_non_uniform_indexing_native(
41258 mut self,
41259 shader_input_attachment_array_non_uniform_indexing_native: bool,
41260 ) -> Self {
41261 self.inner
41262 .shader_input_attachment_array_non_uniform_indexing_native =
41263 shader_input_attachment_array_non_uniform_indexing_native.into();
41264 self
41265 }
41266 pub fn robust_buffer_access_update_after_bind(
41267 mut self,
41268 robust_buffer_access_update_after_bind: bool,
41269 ) -> Self {
41270 self.inner.robust_buffer_access_update_after_bind =
41271 robust_buffer_access_update_after_bind.into();
41272 self
41273 }
41274 pub fn quad_divergent_implicit_lod(mut self, quad_divergent_implicit_lod: bool) -> Self {
41275 self.inner.quad_divergent_implicit_lod = quad_divergent_implicit_lod.into();
41276 self
41277 }
41278 pub fn max_per_stage_descriptor_update_after_bind_samplers(
41279 mut self,
41280 max_per_stage_descriptor_update_after_bind_samplers: u32,
41281 ) -> Self {
41282 self.inner
41283 .max_per_stage_descriptor_update_after_bind_samplers =
41284 max_per_stage_descriptor_update_after_bind_samplers;
41285 self
41286 }
41287 pub fn max_per_stage_descriptor_update_after_bind_uniform_buffers(
41288 mut self,
41289 max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
41290 ) -> Self {
41291 self.inner
41292 .max_per_stage_descriptor_update_after_bind_uniform_buffers =
41293 max_per_stage_descriptor_update_after_bind_uniform_buffers;
41294 self
41295 }
41296 pub fn max_per_stage_descriptor_update_after_bind_storage_buffers(
41297 mut self,
41298 max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
41299 ) -> Self {
41300 self.inner
41301 .max_per_stage_descriptor_update_after_bind_storage_buffers =
41302 max_per_stage_descriptor_update_after_bind_storage_buffers;
41303 self
41304 }
41305 pub fn max_per_stage_descriptor_update_after_bind_sampled_images(
41306 mut self,
41307 max_per_stage_descriptor_update_after_bind_sampled_images: u32,
41308 ) -> Self {
41309 self.inner
41310 .max_per_stage_descriptor_update_after_bind_sampled_images =
41311 max_per_stage_descriptor_update_after_bind_sampled_images;
41312 self
41313 }
41314 pub fn max_per_stage_descriptor_update_after_bind_storage_images(
41315 mut self,
41316 max_per_stage_descriptor_update_after_bind_storage_images: u32,
41317 ) -> Self {
41318 self.inner
41319 .max_per_stage_descriptor_update_after_bind_storage_images =
41320 max_per_stage_descriptor_update_after_bind_storage_images;
41321 self
41322 }
41323 pub fn max_per_stage_descriptor_update_after_bind_input_attachments(
41324 mut self,
41325 max_per_stage_descriptor_update_after_bind_input_attachments: u32,
41326 ) -> Self {
41327 self.inner
41328 .max_per_stage_descriptor_update_after_bind_input_attachments =
41329 max_per_stage_descriptor_update_after_bind_input_attachments;
41330 self
41331 }
41332 pub fn max_per_stage_update_after_bind_resources(
41333 mut self,
41334 max_per_stage_update_after_bind_resources: u32,
41335 ) -> Self {
41336 self.inner.max_per_stage_update_after_bind_resources =
41337 max_per_stage_update_after_bind_resources;
41338 self
41339 }
41340 pub fn max_descriptor_set_update_after_bind_samplers(
41341 mut self,
41342 max_descriptor_set_update_after_bind_samplers: u32,
41343 ) -> Self {
41344 self.inner.max_descriptor_set_update_after_bind_samplers =
41345 max_descriptor_set_update_after_bind_samplers;
41346 self
41347 }
41348 pub fn max_descriptor_set_update_after_bind_uniform_buffers(
41349 mut self,
41350 max_descriptor_set_update_after_bind_uniform_buffers: u32,
41351 ) -> Self {
41352 self.inner
41353 .max_descriptor_set_update_after_bind_uniform_buffers =
41354 max_descriptor_set_update_after_bind_uniform_buffers;
41355 self
41356 }
41357 pub fn max_descriptor_set_update_after_bind_uniform_buffers_dynamic(
41358 mut self,
41359 max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
41360 ) -> Self {
41361 self.inner
41362 .max_descriptor_set_update_after_bind_uniform_buffers_dynamic =
41363 max_descriptor_set_update_after_bind_uniform_buffers_dynamic;
41364 self
41365 }
41366 pub fn max_descriptor_set_update_after_bind_storage_buffers(
41367 mut self,
41368 max_descriptor_set_update_after_bind_storage_buffers: u32,
41369 ) -> Self {
41370 self.inner
41371 .max_descriptor_set_update_after_bind_storage_buffers =
41372 max_descriptor_set_update_after_bind_storage_buffers;
41373 self
41374 }
41375 pub fn max_descriptor_set_update_after_bind_storage_buffers_dynamic(
41376 mut self,
41377 max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
41378 ) -> Self {
41379 self.inner
41380 .max_descriptor_set_update_after_bind_storage_buffers_dynamic =
41381 max_descriptor_set_update_after_bind_storage_buffers_dynamic;
41382 self
41383 }
41384 pub fn max_descriptor_set_update_after_bind_sampled_images(
41385 mut self,
41386 max_descriptor_set_update_after_bind_sampled_images: u32,
41387 ) -> Self {
41388 self.inner
41389 .max_descriptor_set_update_after_bind_sampled_images =
41390 max_descriptor_set_update_after_bind_sampled_images;
41391 self
41392 }
41393 pub fn max_descriptor_set_update_after_bind_storage_images(
41394 mut self,
41395 max_descriptor_set_update_after_bind_storage_images: u32,
41396 ) -> Self {
41397 self.inner
41398 .max_descriptor_set_update_after_bind_storage_images =
41399 max_descriptor_set_update_after_bind_storage_images;
41400 self
41401 }
41402 pub fn max_descriptor_set_update_after_bind_input_attachments(
41403 mut self,
41404 max_descriptor_set_update_after_bind_input_attachments: u32,
41405 ) -> Self {
41406 self.inner
41407 .max_descriptor_set_update_after_bind_input_attachments =
41408 max_descriptor_set_update_after_bind_input_attachments;
41409 self
41410 }
41411 pub fn supported_depth_resolve_modes(
41412 mut self,
41413 supported_depth_resolve_modes: ResolveModeFlags,
41414 ) -> Self {
41415 self.inner.supported_depth_resolve_modes = supported_depth_resolve_modes;
41416 self
41417 }
41418 pub fn supported_stencil_resolve_modes(
41419 mut self,
41420 supported_stencil_resolve_modes: ResolveModeFlags,
41421 ) -> Self {
41422 self.inner.supported_stencil_resolve_modes = supported_stencil_resolve_modes;
41423 self
41424 }
41425 pub fn independent_resolve_none(mut self, independent_resolve_none: bool) -> Self {
41426 self.inner.independent_resolve_none = independent_resolve_none.into();
41427 self
41428 }
41429 pub fn independent_resolve(mut self, independent_resolve: bool) -> Self {
41430 self.inner.independent_resolve = independent_resolve.into();
41431 self
41432 }
41433 pub fn filter_minmax_single_component_formats(
41434 mut self,
41435 filter_minmax_single_component_formats: bool,
41436 ) -> Self {
41437 self.inner.filter_minmax_single_component_formats =
41438 filter_minmax_single_component_formats.into();
41439 self
41440 }
41441 pub fn filter_minmax_image_component_mapping(
41442 mut self,
41443 filter_minmax_image_component_mapping: bool,
41444 ) -> Self {
41445 self.inner.filter_minmax_image_component_mapping =
41446 filter_minmax_image_component_mapping.into();
41447 self
41448 }
41449 pub fn max_timeline_semaphore_value_difference(
41450 mut self,
41451 max_timeline_semaphore_value_difference: u64,
41452 ) -> Self {
41453 self.inner.max_timeline_semaphore_value_difference =
41454 max_timeline_semaphore_value_difference;
41455 self
41456 }
41457 pub fn framebuffer_integer_color_sample_counts(
41458 mut self,
41459 framebuffer_integer_color_sample_counts: SampleCountFlags,
41460 ) -> Self {
41461 self.inner.framebuffer_integer_color_sample_counts =
41462 framebuffer_integer_color_sample_counts;
41463 self
41464 }
41465 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
41466 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
41467 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
41468 pub fn build(self) -> PhysicalDeviceVulkan12Properties {
41469 self.inner
41470 }
41471}
41472#[repr(C)]
41473#[cfg_attr(feature = "debug", derive(Debug))]
41474#[derive(Copy, Clone)]
41475#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkan13Features.html>"]
41476pub struct PhysicalDeviceVulkan13Features {
41477 pub s_type: StructureType,
41478 pub p_next: *mut c_void,
41479 pub robust_image_access: Bool32,
41480 pub inline_uniform_block: Bool32,
41481 pub descriptor_binding_inline_uniform_block_update_after_bind: Bool32,
41482 pub pipeline_creation_cache_control: Bool32,
41483 pub private_data: Bool32,
41484 pub shader_demote_to_helper_invocation: Bool32,
41485 pub shader_terminate_invocation: Bool32,
41486 pub subgroup_size_control: Bool32,
41487 pub compute_full_subgroups: Bool32,
41488 pub synchronization2: Bool32,
41489 pub texture_compression_astc_hdr: Bool32,
41490 pub shader_zero_initialize_workgroup_memory: Bool32,
41491 pub dynamic_rendering: Bool32,
41492 pub shader_integer_dot_product: Bool32,
41493 pub maintenance4: Bool32,
41494}
41495impl ::std::default::Default for PhysicalDeviceVulkan13Features {
41496 fn default() -> Self {
41497 Self {
41498 s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_3_FEATURES,
41499 p_next: ::std::ptr::null_mut(),
41500 robust_image_access: Bool32::default(),
41501 inline_uniform_block: Bool32::default(),
41502 descriptor_binding_inline_uniform_block_update_after_bind: Bool32::default(),
41503 pipeline_creation_cache_control: Bool32::default(),
41504 private_data: Bool32::default(),
41505 shader_demote_to_helper_invocation: Bool32::default(),
41506 shader_terminate_invocation: Bool32::default(),
41507 subgroup_size_control: Bool32::default(),
41508 compute_full_subgroups: Bool32::default(),
41509 synchronization2: Bool32::default(),
41510 texture_compression_astc_hdr: Bool32::default(),
41511 shader_zero_initialize_workgroup_memory: Bool32::default(),
41512 dynamic_rendering: Bool32::default(),
41513 shader_integer_dot_product: Bool32::default(),
41514 maintenance4: Bool32::default(),
41515 }
41516 }
41517}
41518impl PhysicalDeviceVulkan13Features {
41519 pub fn builder<'a>() -> PhysicalDeviceVulkan13FeaturesBuilder<'a> {
41520 PhysicalDeviceVulkan13FeaturesBuilder {
41521 inner: Self::default(),
41522 marker: ::std::marker::PhantomData,
41523 }
41524 }
41525}
41526#[repr(transparent)]
41527pub struct PhysicalDeviceVulkan13FeaturesBuilder<'a> {
41528 inner: PhysicalDeviceVulkan13Features,
41529 marker: ::std::marker::PhantomData<&'a ()>,
41530}
41531unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan13FeaturesBuilder<'_> {}
41532unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan13Features {}
41533unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan13FeaturesBuilder<'_> {}
41534unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan13Features {}
41535impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan13FeaturesBuilder<'a> {
41536 type Target = PhysicalDeviceVulkan13Features;
41537 fn deref(&self) -> &Self::Target {
41538 &self.inner
41539 }
41540}
41541impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan13FeaturesBuilder<'a> {
41542 fn deref_mut(&mut self) -> &mut Self::Target {
41543 &mut self.inner
41544 }
41545}
41546impl<'a> PhysicalDeviceVulkan13FeaturesBuilder<'a> {
41547 pub fn robust_image_access(mut self, robust_image_access: bool) -> Self {
41548 self.inner.robust_image_access = robust_image_access.into();
41549 self
41550 }
41551 pub fn inline_uniform_block(mut self, inline_uniform_block: bool) -> Self {
41552 self.inner.inline_uniform_block = inline_uniform_block.into();
41553 self
41554 }
41555 pub fn descriptor_binding_inline_uniform_block_update_after_bind(
41556 mut self,
41557 descriptor_binding_inline_uniform_block_update_after_bind: bool,
41558 ) -> Self {
41559 self.inner
41560 .descriptor_binding_inline_uniform_block_update_after_bind =
41561 descriptor_binding_inline_uniform_block_update_after_bind.into();
41562 self
41563 }
41564 pub fn pipeline_creation_cache_control(
41565 mut self,
41566 pipeline_creation_cache_control: bool,
41567 ) -> Self {
41568 self.inner.pipeline_creation_cache_control = pipeline_creation_cache_control.into();
41569 self
41570 }
41571 pub fn private_data(mut self, private_data: bool) -> Self {
41572 self.inner.private_data = private_data.into();
41573 self
41574 }
41575 pub fn shader_demote_to_helper_invocation(
41576 mut self,
41577 shader_demote_to_helper_invocation: bool,
41578 ) -> Self {
41579 self.inner.shader_demote_to_helper_invocation = shader_demote_to_helper_invocation.into();
41580 self
41581 }
41582 pub fn shader_terminate_invocation(mut self, shader_terminate_invocation: bool) -> Self {
41583 self.inner.shader_terminate_invocation = shader_terminate_invocation.into();
41584 self
41585 }
41586 pub fn subgroup_size_control(mut self, subgroup_size_control: bool) -> Self {
41587 self.inner.subgroup_size_control = subgroup_size_control.into();
41588 self
41589 }
41590 pub fn compute_full_subgroups(mut self, compute_full_subgroups: bool) -> Self {
41591 self.inner.compute_full_subgroups = compute_full_subgroups.into();
41592 self
41593 }
41594 pub fn synchronization2(mut self, synchronization2: bool) -> Self {
41595 self.inner.synchronization2 = synchronization2.into();
41596 self
41597 }
41598 pub fn texture_compression_astc_hdr(mut self, texture_compression_astc_hdr: bool) -> Self {
41599 self.inner.texture_compression_astc_hdr = texture_compression_astc_hdr.into();
41600 self
41601 }
41602 pub fn shader_zero_initialize_workgroup_memory(
41603 mut self,
41604 shader_zero_initialize_workgroup_memory: bool,
41605 ) -> Self {
41606 self.inner.shader_zero_initialize_workgroup_memory =
41607 shader_zero_initialize_workgroup_memory.into();
41608 self
41609 }
41610 pub fn dynamic_rendering(mut self, dynamic_rendering: bool) -> Self {
41611 self.inner.dynamic_rendering = dynamic_rendering.into();
41612 self
41613 }
41614 pub fn shader_integer_dot_product(mut self, shader_integer_dot_product: bool) -> Self {
41615 self.inner.shader_integer_dot_product = shader_integer_dot_product.into();
41616 self
41617 }
41618 pub fn maintenance4(mut self, maintenance4: bool) -> Self {
41619 self.inner.maintenance4 = maintenance4.into();
41620 self
41621 }
41622 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
41623 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
41624 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
41625 pub fn build(self) -> PhysicalDeviceVulkan13Features {
41626 self.inner
41627 }
41628}
41629#[repr(C)]
41630#[cfg_attr(feature = "debug", derive(Debug))]
41631#[derive(Copy, Clone)]
41632#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkan13Properties.html>"]
41633pub struct PhysicalDeviceVulkan13Properties {
41634 pub s_type: StructureType,
41635 pub p_next: *mut c_void,
41636 pub min_subgroup_size: u32,
41637 pub max_subgroup_size: u32,
41638 pub max_compute_workgroup_subgroups: u32,
41639 pub required_subgroup_size_stages: ShaderStageFlags,
41640 pub max_inline_uniform_block_size: u32,
41641 pub max_per_stage_descriptor_inline_uniform_blocks: u32,
41642 pub max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32,
41643 pub max_descriptor_set_inline_uniform_blocks: u32,
41644 pub max_descriptor_set_update_after_bind_inline_uniform_blocks: u32,
41645 pub max_inline_uniform_total_size: u32,
41646 pub integer_dot_product8_bit_unsigned_accelerated: Bool32,
41647 pub integer_dot_product8_bit_signed_accelerated: Bool32,
41648 pub integer_dot_product8_bit_mixed_signedness_accelerated: Bool32,
41649 pub integer_dot_product4x8_bit_packed_unsigned_accelerated: Bool32,
41650 pub integer_dot_product4x8_bit_packed_signed_accelerated: Bool32,
41651 pub integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: Bool32,
41652 pub integer_dot_product16_bit_unsigned_accelerated: Bool32,
41653 pub integer_dot_product16_bit_signed_accelerated: Bool32,
41654 pub integer_dot_product16_bit_mixed_signedness_accelerated: Bool32,
41655 pub integer_dot_product32_bit_unsigned_accelerated: Bool32,
41656 pub integer_dot_product32_bit_signed_accelerated: Bool32,
41657 pub integer_dot_product32_bit_mixed_signedness_accelerated: Bool32,
41658 pub integer_dot_product64_bit_unsigned_accelerated: Bool32,
41659 pub integer_dot_product64_bit_signed_accelerated: Bool32,
41660 pub integer_dot_product64_bit_mixed_signedness_accelerated: Bool32,
41661 pub integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: Bool32,
41662 pub integer_dot_product_accumulating_saturating8_bit_signed_accelerated: Bool32,
41663 pub integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: Bool32,
41664 pub integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: Bool32,
41665 pub integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: Bool32,
41666 pub integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated:
41667 Bool32,
41668 pub integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: Bool32,
41669 pub integer_dot_product_accumulating_saturating16_bit_signed_accelerated: Bool32,
41670 pub integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: Bool32,
41671 pub integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: Bool32,
41672 pub integer_dot_product_accumulating_saturating32_bit_signed_accelerated: Bool32,
41673 pub integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: Bool32,
41674 pub integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: Bool32,
41675 pub integer_dot_product_accumulating_saturating64_bit_signed_accelerated: Bool32,
41676 pub integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: Bool32,
41677 pub storage_texel_buffer_offset_alignment_bytes: DeviceSize,
41678 pub storage_texel_buffer_offset_single_texel_alignment: Bool32,
41679 pub uniform_texel_buffer_offset_alignment_bytes: DeviceSize,
41680 pub uniform_texel_buffer_offset_single_texel_alignment: Bool32,
41681 pub max_buffer_size: DeviceSize,
41682}
41683impl ::std::default::Default for PhysicalDeviceVulkan13Properties {
41684 fn default() -> Self {
41685 Self { s_type : StructureType :: PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES , 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 () }
41686 }
41687}
41688impl PhysicalDeviceVulkan13Properties {
41689 pub fn builder<'a>() -> PhysicalDeviceVulkan13PropertiesBuilder<'a> {
41690 PhysicalDeviceVulkan13PropertiesBuilder {
41691 inner: Self::default(),
41692 marker: ::std::marker::PhantomData,
41693 }
41694 }
41695}
41696#[repr(transparent)]
41697pub struct PhysicalDeviceVulkan13PropertiesBuilder<'a> {
41698 inner: PhysicalDeviceVulkan13Properties,
41699 marker: ::std::marker::PhantomData<&'a ()>,
41700}
41701unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan13PropertiesBuilder<'_> {}
41702unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan13Properties {}
41703impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan13PropertiesBuilder<'a> {
41704 type Target = PhysicalDeviceVulkan13Properties;
41705 fn deref(&self) -> &Self::Target {
41706 &self.inner
41707 }
41708}
41709impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan13PropertiesBuilder<'a> {
41710 fn deref_mut(&mut self) -> &mut Self::Target {
41711 &mut self.inner
41712 }
41713}
41714impl<'a> PhysicalDeviceVulkan13PropertiesBuilder<'a> {
41715 pub fn min_subgroup_size(mut self, min_subgroup_size: u32) -> Self {
41716 self.inner.min_subgroup_size = min_subgroup_size;
41717 self
41718 }
41719 pub fn max_subgroup_size(mut self, max_subgroup_size: u32) -> Self {
41720 self.inner.max_subgroup_size = max_subgroup_size;
41721 self
41722 }
41723 pub fn max_compute_workgroup_subgroups(mut self, max_compute_workgroup_subgroups: u32) -> Self {
41724 self.inner.max_compute_workgroup_subgroups = max_compute_workgroup_subgroups;
41725 self
41726 }
41727 pub fn required_subgroup_size_stages(
41728 mut self,
41729 required_subgroup_size_stages: ShaderStageFlags,
41730 ) -> Self {
41731 self.inner.required_subgroup_size_stages = required_subgroup_size_stages;
41732 self
41733 }
41734 pub fn max_inline_uniform_block_size(mut self, max_inline_uniform_block_size: u32) -> Self {
41735 self.inner.max_inline_uniform_block_size = max_inline_uniform_block_size;
41736 self
41737 }
41738 pub fn max_per_stage_descriptor_inline_uniform_blocks(
41739 mut self,
41740 max_per_stage_descriptor_inline_uniform_blocks: u32,
41741 ) -> Self {
41742 self.inner.max_per_stage_descriptor_inline_uniform_blocks =
41743 max_per_stage_descriptor_inline_uniform_blocks;
41744 self
41745 }
41746 pub fn max_per_stage_descriptor_update_after_bind_inline_uniform_blocks(
41747 mut self,
41748 max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32,
41749 ) -> Self {
41750 self.inner
41751 .max_per_stage_descriptor_update_after_bind_inline_uniform_blocks =
41752 max_per_stage_descriptor_update_after_bind_inline_uniform_blocks;
41753 self
41754 }
41755 pub fn max_descriptor_set_inline_uniform_blocks(
41756 mut self,
41757 max_descriptor_set_inline_uniform_blocks: u32,
41758 ) -> Self {
41759 self.inner.max_descriptor_set_inline_uniform_blocks =
41760 max_descriptor_set_inline_uniform_blocks;
41761 self
41762 }
41763 pub fn max_descriptor_set_update_after_bind_inline_uniform_blocks(
41764 mut self,
41765 max_descriptor_set_update_after_bind_inline_uniform_blocks: u32,
41766 ) -> Self {
41767 self.inner
41768 .max_descriptor_set_update_after_bind_inline_uniform_blocks =
41769 max_descriptor_set_update_after_bind_inline_uniform_blocks;
41770 self
41771 }
41772 pub fn max_inline_uniform_total_size(mut self, max_inline_uniform_total_size: u32) -> Self {
41773 self.inner.max_inline_uniform_total_size = max_inline_uniform_total_size;
41774 self
41775 }
41776 pub fn integer_dot_product8_bit_unsigned_accelerated(
41777 mut self,
41778 integer_dot_product8_bit_unsigned_accelerated: bool,
41779 ) -> Self {
41780 self.inner.integer_dot_product8_bit_unsigned_accelerated =
41781 integer_dot_product8_bit_unsigned_accelerated.into();
41782 self
41783 }
41784 pub fn integer_dot_product8_bit_signed_accelerated(
41785 mut self,
41786 integer_dot_product8_bit_signed_accelerated: bool,
41787 ) -> Self {
41788 self.inner.integer_dot_product8_bit_signed_accelerated =
41789 integer_dot_product8_bit_signed_accelerated.into();
41790 self
41791 }
41792 pub fn integer_dot_product8_bit_mixed_signedness_accelerated(
41793 mut self,
41794 integer_dot_product8_bit_mixed_signedness_accelerated: bool,
41795 ) -> Self {
41796 self.inner
41797 .integer_dot_product8_bit_mixed_signedness_accelerated =
41798 integer_dot_product8_bit_mixed_signedness_accelerated.into();
41799 self
41800 }
41801 pub fn integer_dot_product4x8_bit_packed_unsigned_accelerated(
41802 mut self,
41803 integer_dot_product4x8_bit_packed_unsigned_accelerated: bool,
41804 ) -> Self {
41805 self.inner
41806 .integer_dot_product4x8_bit_packed_unsigned_accelerated =
41807 integer_dot_product4x8_bit_packed_unsigned_accelerated.into();
41808 self
41809 }
41810 pub fn integer_dot_product4x8_bit_packed_signed_accelerated(
41811 mut self,
41812 integer_dot_product4x8_bit_packed_signed_accelerated: bool,
41813 ) -> Self {
41814 self.inner
41815 .integer_dot_product4x8_bit_packed_signed_accelerated =
41816 integer_dot_product4x8_bit_packed_signed_accelerated.into();
41817 self
41818 }
41819 pub fn integer_dot_product4x8_bit_packed_mixed_signedness_accelerated(
41820 mut self,
41821 integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: bool,
41822 ) -> Self {
41823 self.inner
41824 .integer_dot_product4x8_bit_packed_mixed_signedness_accelerated =
41825 integer_dot_product4x8_bit_packed_mixed_signedness_accelerated.into();
41826 self
41827 }
41828 pub fn integer_dot_product16_bit_unsigned_accelerated(
41829 mut self,
41830 integer_dot_product16_bit_unsigned_accelerated: bool,
41831 ) -> Self {
41832 self.inner.integer_dot_product16_bit_unsigned_accelerated =
41833 integer_dot_product16_bit_unsigned_accelerated.into();
41834 self
41835 }
41836 pub fn integer_dot_product16_bit_signed_accelerated(
41837 mut self,
41838 integer_dot_product16_bit_signed_accelerated: bool,
41839 ) -> Self {
41840 self.inner.integer_dot_product16_bit_signed_accelerated =
41841 integer_dot_product16_bit_signed_accelerated.into();
41842 self
41843 }
41844 pub fn integer_dot_product16_bit_mixed_signedness_accelerated(
41845 mut self,
41846 integer_dot_product16_bit_mixed_signedness_accelerated: bool,
41847 ) -> Self {
41848 self.inner
41849 .integer_dot_product16_bit_mixed_signedness_accelerated =
41850 integer_dot_product16_bit_mixed_signedness_accelerated.into();
41851 self
41852 }
41853 pub fn integer_dot_product32_bit_unsigned_accelerated(
41854 mut self,
41855 integer_dot_product32_bit_unsigned_accelerated: bool,
41856 ) -> Self {
41857 self.inner.integer_dot_product32_bit_unsigned_accelerated =
41858 integer_dot_product32_bit_unsigned_accelerated.into();
41859 self
41860 }
41861 pub fn integer_dot_product32_bit_signed_accelerated(
41862 mut self,
41863 integer_dot_product32_bit_signed_accelerated: bool,
41864 ) -> Self {
41865 self.inner.integer_dot_product32_bit_signed_accelerated =
41866 integer_dot_product32_bit_signed_accelerated.into();
41867 self
41868 }
41869 pub fn integer_dot_product32_bit_mixed_signedness_accelerated(
41870 mut self,
41871 integer_dot_product32_bit_mixed_signedness_accelerated: bool,
41872 ) -> Self {
41873 self.inner
41874 .integer_dot_product32_bit_mixed_signedness_accelerated =
41875 integer_dot_product32_bit_mixed_signedness_accelerated.into();
41876 self
41877 }
41878 pub fn integer_dot_product64_bit_unsigned_accelerated(
41879 mut self,
41880 integer_dot_product64_bit_unsigned_accelerated: bool,
41881 ) -> Self {
41882 self.inner.integer_dot_product64_bit_unsigned_accelerated =
41883 integer_dot_product64_bit_unsigned_accelerated.into();
41884 self
41885 }
41886 pub fn integer_dot_product64_bit_signed_accelerated(
41887 mut self,
41888 integer_dot_product64_bit_signed_accelerated: bool,
41889 ) -> Self {
41890 self.inner.integer_dot_product64_bit_signed_accelerated =
41891 integer_dot_product64_bit_signed_accelerated.into();
41892 self
41893 }
41894 pub fn integer_dot_product64_bit_mixed_signedness_accelerated(
41895 mut self,
41896 integer_dot_product64_bit_mixed_signedness_accelerated: bool,
41897 ) -> Self {
41898 self.inner
41899 .integer_dot_product64_bit_mixed_signedness_accelerated =
41900 integer_dot_product64_bit_mixed_signedness_accelerated.into();
41901 self
41902 }
41903 pub fn integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated(
41904 mut self,
41905 integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: bool,
41906 ) -> Self {
41907 self.inner
41908 .integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated =
41909 integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated.into();
41910 self
41911 }
41912 pub fn integer_dot_product_accumulating_saturating8_bit_signed_accelerated(
41913 mut self,
41914 integer_dot_product_accumulating_saturating8_bit_signed_accelerated: bool,
41915 ) -> Self {
41916 self.inner
41917 .integer_dot_product_accumulating_saturating8_bit_signed_accelerated =
41918 integer_dot_product_accumulating_saturating8_bit_signed_accelerated.into();
41919 self
41920 }
41921 pub fn integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated(
41922 mut self,
41923 integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: bool,
41924 ) -> Self {
41925 self.inner
41926 .integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated =
41927 integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated.into();
41928 self
41929 }
41930 pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated(
41931 mut self,
41932 integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: bool,
41933 ) -> Self {
41934 self.inner
41935 .integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated =
41936 integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated.into();
41937 self
41938 }
41939 pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated(
41940 mut self,
41941 integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: bool,
41942 ) -> Self {
41943 self.inner
41944 .integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated =
41945 integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated.into();
41946 self
41947 }
41948 pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated(
41949 mut self,
41950 integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : bool,
41951 ) -> Self {
41952 self . inner . integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated . into () ;
41953 self
41954 }
41955 pub fn integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated(
41956 mut self,
41957 integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: bool,
41958 ) -> Self {
41959 self.inner
41960 .integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated =
41961 integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated.into();
41962 self
41963 }
41964 pub fn integer_dot_product_accumulating_saturating16_bit_signed_accelerated(
41965 mut self,
41966 integer_dot_product_accumulating_saturating16_bit_signed_accelerated: bool,
41967 ) -> Self {
41968 self.inner
41969 .integer_dot_product_accumulating_saturating16_bit_signed_accelerated =
41970 integer_dot_product_accumulating_saturating16_bit_signed_accelerated.into();
41971 self
41972 }
41973 pub fn integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated(
41974 mut self,
41975 integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: bool,
41976 ) -> Self {
41977 self.inner
41978 .integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated =
41979 integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated.into();
41980 self
41981 }
41982 pub fn integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated(
41983 mut self,
41984 integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: bool,
41985 ) -> Self {
41986 self.inner
41987 .integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated =
41988 integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated.into();
41989 self
41990 }
41991 pub fn integer_dot_product_accumulating_saturating32_bit_signed_accelerated(
41992 mut self,
41993 integer_dot_product_accumulating_saturating32_bit_signed_accelerated: bool,
41994 ) -> Self {
41995 self.inner
41996 .integer_dot_product_accumulating_saturating32_bit_signed_accelerated =
41997 integer_dot_product_accumulating_saturating32_bit_signed_accelerated.into();
41998 self
41999 }
42000 pub fn integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated(
42001 mut self,
42002 integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: bool,
42003 ) -> Self {
42004 self.inner
42005 .integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated =
42006 integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated.into();
42007 self
42008 }
42009 pub fn integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated(
42010 mut self,
42011 integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: bool,
42012 ) -> Self {
42013 self.inner
42014 .integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated =
42015 integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated.into();
42016 self
42017 }
42018 pub fn integer_dot_product_accumulating_saturating64_bit_signed_accelerated(
42019 mut self,
42020 integer_dot_product_accumulating_saturating64_bit_signed_accelerated: bool,
42021 ) -> Self {
42022 self.inner
42023 .integer_dot_product_accumulating_saturating64_bit_signed_accelerated =
42024 integer_dot_product_accumulating_saturating64_bit_signed_accelerated.into();
42025 self
42026 }
42027 pub fn integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated(
42028 mut self,
42029 integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: bool,
42030 ) -> Self {
42031 self.inner
42032 .integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated =
42033 integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated.into();
42034 self
42035 }
42036 pub fn storage_texel_buffer_offset_alignment_bytes(
42037 mut self,
42038 storage_texel_buffer_offset_alignment_bytes: DeviceSize,
42039 ) -> Self {
42040 self.inner.storage_texel_buffer_offset_alignment_bytes =
42041 storage_texel_buffer_offset_alignment_bytes;
42042 self
42043 }
42044 pub fn storage_texel_buffer_offset_single_texel_alignment(
42045 mut self,
42046 storage_texel_buffer_offset_single_texel_alignment: bool,
42047 ) -> Self {
42048 self.inner
42049 .storage_texel_buffer_offset_single_texel_alignment =
42050 storage_texel_buffer_offset_single_texel_alignment.into();
42051 self
42052 }
42053 pub fn uniform_texel_buffer_offset_alignment_bytes(
42054 mut self,
42055 uniform_texel_buffer_offset_alignment_bytes: DeviceSize,
42056 ) -> Self {
42057 self.inner.uniform_texel_buffer_offset_alignment_bytes =
42058 uniform_texel_buffer_offset_alignment_bytes;
42059 self
42060 }
42061 pub fn uniform_texel_buffer_offset_single_texel_alignment(
42062 mut self,
42063 uniform_texel_buffer_offset_single_texel_alignment: bool,
42064 ) -> Self {
42065 self.inner
42066 .uniform_texel_buffer_offset_single_texel_alignment =
42067 uniform_texel_buffer_offset_single_texel_alignment.into();
42068 self
42069 }
42070 pub fn max_buffer_size(mut self, max_buffer_size: DeviceSize) -> Self {
42071 self.inner.max_buffer_size = max_buffer_size;
42072 self
42073 }
42074 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42075 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42076 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
42077 pub fn build(self) -> PhysicalDeviceVulkan13Properties {
42078 self.inner
42079 }
42080}
42081#[repr(C)]
42082#[cfg_attr(feature = "debug", derive(Debug))]
42083#[derive(Copy, Clone)]
42084#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCompilerControlCreateInfoAMD.html>"]
42085pub struct PipelineCompilerControlCreateInfoAMD {
42086 pub s_type: StructureType,
42087 pub p_next: *const c_void,
42088 pub compiler_control_flags: PipelineCompilerControlFlagsAMD,
42089}
42090impl ::std::default::Default for PipelineCompilerControlCreateInfoAMD {
42091 fn default() -> Self {
42092 Self {
42093 s_type: StructureType::PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD,
42094 p_next: ::std::ptr::null(),
42095 compiler_control_flags: PipelineCompilerControlFlagsAMD::default(),
42096 }
42097 }
42098}
42099impl PipelineCompilerControlCreateInfoAMD {
42100 pub fn builder<'a>() -> PipelineCompilerControlCreateInfoAMDBuilder<'a> {
42101 PipelineCompilerControlCreateInfoAMDBuilder {
42102 inner: Self::default(),
42103 marker: ::std::marker::PhantomData,
42104 }
42105 }
42106}
42107#[repr(transparent)]
42108pub struct PipelineCompilerControlCreateInfoAMDBuilder<'a> {
42109 inner: PipelineCompilerControlCreateInfoAMD,
42110 marker: ::std::marker::PhantomData<&'a ()>,
42111}
42112unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCompilerControlCreateInfoAMDBuilder<'_> {}
42113unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCompilerControlCreateInfoAMD {}
42114unsafe impl ExtendsComputePipelineCreateInfo for PipelineCompilerControlCreateInfoAMDBuilder<'_> {}
42115unsafe impl ExtendsComputePipelineCreateInfo for PipelineCompilerControlCreateInfoAMD {}
42116impl<'a> ::std::ops::Deref for PipelineCompilerControlCreateInfoAMDBuilder<'a> {
42117 type Target = PipelineCompilerControlCreateInfoAMD;
42118 fn deref(&self) -> &Self::Target {
42119 &self.inner
42120 }
42121}
42122impl<'a> ::std::ops::DerefMut for PipelineCompilerControlCreateInfoAMDBuilder<'a> {
42123 fn deref_mut(&mut self) -> &mut Self::Target {
42124 &mut self.inner
42125 }
42126}
42127impl<'a> PipelineCompilerControlCreateInfoAMDBuilder<'a> {
42128 pub fn compiler_control_flags(
42129 mut self,
42130 compiler_control_flags: PipelineCompilerControlFlagsAMD,
42131 ) -> Self {
42132 self.inner.compiler_control_flags = compiler_control_flags;
42133 self
42134 }
42135 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42136 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42137 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
42138 pub fn build(self) -> PipelineCompilerControlCreateInfoAMD {
42139 self.inner
42140 }
42141}
42142#[repr(C)]
42143#[cfg_attr(feature = "debug", derive(Debug))]
42144#[derive(Copy, Clone)]
42145#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCoherentMemoryFeaturesAMD.html>"]
42146pub struct PhysicalDeviceCoherentMemoryFeaturesAMD {
42147 pub s_type: StructureType,
42148 pub p_next: *mut c_void,
42149 pub device_coherent_memory: Bool32,
42150}
42151impl ::std::default::Default for PhysicalDeviceCoherentMemoryFeaturesAMD {
42152 fn default() -> Self {
42153 Self {
42154 s_type: StructureType::PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD,
42155 p_next: ::std::ptr::null_mut(),
42156 device_coherent_memory: Bool32::default(),
42157 }
42158 }
42159}
42160impl PhysicalDeviceCoherentMemoryFeaturesAMD {
42161 pub fn builder<'a>() -> PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
42162 PhysicalDeviceCoherentMemoryFeaturesAMDBuilder {
42163 inner: Self::default(),
42164 marker: ::std::marker::PhantomData,
42165 }
42166 }
42167}
42168#[repr(transparent)]
42169pub struct PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
42170 inner: PhysicalDeviceCoherentMemoryFeaturesAMD,
42171 marker: ::std::marker::PhantomData<&'a ()>,
42172}
42173unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'_> {}
42174unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCoherentMemoryFeaturesAMD {}
42175unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'_> {}
42176unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoherentMemoryFeaturesAMD {}
42177impl<'a> ::std::ops::Deref for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
42178 type Target = PhysicalDeviceCoherentMemoryFeaturesAMD;
42179 fn deref(&self) -> &Self::Target {
42180 &self.inner
42181 }
42182}
42183impl<'a> ::std::ops::DerefMut for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
42184 fn deref_mut(&mut self) -> &mut Self::Target {
42185 &mut self.inner
42186 }
42187}
42188impl<'a> PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
42189 pub fn device_coherent_memory(mut self, device_coherent_memory: bool) -> Self {
42190 self.inner.device_coherent_memory = device_coherent_memory.into();
42191 self
42192 }
42193 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42194 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42195 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
42196 pub fn build(self) -> PhysicalDeviceCoherentMemoryFeaturesAMD {
42197 self.inner
42198 }
42199}
42200#[repr(C)]
42201#[derive(Copy, Clone)]
42202#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceToolProperties.html>"]
42203pub struct PhysicalDeviceToolProperties {
42204 pub s_type: StructureType,
42205 pub p_next: *mut c_void,
42206 pub name: [c_char; MAX_EXTENSION_NAME_SIZE],
42207 pub version: [c_char; MAX_EXTENSION_NAME_SIZE],
42208 pub purposes: ToolPurposeFlags,
42209 pub description: [c_char; MAX_DESCRIPTION_SIZE],
42210 pub layer: [c_char; MAX_EXTENSION_NAME_SIZE],
42211}
42212#[cfg(feature = "debug")]
42213impl fmt::Debug for PhysicalDeviceToolProperties {
42214 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
42215 fmt.debug_struct("PhysicalDeviceToolProperties")
42216 .field("s_type", &self.s_type)
42217 .field("p_next", &self.p_next)
42218 .field("name", &unsafe {
42219 ::std::ffi::CStr::from_ptr(self.name.as_ptr())
42220 })
42221 .field("version", &unsafe {
42222 ::std::ffi::CStr::from_ptr(self.version.as_ptr())
42223 })
42224 .field("purposes", &self.purposes)
42225 .field("description", &unsafe {
42226 ::std::ffi::CStr::from_ptr(self.description.as_ptr())
42227 })
42228 .field("layer", &unsafe {
42229 ::std::ffi::CStr::from_ptr(self.layer.as_ptr())
42230 })
42231 .finish()
42232 }
42233}
42234impl ::std::default::Default for PhysicalDeviceToolProperties {
42235 fn default() -> Self {
42236 Self {
42237 s_type: StructureType::PHYSICAL_DEVICE_TOOL_PROPERTIES,
42238 p_next: ::std::ptr::null_mut(),
42239 name: unsafe { ::std::mem::zeroed() },
42240 version: unsafe { ::std::mem::zeroed() },
42241 purposes: ToolPurposeFlags::default(),
42242 description: unsafe { ::std::mem::zeroed() },
42243 layer: unsafe { ::std::mem::zeroed() },
42244 }
42245 }
42246}
42247impl PhysicalDeviceToolProperties {
42248 pub fn builder<'a>() -> PhysicalDeviceToolPropertiesBuilder<'a> {
42249 PhysicalDeviceToolPropertiesBuilder {
42250 inner: Self::default(),
42251 marker: ::std::marker::PhantomData,
42252 }
42253 }
42254}
42255#[repr(transparent)]
42256pub struct PhysicalDeviceToolPropertiesBuilder<'a> {
42257 inner: PhysicalDeviceToolProperties,
42258 marker: ::std::marker::PhantomData<&'a ()>,
42259}
42260impl<'a> ::std::ops::Deref for PhysicalDeviceToolPropertiesBuilder<'a> {
42261 type Target = PhysicalDeviceToolProperties;
42262 fn deref(&self) -> &Self::Target {
42263 &self.inner
42264 }
42265}
42266impl<'a> ::std::ops::DerefMut for PhysicalDeviceToolPropertiesBuilder<'a> {
42267 fn deref_mut(&mut self) -> &mut Self::Target {
42268 &mut self.inner
42269 }
42270}
42271impl<'a> PhysicalDeviceToolPropertiesBuilder<'a> {
42272 pub fn name(mut self, name: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self {
42273 self.inner.name = name;
42274 self
42275 }
42276 pub fn version(mut self, version: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self {
42277 self.inner.version = version;
42278 self
42279 }
42280 pub fn purposes(mut self, purposes: ToolPurposeFlags) -> Self {
42281 self.inner.purposes = purposes;
42282 self
42283 }
42284 pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
42285 self.inner.description = description;
42286 self
42287 }
42288 pub fn layer(mut self, layer: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self {
42289 self.inner.layer = layer;
42290 self
42291 }
42292 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42293 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42294 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
42295 pub fn build(self) -> PhysicalDeviceToolProperties {
42296 self.inner
42297 }
42298}
42299#[repr(C)]
42300#[derive(Copy, Clone)]
42301#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerCustomBorderColorCreateInfoEXT.html>"]
42302pub struct SamplerCustomBorderColorCreateInfoEXT {
42303 pub s_type: StructureType,
42304 pub p_next: *const c_void,
42305 pub custom_border_color: ClearColorValue,
42306 pub format: Format,
42307}
42308#[cfg(feature = "debug")]
42309impl fmt::Debug for SamplerCustomBorderColorCreateInfoEXT {
42310 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
42311 fmt.debug_struct("SamplerCustomBorderColorCreateInfoEXT")
42312 .field("s_type", &self.s_type)
42313 .field("p_next", &self.p_next)
42314 .field("custom_border_color", &"union")
42315 .field("format", &self.format)
42316 .finish()
42317 }
42318}
42319impl ::std::default::Default for SamplerCustomBorderColorCreateInfoEXT {
42320 fn default() -> Self {
42321 Self {
42322 s_type: StructureType::SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT,
42323 p_next: ::std::ptr::null(),
42324 custom_border_color: ClearColorValue::default(),
42325 format: Format::default(),
42326 }
42327 }
42328}
42329impl SamplerCustomBorderColorCreateInfoEXT {
42330 pub fn builder<'a>() -> SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
42331 SamplerCustomBorderColorCreateInfoEXTBuilder {
42332 inner: Self::default(),
42333 marker: ::std::marker::PhantomData,
42334 }
42335 }
42336}
42337#[repr(transparent)]
42338pub struct SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
42339 inner: SamplerCustomBorderColorCreateInfoEXT,
42340 marker: ::std::marker::PhantomData<&'a ()>,
42341}
42342unsafe impl ExtendsSamplerCreateInfo for SamplerCustomBorderColorCreateInfoEXTBuilder<'_> {}
42343unsafe impl ExtendsSamplerCreateInfo for SamplerCustomBorderColorCreateInfoEXT {}
42344impl<'a> ::std::ops::Deref for SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
42345 type Target = SamplerCustomBorderColorCreateInfoEXT;
42346 fn deref(&self) -> &Self::Target {
42347 &self.inner
42348 }
42349}
42350impl<'a> ::std::ops::DerefMut for SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
42351 fn deref_mut(&mut self) -> &mut Self::Target {
42352 &mut self.inner
42353 }
42354}
42355impl<'a> SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
42356 pub fn custom_border_color(mut self, custom_border_color: ClearColorValue) -> Self {
42357 self.inner.custom_border_color = custom_border_color;
42358 self
42359 }
42360 pub fn format(mut self, format: Format) -> Self {
42361 self.inner.format = format;
42362 self
42363 }
42364 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42365 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42366 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
42367 pub fn build(self) -> SamplerCustomBorderColorCreateInfoEXT {
42368 self.inner
42369 }
42370}
42371#[repr(C)]
42372#[cfg_attr(feature = "debug", derive(Debug))]
42373#[derive(Copy, Clone)]
42374#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCustomBorderColorPropertiesEXT.html>"]
42375pub struct PhysicalDeviceCustomBorderColorPropertiesEXT {
42376 pub s_type: StructureType,
42377 pub p_next: *mut c_void,
42378 pub max_custom_border_color_samplers: u32,
42379}
42380impl ::std::default::Default for PhysicalDeviceCustomBorderColorPropertiesEXT {
42381 fn default() -> Self {
42382 Self {
42383 s_type: StructureType::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT,
42384 p_next: ::std::ptr::null_mut(),
42385 max_custom_border_color_samplers: u32::default(),
42386 }
42387 }
42388}
42389impl PhysicalDeviceCustomBorderColorPropertiesEXT {
42390 pub fn builder<'a>() -> PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> {
42391 PhysicalDeviceCustomBorderColorPropertiesEXTBuilder {
42392 inner: Self::default(),
42393 marker: ::std::marker::PhantomData,
42394 }
42395 }
42396}
42397#[repr(transparent)]
42398pub struct PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> {
42399 inner: PhysicalDeviceCustomBorderColorPropertiesEXT,
42400 marker: ::std::marker::PhantomData<&'a ()>,
42401}
42402unsafe impl ExtendsPhysicalDeviceProperties2
42403 for PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'_>
42404{
42405}
42406unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCustomBorderColorPropertiesEXT {}
42407impl<'a> ::std::ops::Deref for PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> {
42408 type Target = PhysicalDeviceCustomBorderColorPropertiesEXT;
42409 fn deref(&self) -> &Self::Target {
42410 &self.inner
42411 }
42412}
42413impl<'a> ::std::ops::DerefMut for PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> {
42414 fn deref_mut(&mut self) -> &mut Self::Target {
42415 &mut self.inner
42416 }
42417}
42418impl<'a> PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> {
42419 pub fn max_custom_border_color_samplers(
42420 mut self,
42421 max_custom_border_color_samplers: u32,
42422 ) -> Self {
42423 self.inner.max_custom_border_color_samplers = max_custom_border_color_samplers;
42424 self
42425 }
42426 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42427 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42428 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
42429 pub fn build(self) -> PhysicalDeviceCustomBorderColorPropertiesEXT {
42430 self.inner
42431 }
42432}
42433#[repr(C)]
42434#[cfg_attr(feature = "debug", derive(Debug))]
42435#[derive(Copy, Clone)]
42436#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCustomBorderColorFeaturesEXT.html>"]
42437pub struct PhysicalDeviceCustomBorderColorFeaturesEXT {
42438 pub s_type: StructureType,
42439 pub p_next: *mut c_void,
42440 pub custom_border_colors: Bool32,
42441 pub custom_border_color_without_format: Bool32,
42442}
42443impl ::std::default::Default for PhysicalDeviceCustomBorderColorFeaturesEXT {
42444 fn default() -> Self {
42445 Self {
42446 s_type: StructureType::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT,
42447 p_next: ::std::ptr::null_mut(),
42448 custom_border_colors: Bool32::default(),
42449 custom_border_color_without_format: Bool32::default(),
42450 }
42451 }
42452}
42453impl PhysicalDeviceCustomBorderColorFeaturesEXT {
42454 pub fn builder<'a>() -> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
42455 PhysicalDeviceCustomBorderColorFeaturesEXTBuilder {
42456 inner: Self::default(),
42457 marker: ::std::marker::PhantomData,
42458 }
42459 }
42460}
42461#[repr(transparent)]
42462pub struct PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
42463 inner: PhysicalDeviceCustomBorderColorFeaturesEXT,
42464 marker: ::std::marker::PhantomData<&'a ()>,
42465}
42466unsafe impl ExtendsPhysicalDeviceFeatures2
42467 for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'_>
42468{
42469}
42470unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCustomBorderColorFeaturesEXT {}
42471unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'_> {}
42472unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCustomBorderColorFeaturesEXT {}
42473impl<'a> ::std::ops::Deref for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
42474 type Target = PhysicalDeviceCustomBorderColorFeaturesEXT;
42475 fn deref(&self) -> &Self::Target {
42476 &self.inner
42477 }
42478}
42479impl<'a> ::std::ops::DerefMut for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
42480 fn deref_mut(&mut self) -> &mut Self::Target {
42481 &mut self.inner
42482 }
42483}
42484impl<'a> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
42485 pub fn custom_border_colors(mut self, custom_border_colors: bool) -> Self {
42486 self.inner.custom_border_colors = custom_border_colors.into();
42487 self
42488 }
42489 pub fn custom_border_color_without_format(
42490 mut self,
42491 custom_border_color_without_format: bool,
42492 ) -> Self {
42493 self.inner.custom_border_color_without_format = custom_border_color_without_format.into();
42494 self
42495 }
42496 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42497 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42498 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
42499 pub fn build(self) -> PhysicalDeviceCustomBorderColorFeaturesEXT {
42500 self.inner
42501 }
42502}
42503#[repr(C)]
42504#[cfg_attr(feature = "debug", derive(Debug))]
42505#[derive(Copy, Clone)]
42506#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerBorderColorComponentMappingCreateInfoEXT.html>"]
42507pub struct SamplerBorderColorComponentMappingCreateInfoEXT {
42508 pub s_type: StructureType,
42509 pub p_next: *const c_void,
42510 pub components: ComponentMapping,
42511 pub srgb: Bool32,
42512}
42513impl ::std::default::Default for SamplerBorderColorComponentMappingCreateInfoEXT {
42514 fn default() -> Self {
42515 Self {
42516 s_type: StructureType::SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT,
42517 p_next: ::std::ptr::null(),
42518 components: ComponentMapping::default(),
42519 srgb: Bool32::default(),
42520 }
42521 }
42522}
42523impl SamplerBorderColorComponentMappingCreateInfoEXT {
42524 pub fn builder<'a>() -> SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> {
42525 SamplerBorderColorComponentMappingCreateInfoEXTBuilder {
42526 inner: Self::default(),
42527 marker: ::std::marker::PhantomData,
42528 }
42529 }
42530}
42531#[repr(transparent)]
42532pub struct SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> {
42533 inner: SamplerBorderColorComponentMappingCreateInfoEXT,
42534 marker: ::std::marker::PhantomData<&'a ()>,
42535}
42536unsafe impl ExtendsSamplerCreateInfo
42537 for SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'_>
42538{
42539}
42540unsafe impl ExtendsSamplerCreateInfo for SamplerBorderColorComponentMappingCreateInfoEXT {}
42541impl<'a> ::std::ops::Deref for SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> {
42542 type Target = SamplerBorderColorComponentMappingCreateInfoEXT;
42543 fn deref(&self) -> &Self::Target {
42544 &self.inner
42545 }
42546}
42547impl<'a> ::std::ops::DerefMut for SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> {
42548 fn deref_mut(&mut self) -> &mut Self::Target {
42549 &mut self.inner
42550 }
42551}
42552impl<'a> SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> {
42553 pub fn components(mut self, components: ComponentMapping) -> Self {
42554 self.inner.components = components;
42555 self
42556 }
42557 pub fn srgb(mut self, srgb: bool) -> Self {
42558 self.inner.srgb = srgb.into();
42559 self
42560 }
42561 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42562 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42563 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
42564 pub fn build(self) -> SamplerBorderColorComponentMappingCreateInfoEXT {
42565 self.inner
42566 }
42567}
42568#[repr(C)]
42569#[cfg_attr(feature = "debug", derive(Debug))]
42570#[derive(Copy, Clone)]
42571#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceBorderColorSwizzleFeaturesEXT.html>"]
42572pub struct PhysicalDeviceBorderColorSwizzleFeaturesEXT {
42573 pub s_type: StructureType,
42574 pub p_next: *mut c_void,
42575 pub border_color_swizzle: Bool32,
42576 pub border_color_swizzle_from_image: Bool32,
42577}
42578impl ::std::default::Default for PhysicalDeviceBorderColorSwizzleFeaturesEXT {
42579 fn default() -> Self {
42580 Self {
42581 s_type: StructureType::PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT,
42582 p_next: ::std::ptr::null_mut(),
42583 border_color_swizzle: Bool32::default(),
42584 border_color_swizzle_from_image: Bool32::default(),
42585 }
42586 }
42587}
42588impl PhysicalDeviceBorderColorSwizzleFeaturesEXT {
42589 pub fn builder<'a>() -> PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> {
42590 PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder {
42591 inner: Self::default(),
42592 marker: ::std::marker::PhantomData,
42593 }
42594 }
42595}
42596#[repr(transparent)]
42597pub struct PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> {
42598 inner: PhysicalDeviceBorderColorSwizzleFeaturesEXT,
42599 marker: ::std::marker::PhantomData<&'a ()>,
42600}
42601unsafe impl ExtendsPhysicalDeviceFeatures2
42602 for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'_>
42603{
42604}
42605unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBorderColorSwizzleFeaturesEXT {}
42606unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'_> {}
42607unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBorderColorSwizzleFeaturesEXT {}
42608impl<'a> ::std::ops::Deref for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> {
42609 type Target = PhysicalDeviceBorderColorSwizzleFeaturesEXT;
42610 fn deref(&self) -> &Self::Target {
42611 &self.inner
42612 }
42613}
42614impl<'a> ::std::ops::DerefMut for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> {
42615 fn deref_mut(&mut self) -> &mut Self::Target {
42616 &mut self.inner
42617 }
42618}
42619impl<'a> PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> {
42620 pub fn border_color_swizzle(mut self, border_color_swizzle: bool) -> Self {
42621 self.inner.border_color_swizzle = border_color_swizzle.into();
42622 self
42623 }
42624 pub fn border_color_swizzle_from_image(
42625 mut self,
42626 border_color_swizzle_from_image: bool,
42627 ) -> Self {
42628 self.inner.border_color_swizzle_from_image = border_color_swizzle_from_image.into();
42629 self
42630 }
42631 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42632 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42633 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
42634 pub fn build(self) -> PhysicalDeviceBorderColorSwizzleFeaturesEXT {
42635 self.inner
42636 }
42637}
42638#[repr(C)]
42639#[derive(Copy, Clone)]
42640#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceOrHostAddressKHR.html>"]
42641pub union DeviceOrHostAddressKHR {
42642 pub device_address: DeviceAddress,
42643 pub host_address: *mut c_void,
42644}
42645impl ::std::default::Default for DeviceOrHostAddressKHR {
42646 fn default() -> Self {
42647 unsafe { ::std::mem::zeroed() }
42648 }
42649}
42650#[repr(C)]
42651#[derive(Copy, Clone)]
42652#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceOrHostAddressConstKHR.html>"]
42653pub union DeviceOrHostAddressConstKHR {
42654 pub device_address: DeviceAddress,
42655 pub host_address: *const c_void,
42656}
42657impl ::std::default::Default for DeviceOrHostAddressConstKHR {
42658 fn default() -> Self {
42659 unsafe { ::std::mem::zeroed() }
42660 }
42661}
42662#[repr(C)]
42663#[derive(Copy, Clone)]
42664#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryTrianglesDataKHR.html>"]
42665pub struct AccelerationStructureGeometryTrianglesDataKHR {
42666 pub s_type: StructureType,
42667 pub p_next: *const c_void,
42668 pub vertex_format: Format,
42669 pub vertex_data: DeviceOrHostAddressConstKHR,
42670 pub vertex_stride: DeviceSize,
42671 pub max_vertex: u32,
42672 pub index_type: IndexType,
42673 pub index_data: DeviceOrHostAddressConstKHR,
42674 pub transform_data: DeviceOrHostAddressConstKHR,
42675}
42676#[cfg(feature = "debug")]
42677impl fmt::Debug for AccelerationStructureGeometryTrianglesDataKHR {
42678 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
42679 fmt.debug_struct("AccelerationStructureGeometryTrianglesDataKHR")
42680 .field("s_type", &self.s_type)
42681 .field("p_next", &self.p_next)
42682 .field("vertex_format", &self.vertex_format)
42683 .field("vertex_data", &"union")
42684 .field("vertex_stride", &self.vertex_stride)
42685 .field("max_vertex", &self.max_vertex)
42686 .field("index_type", &self.index_type)
42687 .field("index_data", &"union")
42688 .field("transform_data", &"union")
42689 .finish()
42690 }
42691}
42692impl ::std::default::Default for AccelerationStructureGeometryTrianglesDataKHR {
42693 fn default() -> Self {
42694 Self {
42695 s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR,
42696 p_next: ::std::ptr::null(),
42697 vertex_format: Format::default(),
42698 vertex_data: DeviceOrHostAddressConstKHR::default(),
42699 vertex_stride: DeviceSize::default(),
42700 max_vertex: u32::default(),
42701 index_type: IndexType::default(),
42702 index_data: DeviceOrHostAddressConstKHR::default(),
42703 transform_data: DeviceOrHostAddressConstKHR::default(),
42704 }
42705 }
42706}
42707impl AccelerationStructureGeometryTrianglesDataKHR {
42708 pub fn builder<'a>() -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
42709 AccelerationStructureGeometryTrianglesDataKHRBuilder {
42710 inner: Self::default(),
42711 marker: ::std::marker::PhantomData,
42712 }
42713 }
42714}
42715#[repr(transparent)]
42716pub struct AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
42717 inner: AccelerationStructureGeometryTrianglesDataKHR,
42718 marker: ::std::marker::PhantomData<&'a ()>,
42719}
42720pub unsafe trait ExtendsAccelerationStructureGeometryTrianglesDataKHR {}
42721impl<'a> ::std::ops::Deref for AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
42722 type Target = AccelerationStructureGeometryTrianglesDataKHR;
42723 fn deref(&self) -> &Self::Target {
42724 &self.inner
42725 }
42726}
42727impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
42728 fn deref_mut(&mut self) -> &mut Self::Target {
42729 &mut self.inner
42730 }
42731}
42732impl<'a> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
42733 pub fn vertex_format(mut self, vertex_format: Format) -> Self {
42734 self.inner.vertex_format = vertex_format;
42735 self
42736 }
42737 pub fn vertex_data(mut self, vertex_data: DeviceOrHostAddressConstKHR) -> Self {
42738 self.inner.vertex_data = vertex_data;
42739 self
42740 }
42741 pub fn vertex_stride(mut self, vertex_stride: DeviceSize) -> Self {
42742 self.inner.vertex_stride = vertex_stride;
42743 self
42744 }
42745 pub fn max_vertex(mut self, max_vertex: u32) -> Self {
42746 self.inner.max_vertex = max_vertex;
42747 self
42748 }
42749 pub fn index_type(mut self, index_type: IndexType) -> Self {
42750 self.inner.index_type = index_type;
42751 self
42752 }
42753 pub fn index_data(mut self, index_data: DeviceOrHostAddressConstKHR) -> Self {
42754 self.inner.index_data = index_data;
42755 self
42756 }
42757 pub fn transform_data(mut self, transform_data: DeviceOrHostAddressConstKHR) -> Self {
42758 self.inner.transform_data = transform_data;
42759 self
42760 }
42761 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
42762 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
42763 #[doc = r" valid extension structs can be pushed into the chain."]
42764 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
42765 #[doc = r" chain will look like `A -> D -> B -> C`."]
42766 pub fn push_next<T: ExtendsAccelerationStructureGeometryTrianglesDataKHR>(
42767 mut self,
42768 next: &'a mut T,
42769 ) -> Self {
42770 unsafe {
42771 let next_ptr = <*const T>::cast(next);
42772 let last_next = ptr_chain_iter(next).last().unwrap();
42773 (*last_next).p_next = self.inner.p_next as _;
42774 self.inner.p_next = next_ptr;
42775 }
42776 self
42777 }
42778 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42779 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42780 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
42781 pub fn build(self) -> AccelerationStructureGeometryTrianglesDataKHR {
42782 self.inner
42783 }
42784}
42785#[repr(C)]
42786#[derive(Copy, Clone)]
42787#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryAabbsDataKHR.html>"]
42788pub struct AccelerationStructureGeometryAabbsDataKHR {
42789 pub s_type: StructureType,
42790 pub p_next: *const c_void,
42791 pub data: DeviceOrHostAddressConstKHR,
42792 pub stride: DeviceSize,
42793}
42794#[cfg(feature = "debug")]
42795impl fmt::Debug for AccelerationStructureGeometryAabbsDataKHR {
42796 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
42797 fmt.debug_struct("AccelerationStructureGeometryAabbsDataKHR")
42798 .field("s_type", &self.s_type)
42799 .field("p_next", &self.p_next)
42800 .field("data", &"union")
42801 .field("stride", &self.stride)
42802 .finish()
42803 }
42804}
42805impl ::std::default::Default for AccelerationStructureGeometryAabbsDataKHR {
42806 fn default() -> Self {
42807 Self {
42808 s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR,
42809 p_next: ::std::ptr::null(),
42810 data: DeviceOrHostAddressConstKHR::default(),
42811 stride: DeviceSize::default(),
42812 }
42813 }
42814}
42815impl AccelerationStructureGeometryAabbsDataKHR {
42816 pub fn builder<'a>() -> AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
42817 AccelerationStructureGeometryAabbsDataKHRBuilder {
42818 inner: Self::default(),
42819 marker: ::std::marker::PhantomData,
42820 }
42821 }
42822}
42823#[repr(transparent)]
42824pub struct AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
42825 inner: AccelerationStructureGeometryAabbsDataKHR,
42826 marker: ::std::marker::PhantomData<&'a ()>,
42827}
42828impl<'a> ::std::ops::Deref for AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
42829 type Target = AccelerationStructureGeometryAabbsDataKHR;
42830 fn deref(&self) -> &Self::Target {
42831 &self.inner
42832 }
42833}
42834impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
42835 fn deref_mut(&mut self) -> &mut Self::Target {
42836 &mut self.inner
42837 }
42838}
42839impl<'a> AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
42840 pub fn data(mut self, data: DeviceOrHostAddressConstKHR) -> Self {
42841 self.inner.data = data;
42842 self
42843 }
42844 pub fn stride(mut self, stride: DeviceSize) -> Self {
42845 self.inner.stride = stride;
42846 self
42847 }
42848 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42849 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42850 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
42851 pub fn build(self) -> AccelerationStructureGeometryAabbsDataKHR {
42852 self.inner
42853 }
42854}
42855#[repr(C)]
42856#[derive(Copy, Clone)]
42857#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryInstancesDataKHR.html>"]
42858pub struct AccelerationStructureGeometryInstancesDataKHR {
42859 pub s_type: StructureType,
42860 pub p_next: *const c_void,
42861 pub array_of_pointers: Bool32,
42862 pub data: DeviceOrHostAddressConstKHR,
42863}
42864#[cfg(feature = "debug")]
42865impl fmt::Debug for AccelerationStructureGeometryInstancesDataKHR {
42866 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
42867 fmt.debug_struct("AccelerationStructureGeometryInstancesDataKHR")
42868 .field("s_type", &self.s_type)
42869 .field("p_next", &self.p_next)
42870 .field("array_of_pointers", &self.array_of_pointers)
42871 .field("data", &"union")
42872 .finish()
42873 }
42874}
42875impl ::std::default::Default for AccelerationStructureGeometryInstancesDataKHR {
42876 fn default() -> Self {
42877 Self {
42878 s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR,
42879 p_next: ::std::ptr::null(),
42880 array_of_pointers: Bool32::default(),
42881 data: DeviceOrHostAddressConstKHR::default(),
42882 }
42883 }
42884}
42885impl AccelerationStructureGeometryInstancesDataKHR {
42886 pub fn builder<'a>() -> AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
42887 AccelerationStructureGeometryInstancesDataKHRBuilder {
42888 inner: Self::default(),
42889 marker: ::std::marker::PhantomData,
42890 }
42891 }
42892}
42893#[repr(transparent)]
42894pub struct AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
42895 inner: AccelerationStructureGeometryInstancesDataKHR,
42896 marker: ::std::marker::PhantomData<&'a ()>,
42897}
42898impl<'a> ::std::ops::Deref for AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
42899 type Target = AccelerationStructureGeometryInstancesDataKHR;
42900 fn deref(&self) -> &Self::Target {
42901 &self.inner
42902 }
42903}
42904impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
42905 fn deref_mut(&mut self) -> &mut Self::Target {
42906 &mut self.inner
42907 }
42908}
42909impl<'a> AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
42910 pub fn array_of_pointers(mut self, array_of_pointers: bool) -> Self {
42911 self.inner.array_of_pointers = array_of_pointers.into();
42912 self
42913 }
42914 pub fn data(mut self, data: DeviceOrHostAddressConstKHR) -> Self {
42915 self.inner.data = data;
42916 self
42917 }
42918 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42919 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42920 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
42921 pub fn build(self) -> AccelerationStructureGeometryInstancesDataKHR {
42922 self.inner
42923 }
42924}
42925#[repr(C)]
42926#[derive(Copy, Clone)]
42927#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryDataKHR.html>"]
42928pub union AccelerationStructureGeometryDataKHR {
42929 pub triangles: AccelerationStructureGeometryTrianglesDataKHR,
42930 pub aabbs: AccelerationStructureGeometryAabbsDataKHR,
42931 pub instances: AccelerationStructureGeometryInstancesDataKHR,
42932}
42933impl ::std::default::Default for AccelerationStructureGeometryDataKHR {
42934 fn default() -> Self {
42935 unsafe { ::std::mem::zeroed() }
42936 }
42937}
42938#[repr(C)]
42939#[derive(Copy, Clone)]
42940#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryKHR.html>"]
42941pub struct AccelerationStructureGeometryKHR {
42942 pub s_type: StructureType,
42943 pub p_next: *const c_void,
42944 pub geometry_type: GeometryTypeKHR,
42945 pub geometry: AccelerationStructureGeometryDataKHR,
42946 pub flags: GeometryFlagsKHR,
42947}
42948#[cfg(feature = "debug")]
42949impl fmt::Debug for AccelerationStructureGeometryKHR {
42950 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
42951 fmt.debug_struct("AccelerationStructureGeometryKHR")
42952 .field("s_type", &self.s_type)
42953 .field("p_next", &self.p_next)
42954 .field("geometry_type", &self.geometry_type)
42955 .field("geometry", &"union")
42956 .field("flags", &self.flags)
42957 .finish()
42958 }
42959}
42960impl ::std::default::Default for AccelerationStructureGeometryKHR {
42961 fn default() -> Self {
42962 Self {
42963 s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_KHR,
42964 p_next: ::std::ptr::null(),
42965 geometry_type: GeometryTypeKHR::default(),
42966 geometry: AccelerationStructureGeometryDataKHR::default(),
42967 flags: GeometryFlagsKHR::default(),
42968 }
42969 }
42970}
42971impl AccelerationStructureGeometryKHR {
42972 pub fn builder<'a>() -> AccelerationStructureGeometryKHRBuilder<'a> {
42973 AccelerationStructureGeometryKHRBuilder {
42974 inner: Self::default(),
42975 marker: ::std::marker::PhantomData,
42976 }
42977 }
42978}
42979#[repr(transparent)]
42980pub struct AccelerationStructureGeometryKHRBuilder<'a> {
42981 inner: AccelerationStructureGeometryKHR,
42982 marker: ::std::marker::PhantomData<&'a ()>,
42983}
42984impl<'a> ::std::ops::Deref for AccelerationStructureGeometryKHRBuilder<'a> {
42985 type Target = AccelerationStructureGeometryKHR;
42986 fn deref(&self) -> &Self::Target {
42987 &self.inner
42988 }
42989}
42990impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryKHRBuilder<'a> {
42991 fn deref_mut(&mut self) -> &mut Self::Target {
42992 &mut self.inner
42993 }
42994}
42995impl<'a> AccelerationStructureGeometryKHRBuilder<'a> {
42996 pub fn geometry_type(mut self, geometry_type: GeometryTypeKHR) -> Self {
42997 self.inner.geometry_type = geometry_type;
42998 self
42999 }
43000 pub fn geometry(mut self, geometry: AccelerationStructureGeometryDataKHR) -> Self {
43001 self.inner.geometry = geometry;
43002 self
43003 }
43004 pub fn flags(mut self, flags: GeometryFlagsKHR) -> Self {
43005 self.inner.flags = flags;
43006 self
43007 }
43008 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43009 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43010 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
43011 pub fn build(self) -> AccelerationStructureGeometryKHR {
43012 self.inner
43013 }
43014}
43015#[repr(C)]
43016#[derive(Copy, Clone)]
43017#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureBuildGeometryInfoKHR.html>"]
43018pub struct AccelerationStructureBuildGeometryInfoKHR {
43019 pub s_type: StructureType,
43020 pub p_next: *const c_void,
43021 pub ty: AccelerationStructureTypeKHR,
43022 pub flags: BuildAccelerationStructureFlagsKHR,
43023 pub mode: BuildAccelerationStructureModeKHR,
43024 pub src_acceleration_structure: AccelerationStructureKHR,
43025 pub dst_acceleration_structure: AccelerationStructureKHR,
43026 pub geometry_count: u32,
43027 pub p_geometries: *const AccelerationStructureGeometryKHR,
43028 pub pp_geometries: *const *const AccelerationStructureGeometryKHR,
43029 pub scratch_data: DeviceOrHostAddressKHR,
43030}
43031#[cfg(feature = "debug")]
43032impl fmt::Debug for AccelerationStructureBuildGeometryInfoKHR {
43033 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
43034 fmt.debug_struct("AccelerationStructureBuildGeometryInfoKHR")
43035 .field("s_type", &self.s_type)
43036 .field("p_next", &self.p_next)
43037 .field("ty", &self.ty)
43038 .field("flags", &self.flags)
43039 .field("mode", &self.mode)
43040 .field(
43041 "src_acceleration_structure",
43042 &self.src_acceleration_structure,
43043 )
43044 .field(
43045 "dst_acceleration_structure",
43046 &self.dst_acceleration_structure,
43047 )
43048 .field("geometry_count", &self.geometry_count)
43049 .field("p_geometries", &self.p_geometries)
43050 .field("pp_geometries", &self.pp_geometries)
43051 .field("scratch_data", &"union")
43052 .finish()
43053 }
43054}
43055impl ::std::default::Default for AccelerationStructureBuildGeometryInfoKHR {
43056 fn default() -> Self {
43057 Self {
43058 s_type: StructureType::ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR,
43059 p_next: ::std::ptr::null(),
43060 ty: AccelerationStructureTypeKHR::default(),
43061 flags: BuildAccelerationStructureFlagsKHR::default(),
43062 mode: BuildAccelerationStructureModeKHR::default(),
43063 src_acceleration_structure: AccelerationStructureKHR::default(),
43064 dst_acceleration_structure: AccelerationStructureKHR::default(),
43065 geometry_count: u32::default(),
43066 p_geometries: ::std::ptr::null(),
43067 pp_geometries: ::std::ptr::null(),
43068 scratch_data: DeviceOrHostAddressKHR::default(),
43069 }
43070 }
43071}
43072impl AccelerationStructureBuildGeometryInfoKHR {
43073 pub fn builder<'a>() -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
43074 AccelerationStructureBuildGeometryInfoKHRBuilder {
43075 inner: Self::default(),
43076 marker: ::std::marker::PhantomData,
43077 }
43078 }
43079}
43080#[repr(transparent)]
43081pub struct AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
43082 inner: AccelerationStructureBuildGeometryInfoKHR,
43083 marker: ::std::marker::PhantomData<&'a ()>,
43084}
43085impl<'a> ::std::ops::Deref for AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
43086 type Target = AccelerationStructureBuildGeometryInfoKHR;
43087 fn deref(&self) -> &Self::Target {
43088 &self.inner
43089 }
43090}
43091impl<'a> ::std::ops::DerefMut for AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
43092 fn deref_mut(&mut self) -> &mut Self::Target {
43093 &mut self.inner
43094 }
43095}
43096impl<'a> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
43097 pub fn ty(mut self, ty: AccelerationStructureTypeKHR) -> Self {
43098 self.inner.ty = ty;
43099 self
43100 }
43101 pub fn flags(mut self, flags: BuildAccelerationStructureFlagsKHR) -> Self {
43102 self.inner.flags = flags;
43103 self
43104 }
43105 pub fn mode(mut self, mode: BuildAccelerationStructureModeKHR) -> Self {
43106 self.inner.mode = mode;
43107 self
43108 }
43109 pub fn src_acceleration_structure(
43110 mut self,
43111 src_acceleration_structure: AccelerationStructureKHR,
43112 ) -> Self {
43113 self.inner.src_acceleration_structure = src_acceleration_structure;
43114 self
43115 }
43116 pub fn dst_acceleration_structure(
43117 mut self,
43118 dst_acceleration_structure: AccelerationStructureKHR,
43119 ) -> Self {
43120 self.inner.dst_acceleration_structure = dst_acceleration_structure;
43121 self
43122 }
43123 pub fn geometries(mut self, geometries: &'a [AccelerationStructureGeometryKHR]) -> Self {
43124 self.inner.geometry_count = geometries.len() as _;
43125 self.inner.p_geometries = geometries.as_ptr();
43126 self
43127 }
43128 pub fn geometries_ptrs(
43129 mut self,
43130 geometries: &'a [&'a AccelerationStructureGeometryKHR],
43131 ) -> Self {
43132 self.inner.geometry_count = geometries.len() as _;
43133 self.inner.pp_geometries = geometries.as_ptr() as *const *const _;
43134 self
43135 }
43136 pub fn scratch_data(mut self, scratch_data: DeviceOrHostAddressKHR) -> Self {
43137 self.inner.scratch_data = scratch_data;
43138 self
43139 }
43140 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43141 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43142 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
43143 pub fn build(self) -> AccelerationStructureBuildGeometryInfoKHR {
43144 self.inner
43145 }
43146}
43147#[repr(C)]
43148#[cfg_attr(feature = "debug", derive(Debug))]
43149#[derive(Copy, Clone, Default)]
43150#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureBuildRangeInfoKHR.html>"]
43151pub struct AccelerationStructureBuildRangeInfoKHR {
43152 pub primitive_count: u32,
43153 pub primitive_offset: u32,
43154 pub first_vertex: u32,
43155 pub transform_offset: u32,
43156}
43157impl AccelerationStructureBuildRangeInfoKHR {
43158 pub fn builder<'a>() -> AccelerationStructureBuildRangeInfoKHRBuilder<'a> {
43159 AccelerationStructureBuildRangeInfoKHRBuilder {
43160 inner: Self::default(),
43161 marker: ::std::marker::PhantomData,
43162 }
43163 }
43164}
43165#[repr(transparent)]
43166pub struct AccelerationStructureBuildRangeInfoKHRBuilder<'a> {
43167 inner: AccelerationStructureBuildRangeInfoKHR,
43168 marker: ::std::marker::PhantomData<&'a ()>,
43169}
43170impl<'a> ::std::ops::Deref for AccelerationStructureBuildRangeInfoKHRBuilder<'a> {
43171 type Target = AccelerationStructureBuildRangeInfoKHR;
43172 fn deref(&self) -> &Self::Target {
43173 &self.inner
43174 }
43175}
43176impl<'a> ::std::ops::DerefMut for AccelerationStructureBuildRangeInfoKHRBuilder<'a> {
43177 fn deref_mut(&mut self) -> &mut Self::Target {
43178 &mut self.inner
43179 }
43180}
43181impl<'a> AccelerationStructureBuildRangeInfoKHRBuilder<'a> {
43182 pub fn primitive_count(mut self, primitive_count: u32) -> Self {
43183 self.inner.primitive_count = primitive_count;
43184 self
43185 }
43186 pub fn primitive_offset(mut self, primitive_offset: u32) -> Self {
43187 self.inner.primitive_offset = primitive_offset;
43188 self
43189 }
43190 pub fn first_vertex(mut self, first_vertex: u32) -> Self {
43191 self.inner.first_vertex = first_vertex;
43192 self
43193 }
43194 pub fn transform_offset(mut self, transform_offset: u32) -> Self {
43195 self.inner.transform_offset = transform_offset;
43196 self
43197 }
43198 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43199 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43200 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
43201 pub fn build(self) -> AccelerationStructureBuildRangeInfoKHR {
43202 self.inner
43203 }
43204}
43205#[repr(C)]
43206#[cfg_attr(feature = "debug", derive(Debug))]
43207#[derive(Copy, Clone)]
43208#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureCreateInfoKHR.html>"]
43209pub struct AccelerationStructureCreateInfoKHR {
43210 pub s_type: StructureType,
43211 pub p_next: *const c_void,
43212 pub create_flags: AccelerationStructureCreateFlagsKHR,
43213 pub buffer: Buffer,
43214 pub offset: DeviceSize,
43215 pub size: DeviceSize,
43216 pub ty: AccelerationStructureTypeKHR,
43217 pub device_address: DeviceAddress,
43218}
43219impl ::std::default::Default for AccelerationStructureCreateInfoKHR {
43220 fn default() -> Self {
43221 Self {
43222 s_type: StructureType::ACCELERATION_STRUCTURE_CREATE_INFO_KHR,
43223 p_next: ::std::ptr::null(),
43224 create_flags: AccelerationStructureCreateFlagsKHR::default(),
43225 buffer: Buffer::default(),
43226 offset: DeviceSize::default(),
43227 size: DeviceSize::default(),
43228 ty: AccelerationStructureTypeKHR::default(),
43229 device_address: DeviceAddress::default(),
43230 }
43231 }
43232}
43233impl AccelerationStructureCreateInfoKHR {
43234 pub fn builder<'a>() -> AccelerationStructureCreateInfoKHRBuilder<'a> {
43235 AccelerationStructureCreateInfoKHRBuilder {
43236 inner: Self::default(),
43237 marker: ::std::marker::PhantomData,
43238 }
43239 }
43240}
43241#[repr(transparent)]
43242pub struct AccelerationStructureCreateInfoKHRBuilder<'a> {
43243 inner: AccelerationStructureCreateInfoKHR,
43244 marker: ::std::marker::PhantomData<&'a ()>,
43245}
43246pub unsafe trait ExtendsAccelerationStructureCreateInfoKHR {}
43247impl<'a> ::std::ops::Deref for AccelerationStructureCreateInfoKHRBuilder<'a> {
43248 type Target = AccelerationStructureCreateInfoKHR;
43249 fn deref(&self) -> &Self::Target {
43250 &self.inner
43251 }
43252}
43253impl<'a> ::std::ops::DerefMut for AccelerationStructureCreateInfoKHRBuilder<'a> {
43254 fn deref_mut(&mut self) -> &mut Self::Target {
43255 &mut self.inner
43256 }
43257}
43258impl<'a> AccelerationStructureCreateInfoKHRBuilder<'a> {
43259 pub fn create_flags(mut self, create_flags: AccelerationStructureCreateFlagsKHR) -> Self {
43260 self.inner.create_flags = create_flags;
43261 self
43262 }
43263 pub fn buffer(mut self, buffer: Buffer) -> Self {
43264 self.inner.buffer = buffer;
43265 self
43266 }
43267 pub fn offset(mut self, offset: DeviceSize) -> Self {
43268 self.inner.offset = offset;
43269 self
43270 }
43271 pub fn size(mut self, size: DeviceSize) -> Self {
43272 self.inner.size = size;
43273 self
43274 }
43275 pub fn ty(mut self, ty: AccelerationStructureTypeKHR) -> Self {
43276 self.inner.ty = ty;
43277 self
43278 }
43279 pub fn device_address(mut self, device_address: DeviceAddress) -> Self {
43280 self.inner.device_address = device_address;
43281 self
43282 }
43283 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
43284 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
43285 #[doc = r" valid extension structs can be pushed into the chain."]
43286 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
43287 #[doc = r" chain will look like `A -> D -> B -> C`."]
43288 pub fn push_next<T: ExtendsAccelerationStructureCreateInfoKHR>(
43289 mut self,
43290 next: &'a mut T,
43291 ) -> Self {
43292 unsafe {
43293 let next_ptr = <*const T>::cast(next);
43294 let last_next = ptr_chain_iter(next).last().unwrap();
43295 (*last_next).p_next = self.inner.p_next as _;
43296 self.inner.p_next = next_ptr;
43297 }
43298 self
43299 }
43300 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43301 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43302 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
43303 pub fn build(self) -> AccelerationStructureCreateInfoKHR {
43304 self.inner
43305 }
43306}
43307#[repr(C)]
43308#[cfg_attr(feature = "debug", derive(Debug))]
43309#[derive(Copy, Clone, Default)]
43310#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAabbPositionsKHR.html>"]
43311pub struct AabbPositionsKHR {
43312 pub min_x: f32,
43313 pub min_y: f32,
43314 pub min_z: f32,
43315 pub max_x: f32,
43316 pub max_y: f32,
43317 pub max_z: f32,
43318}
43319impl AabbPositionsKHR {
43320 pub fn builder<'a>() -> AabbPositionsKHRBuilder<'a> {
43321 AabbPositionsKHRBuilder {
43322 inner: Self::default(),
43323 marker: ::std::marker::PhantomData,
43324 }
43325 }
43326}
43327#[repr(transparent)]
43328pub struct AabbPositionsKHRBuilder<'a> {
43329 inner: AabbPositionsKHR,
43330 marker: ::std::marker::PhantomData<&'a ()>,
43331}
43332impl<'a> ::std::ops::Deref for AabbPositionsKHRBuilder<'a> {
43333 type Target = AabbPositionsKHR;
43334 fn deref(&self) -> &Self::Target {
43335 &self.inner
43336 }
43337}
43338impl<'a> ::std::ops::DerefMut for AabbPositionsKHRBuilder<'a> {
43339 fn deref_mut(&mut self) -> &mut Self::Target {
43340 &mut self.inner
43341 }
43342}
43343impl<'a> AabbPositionsKHRBuilder<'a> {
43344 pub fn min_x(mut self, min_x: f32) -> Self {
43345 self.inner.min_x = min_x;
43346 self
43347 }
43348 pub fn min_y(mut self, min_y: f32) -> Self {
43349 self.inner.min_y = min_y;
43350 self
43351 }
43352 pub fn min_z(mut self, min_z: f32) -> Self {
43353 self.inner.min_z = min_z;
43354 self
43355 }
43356 pub fn max_x(mut self, max_x: f32) -> Self {
43357 self.inner.max_x = max_x;
43358 self
43359 }
43360 pub fn max_y(mut self, max_y: f32) -> Self {
43361 self.inner.max_y = max_y;
43362 self
43363 }
43364 pub fn max_z(mut self, max_z: f32) -> Self {
43365 self.inner.max_z = max_z;
43366 self
43367 }
43368 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43369 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43370 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
43371 pub fn build(self) -> AabbPositionsKHR {
43372 self.inner
43373 }
43374}
43375#[repr(C)]
43376#[derive(Copy, Clone)]
43377pub struct TransformMatrixKHR {
43378 pub matrix: [f32; 12],
43379}
43380#[repr(C)]
43381#[derive(Copy, Clone)]
43382pub union AccelerationStructureReferenceKHR {
43383 pub device_handle: DeviceAddress,
43384 pub host_handle: AccelerationStructureKHR,
43385}
43386#[repr(C)]
43387#[derive(Copy, Clone)]
43388#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureInstanceKHR.html>"]
43389pub struct AccelerationStructureInstanceKHR {
43390 pub transform: TransformMatrixKHR,
43391 #[doc = r" Use [`Packed24_8::new(instance_custom_index, mask)`][Packed24_8::new()] to construct this field"]
43392 pub instance_custom_index_and_mask: Packed24_8,
43393 #[doc = r" Use [`Packed24_8::new(instance_shader_binding_table_record_offset, flags)`][Packed24_8::new()] to construct this field"]
43394 pub instance_shader_binding_table_record_offset_and_flags: Packed24_8,
43395 pub acceleration_structure_reference: AccelerationStructureReferenceKHR,
43396}
43397#[repr(C)]
43398#[cfg_attr(feature = "debug", derive(Debug))]
43399#[derive(Copy, Clone)]
43400#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureDeviceAddressInfoKHR.html>"]
43401pub struct AccelerationStructureDeviceAddressInfoKHR {
43402 pub s_type: StructureType,
43403 pub p_next: *const c_void,
43404 pub acceleration_structure: AccelerationStructureKHR,
43405}
43406impl ::std::default::Default for AccelerationStructureDeviceAddressInfoKHR {
43407 fn default() -> Self {
43408 Self {
43409 s_type: StructureType::ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR,
43410 p_next: ::std::ptr::null(),
43411 acceleration_structure: AccelerationStructureKHR::default(),
43412 }
43413 }
43414}
43415impl AccelerationStructureDeviceAddressInfoKHR {
43416 pub fn builder<'a>() -> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
43417 AccelerationStructureDeviceAddressInfoKHRBuilder {
43418 inner: Self::default(),
43419 marker: ::std::marker::PhantomData,
43420 }
43421 }
43422}
43423#[repr(transparent)]
43424pub struct AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
43425 inner: AccelerationStructureDeviceAddressInfoKHR,
43426 marker: ::std::marker::PhantomData<&'a ()>,
43427}
43428impl<'a> ::std::ops::Deref for AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
43429 type Target = AccelerationStructureDeviceAddressInfoKHR;
43430 fn deref(&self) -> &Self::Target {
43431 &self.inner
43432 }
43433}
43434impl<'a> ::std::ops::DerefMut for AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
43435 fn deref_mut(&mut self) -> &mut Self::Target {
43436 &mut self.inner
43437 }
43438}
43439impl<'a> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
43440 pub fn acceleration_structure(
43441 mut self,
43442 acceleration_structure: AccelerationStructureKHR,
43443 ) -> Self {
43444 self.inner.acceleration_structure = acceleration_structure;
43445 self
43446 }
43447 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43448 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43449 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
43450 pub fn build(self) -> AccelerationStructureDeviceAddressInfoKHR {
43451 self.inner
43452 }
43453}
43454#[repr(C)]
43455#[cfg_attr(feature = "debug", derive(Debug))]
43456#[derive(Copy, Clone)]
43457#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureVersionInfoKHR.html>"]
43458pub struct AccelerationStructureVersionInfoKHR {
43459 pub s_type: StructureType,
43460 pub p_next: *const c_void,
43461 pub p_version_data: *const [u8; 2 * UUID_SIZE],
43462}
43463impl ::std::default::Default for AccelerationStructureVersionInfoKHR {
43464 fn default() -> Self {
43465 Self {
43466 s_type: StructureType::ACCELERATION_STRUCTURE_VERSION_INFO_KHR,
43467 p_next: ::std::ptr::null(),
43468 p_version_data: ::std::ptr::null(),
43469 }
43470 }
43471}
43472impl AccelerationStructureVersionInfoKHR {
43473 pub fn builder<'a>() -> AccelerationStructureVersionInfoKHRBuilder<'a> {
43474 AccelerationStructureVersionInfoKHRBuilder {
43475 inner: Self::default(),
43476 marker: ::std::marker::PhantomData,
43477 }
43478 }
43479}
43480#[repr(transparent)]
43481pub struct AccelerationStructureVersionInfoKHRBuilder<'a> {
43482 inner: AccelerationStructureVersionInfoKHR,
43483 marker: ::std::marker::PhantomData<&'a ()>,
43484}
43485impl<'a> ::std::ops::Deref for AccelerationStructureVersionInfoKHRBuilder<'a> {
43486 type Target = AccelerationStructureVersionInfoKHR;
43487 fn deref(&self) -> &Self::Target {
43488 &self.inner
43489 }
43490}
43491impl<'a> ::std::ops::DerefMut for AccelerationStructureVersionInfoKHRBuilder<'a> {
43492 fn deref_mut(&mut self) -> &mut Self::Target {
43493 &mut self.inner
43494 }
43495}
43496impl<'a> AccelerationStructureVersionInfoKHRBuilder<'a> {
43497 pub fn version_data(mut self, version_data: &'a [u8; 2 * UUID_SIZE]) -> Self {
43498 self.inner.p_version_data = version_data;
43499 self
43500 }
43501 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43502 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43503 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
43504 pub fn build(self) -> AccelerationStructureVersionInfoKHR {
43505 self.inner
43506 }
43507}
43508#[repr(C)]
43509#[cfg_attr(feature = "debug", derive(Debug))]
43510#[derive(Copy, Clone)]
43511#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyAccelerationStructureInfoKHR.html>"]
43512pub struct CopyAccelerationStructureInfoKHR {
43513 pub s_type: StructureType,
43514 pub p_next: *const c_void,
43515 pub src: AccelerationStructureKHR,
43516 pub dst: AccelerationStructureKHR,
43517 pub mode: CopyAccelerationStructureModeKHR,
43518}
43519impl ::std::default::Default for CopyAccelerationStructureInfoKHR {
43520 fn default() -> Self {
43521 Self {
43522 s_type: StructureType::COPY_ACCELERATION_STRUCTURE_INFO_KHR,
43523 p_next: ::std::ptr::null(),
43524 src: AccelerationStructureKHR::default(),
43525 dst: AccelerationStructureKHR::default(),
43526 mode: CopyAccelerationStructureModeKHR::default(),
43527 }
43528 }
43529}
43530impl CopyAccelerationStructureInfoKHR {
43531 pub fn builder<'a>() -> CopyAccelerationStructureInfoKHRBuilder<'a> {
43532 CopyAccelerationStructureInfoKHRBuilder {
43533 inner: Self::default(),
43534 marker: ::std::marker::PhantomData,
43535 }
43536 }
43537}
43538#[repr(transparent)]
43539pub struct CopyAccelerationStructureInfoKHRBuilder<'a> {
43540 inner: CopyAccelerationStructureInfoKHR,
43541 marker: ::std::marker::PhantomData<&'a ()>,
43542}
43543impl<'a> ::std::ops::Deref for CopyAccelerationStructureInfoKHRBuilder<'a> {
43544 type Target = CopyAccelerationStructureInfoKHR;
43545 fn deref(&self) -> &Self::Target {
43546 &self.inner
43547 }
43548}
43549impl<'a> ::std::ops::DerefMut for CopyAccelerationStructureInfoKHRBuilder<'a> {
43550 fn deref_mut(&mut self) -> &mut Self::Target {
43551 &mut self.inner
43552 }
43553}
43554impl<'a> CopyAccelerationStructureInfoKHRBuilder<'a> {
43555 pub fn src(mut self, src: AccelerationStructureKHR) -> Self {
43556 self.inner.src = src;
43557 self
43558 }
43559 pub fn dst(mut self, dst: AccelerationStructureKHR) -> Self {
43560 self.inner.dst = dst;
43561 self
43562 }
43563 pub fn mode(mut self, mode: CopyAccelerationStructureModeKHR) -> Self {
43564 self.inner.mode = mode;
43565 self
43566 }
43567 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43568 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43569 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
43570 pub fn build(self) -> CopyAccelerationStructureInfoKHR {
43571 self.inner
43572 }
43573}
43574#[repr(C)]
43575#[derive(Copy, Clone)]
43576#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyAccelerationStructureToMemoryInfoKHR.html>"]
43577pub struct CopyAccelerationStructureToMemoryInfoKHR {
43578 pub s_type: StructureType,
43579 pub p_next: *const c_void,
43580 pub src: AccelerationStructureKHR,
43581 pub dst: DeviceOrHostAddressKHR,
43582 pub mode: CopyAccelerationStructureModeKHR,
43583}
43584#[cfg(feature = "debug")]
43585impl fmt::Debug for CopyAccelerationStructureToMemoryInfoKHR {
43586 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
43587 fmt.debug_struct("CopyAccelerationStructureToMemoryInfoKHR")
43588 .field("s_type", &self.s_type)
43589 .field("p_next", &self.p_next)
43590 .field("src", &self.src)
43591 .field("dst", &"union")
43592 .field("mode", &self.mode)
43593 .finish()
43594 }
43595}
43596impl ::std::default::Default for CopyAccelerationStructureToMemoryInfoKHR {
43597 fn default() -> Self {
43598 Self {
43599 s_type: StructureType::COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR,
43600 p_next: ::std::ptr::null(),
43601 src: AccelerationStructureKHR::default(),
43602 dst: DeviceOrHostAddressKHR::default(),
43603 mode: CopyAccelerationStructureModeKHR::default(),
43604 }
43605 }
43606}
43607impl CopyAccelerationStructureToMemoryInfoKHR {
43608 pub fn builder<'a>() -> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
43609 CopyAccelerationStructureToMemoryInfoKHRBuilder {
43610 inner: Self::default(),
43611 marker: ::std::marker::PhantomData,
43612 }
43613 }
43614}
43615#[repr(transparent)]
43616pub struct CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
43617 inner: CopyAccelerationStructureToMemoryInfoKHR,
43618 marker: ::std::marker::PhantomData<&'a ()>,
43619}
43620impl<'a> ::std::ops::Deref for CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
43621 type Target = CopyAccelerationStructureToMemoryInfoKHR;
43622 fn deref(&self) -> &Self::Target {
43623 &self.inner
43624 }
43625}
43626impl<'a> ::std::ops::DerefMut for CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
43627 fn deref_mut(&mut self) -> &mut Self::Target {
43628 &mut self.inner
43629 }
43630}
43631impl<'a> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
43632 pub fn src(mut self, src: AccelerationStructureKHR) -> Self {
43633 self.inner.src = src;
43634 self
43635 }
43636 pub fn dst(mut self, dst: DeviceOrHostAddressKHR) -> Self {
43637 self.inner.dst = dst;
43638 self
43639 }
43640 pub fn mode(mut self, mode: CopyAccelerationStructureModeKHR) -> Self {
43641 self.inner.mode = mode;
43642 self
43643 }
43644 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43645 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43646 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
43647 pub fn build(self) -> CopyAccelerationStructureToMemoryInfoKHR {
43648 self.inner
43649 }
43650}
43651#[repr(C)]
43652#[derive(Copy, Clone)]
43653#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyMemoryToAccelerationStructureInfoKHR.html>"]
43654pub struct CopyMemoryToAccelerationStructureInfoKHR {
43655 pub s_type: StructureType,
43656 pub p_next: *const c_void,
43657 pub src: DeviceOrHostAddressConstKHR,
43658 pub dst: AccelerationStructureKHR,
43659 pub mode: CopyAccelerationStructureModeKHR,
43660}
43661#[cfg(feature = "debug")]
43662impl fmt::Debug for CopyMemoryToAccelerationStructureInfoKHR {
43663 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
43664 fmt.debug_struct("CopyMemoryToAccelerationStructureInfoKHR")
43665 .field("s_type", &self.s_type)
43666 .field("p_next", &self.p_next)
43667 .field("src", &"union")
43668 .field("dst", &self.dst)
43669 .field("mode", &self.mode)
43670 .finish()
43671 }
43672}
43673impl ::std::default::Default for CopyMemoryToAccelerationStructureInfoKHR {
43674 fn default() -> Self {
43675 Self {
43676 s_type: StructureType::COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR,
43677 p_next: ::std::ptr::null(),
43678 src: DeviceOrHostAddressConstKHR::default(),
43679 dst: AccelerationStructureKHR::default(),
43680 mode: CopyAccelerationStructureModeKHR::default(),
43681 }
43682 }
43683}
43684impl CopyMemoryToAccelerationStructureInfoKHR {
43685 pub fn builder<'a>() -> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
43686 CopyMemoryToAccelerationStructureInfoKHRBuilder {
43687 inner: Self::default(),
43688 marker: ::std::marker::PhantomData,
43689 }
43690 }
43691}
43692#[repr(transparent)]
43693pub struct CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
43694 inner: CopyMemoryToAccelerationStructureInfoKHR,
43695 marker: ::std::marker::PhantomData<&'a ()>,
43696}
43697impl<'a> ::std::ops::Deref for CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
43698 type Target = CopyMemoryToAccelerationStructureInfoKHR;
43699 fn deref(&self) -> &Self::Target {
43700 &self.inner
43701 }
43702}
43703impl<'a> ::std::ops::DerefMut for CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
43704 fn deref_mut(&mut self) -> &mut Self::Target {
43705 &mut self.inner
43706 }
43707}
43708impl<'a> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
43709 pub fn src(mut self, src: DeviceOrHostAddressConstKHR) -> Self {
43710 self.inner.src = src;
43711 self
43712 }
43713 pub fn dst(mut self, dst: AccelerationStructureKHR) -> Self {
43714 self.inner.dst = dst;
43715 self
43716 }
43717 pub fn mode(mut self, mode: CopyAccelerationStructureModeKHR) -> Self {
43718 self.inner.mode = mode;
43719 self
43720 }
43721 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43722 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43723 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
43724 pub fn build(self) -> CopyMemoryToAccelerationStructureInfoKHR {
43725 self.inner
43726 }
43727}
43728#[repr(C)]
43729#[cfg_attr(feature = "debug", derive(Debug))]
43730#[derive(Copy, Clone)]
43731#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRayTracingPipelineInterfaceCreateInfoKHR.html>"]
43732pub struct RayTracingPipelineInterfaceCreateInfoKHR {
43733 pub s_type: StructureType,
43734 pub p_next: *const c_void,
43735 pub max_pipeline_ray_payload_size: u32,
43736 pub max_pipeline_ray_hit_attribute_size: u32,
43737}
43738impl ::std::default::Default for RayTracingPipelineInterfaceCreateInfoKHR {
43739 fn default() -> Self {
43740 Self {
43741 s_type: StructureType::RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR,
43742 p_next: ::std::ptr::null(),
43743 max_pipeline_ray_payload_size: u32::default(),
43744 max_pipeline_ray_hit_attribute_size: u32::default(),
43745 }
43746 }
43747}
43748impl RayTracingPipelineInterfaceCreateInfoKHR {
43749 pub fn builder<'a>() -> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
43750 RayTracingPipelineInterfaceCreateInfoKHRBuilder {
43751 inner: Self::default(),
43752 marker: ::std::marker::PhantomData,
43753 }
43754 }
43755}
43756#[repr(transparent)]
43757pub struct RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
43758 inner: RayTracingPipelineInterfaceCreateInfoKHR,
43759 marker: ::std::marker::PhantomData<&'a ()>,
43760}
43761impl<'a> ::std::ops::Deref for RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
43762 type Target = RayTracingPipelineInterfaceCreateInfoKHR;
43763 fn deref(&self) -> &Self::Target {
43764 &self.inner
43765 }
43766}
43767impl<'a> ::std::ops::DerefMut for RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
43768 fn deref_mut(&mut self) -> &mut Self::Target {
43769 &mut self.inner
43770 }
43771}
43772impl<'a> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
43773 pub fn max_pipeline_ray_payload_size(mut self, max_pipeline_ray_payload_size: u32) -> Self {
43774 self.inner.max_pipeline_ray_payload_size = max_pipeline_ray_payload_size;
43775 self
43776 }
43777 pub fn max_pipeline_ray_hit_attribute_size(
43778 mut self,
43779 max_pipeline_ray_hit_attribute_size: u32,
43780 ) -> Self {
43781 self.inner.max_pipeline_ray_hit_attribute_size = max_pipeline_ray_hit_attribute_size;
43782 self
43783 }
43784 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43785 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43786 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
43787 pub fn build(self) -> RayTracingPipelineInterfaceCreateInfoKHR {
43788 self.inner
43789 }
43790}
43791#[repr(C)]
43792#[cfg_attr(feature = "debug", derive(Debug))]
43793#[derive(Copy, Clone)]
43794#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineLibraryCreateInfoKHR.html>"]
43795pub struct PipelineLibraryCreateInfoKHR {
43796 pub s_type: StructureType,
43797 pub p_next: *const c_void,
43798 pub library_count: u32,
43799 pub p_libraries: *const Pipeline,
43800}
43801impl ::std::default::Default for PipelineLibraryCreateInfoKHR {
43802 fn default() -> Self {
43803 Self {
43804 s_type: StructureType::PIPELINE_LIBRARY_CREATE_INFO_KHR,
43805 p_next: ::std::ptr::null(),
43806 library_count: u32::default(),
43807 p_libraries: ::std::ptr::null(),
43808 }
43809 }
43810}
43811impl PipelineLibraryCreateInfoKHR {
43812 pub fn builder<'a>() -> PipelineLibraryCreateInfoKHRBuilder<'a> {
43813 PipelineLibraryCreateInfoKHRBuilder {
43814 inner: Self::default(),
43815 marker: ::std::marker::PhantomData,
43816 }
43817 }
43818}
43819#[repr(transparent)]
43820pub struct PipelineLibraryCreateInfoKHRBuilder<'a> {
43821 inner: PipelineLibraryCreateInfoKHR,
43822 marker: ::std::marker::PhantomData<&'a ()>,
43823}
43824impl<'a> ::std::ops::Deref for PipelineLibraryCreateInfoKHRBuilder<'a> {
43825 type Target = PipelineLibraryCreateInfoKHR;
43826 fn deref(&self) -> &Self::Target {
43827 &self.inner
43828 }
43829}
43830impl<'a> ::std::ops::DerefMut for PipelineLibraryCreateInfoKHRBuilder<'a> {
43831 fn deref_mut(&mut self) -> &mut Self::Target {
43832 &mut self.inner
43833 }
43834}
43835impl<'a> PipelineLibraryCreateInfoKHRBuilder<'a> {
43836 pub fn libraries(mut self, libraries: &'a [Pipeline]) -> Self {
43837 self.inner.library_count = libraries.len() as _;
43838 self.inner.p_libraries = libraries.as_ptr();
43839 self
43840 }
43841 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43842 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43843 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
43844 pub fn build(self) -> PipelineLibraryCreateInfoKHR {
43845 self.inner
43846 }
43847}
43848#[repr(C)]
43849#[cfg_attr(feature = "debug", derive(Debug))]
43850#[derive(Copy, Clone)]
43851#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExtendedDynamicStateFeaturesEXT.html>"]
43852pub struct PhysicalDeviceExtendedDynamicStateFeaturesEXT {
43853 pub s_type: StructureType,
43854 pub p_next: *mut c_void,
43855 pub extended_dynamic_state: Bool32,
43856}
43857impl ::std::default::Default for PhysicalDeviceExtendedDynamicStateFeaturesEXT {
43858 fn default() -> Self {
43859 Self {
43860 s_type: StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT,
43861 p_next: ::std::ptr::null_mut(),
43862 extended_dynamic_state: Bool32::default(),
43863 }
43864 }
43865}
43866impl PhysicalDeviceExtendedDynamicStateFeaturesEXT {
43867 pub fn builder<'a>() -> PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> {
43868 PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder {
43869 inner: Self::default(),
43870 marker: ::std::marker::PhantomData,
43871 }
43872 }
43873}
43874#[repr(transparent)]
43875pub struct PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> {
43876 inner: PhysicalDeviceExtendedDynamicStateFeaturesEXT,
43877 marker: ::std::marker::PhantomData<&'a ()>,
43878}
43879unsafe impl ExtendsPhysicalDeviceFeatures2
43880 for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'_>
43881{
43882}
43883unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExtendedDynamicStateFeaturesEXT {}
43884unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'_> {}
43885unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicStateFeaturesEXT {}
43886impl<'a> ::std::ops::Deref for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> {
43887 type Target = PhysicalDeviceExtendedDynamicStateFeaturesEXT;
43888 fn deref(&self) -> &Self::Target {
43889 &self.inner
43890 }
43891}
43892impl<'a> ::std::ops::DerefMut for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> {
43893 fn deref_mut(&mut self) -> &mut Self::Target {
43894 &mut self.inner
43895 }
43896}
43897impl<'a> PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> {
43898 pub fn extended_dynamic_state(mut self, extended_dynamic_state: bool) -> Self {
43899 self.inner.extended_dynamic_state = extended_dynamic_state.into();
43900 self
43901 }
43902 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43903 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43904 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
43905 pub fn build(self) -> PhysicalDeviceExtendedDynamicStateFeaturesEXT {
43906 self.inner
43907 }
43908}
43909#[repr(C)]
43910#[cfg_attr(feature = "debug", derive(Debug))]
43911#[derive(Copy, Clone)]
43912#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExtendedDynamicState2FeaturesEXT.html>"]
43913pub struct PhysicalDeviceExtendedDynamicState2FeaturesEXT {
43914 pub s_type: StructureType,
43915 pub p_next: *mut c_void,
43916 pub extended_dynamic_state2: Bool32,
43917 pub extended_dynamic_state2_logic_op: Bool32,
43918 pub extended_dynamic_state2_patch_control_points: Bool32,
43919}
43920impl ::std::default::Default for PhysicalDeviceExtendedDynamicState2FeaturesEXT {
43921 fn default() -> Self {
43922 Self {
43923 s_type: StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT,
43924 p_next: ::std::ptr::null_mut(),
43925 extended_dynamic_state2: Bool32::default(),
43926 extended_dynamic_state2_logic_op: Bool32::default(),
43927 extended_dynamic_state2_patch_control_points: Bool32::default(),
43928 }
43929 }
43930}
43931impl PhysicalDeviceExtendedDynamicState2FeaturesEXT {
43932 pub fn builder<'a>() -> PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> {
43933 PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder {
43934 inner: Self::default(),
43935 marker: ::std::marker::PhantomData,
43936 }
43937 }
43938}
43939#[repr(transparent)]
43940pub struct PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> {
43941 inner: PhysicalDeviceExtendedDynamicState2FeaturesEXT,
43942 marker: ::std::marker::PhantomData<&'a ()>,
43943}
43944unsafe impl ExtendsPhysicalDeviceFeatures2
43945 for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'_>
43946{
43947}
43948unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExtendedDynamicState2FeaturesEXT {}
43949unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'_> {}
43950unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicState2FeaturesEXT {}
43951impl<'a> ::std::ops::Deref for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> {
43952 type Target = PhysicalDeviceExtendedDynamicState2FeaturesEXT;
43953 fn deref(&self) -> &Self::Target {
43954 &self.inner
43955 }
43956}
43957impl<'a> ::std::ops::DerefMut for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> {
43958 fn deref_mut(&mut self) -> &mut Self::Target {
43959 &mut self.inner
43960 }
43961}
43962impl<'a> PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> {
43963 pub fn extended_dynamic_state2(mut self, extended_dynamic_state2: bool) -> Self {
43964 self.inner.extended_dynamic_state2 = extended_dynamic_state2.into();
43965 self
43966 }
43967 pub fn extended_dynamic_state2_logic_op(
43968 mut self,
43969 extended_dynamic_state2_logic_op: bool,
43970 ) -> Self {
43971 self.inner.extended_dynamic_state2_logic_op = extended_dynamic_state2_logic_op.into();
43972 self
43973 }
43974 pub fn extended_dynamic_state2_patch_control_points(
43975 mut self,
43976 extended_dynamic_state2_patch_control_points: bool,
43977 ) -> Self {
43978 self.inner.extended_dynamic_state2_patch_control_points =
43979 extended_dynamic_state2_patch_control_points.into();
43980 self
43981 }
43982 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43983 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43984 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
43985 pub fn build(self) -> PhysicalDeviceExtendedDynamicState2FeaturesEXT {
43986 self.inner
43987 }
43988}
43989#[repr(C)]
43990#[cfg_attr(feature = "debug", derive(Debug))]
43991#[derive(Copy, Clone)]
43992#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassTransformBeginInfoQCOM.html>"]
43993pub struct RenderPassTransformBeginInfoQCOM {
43994 pub s_type: StructureType,
43995 pub p_next: *mut c_void,
43996 pub transform: SurfaceTransformFlagsKHR,
43997}
43998impl ::std::default::Default for RenderPassTransformBeginInfoQCOM {
43999 fn default() -> Self {
44000 Self {
44001 s_type: StructureType::RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM,
44002 p_next: ::std::ptr::null_mut(),
44003 transform: SurfaceTransformFlagsKHR::default(),
44004 }
44005 }
44006}
44007impl RenderPassTransformBeginInfoQCOM {
44008 pub fn builder<'a>() -> RenderPassTransformBeginInfoQCOMBuilder<'a> {
44009 RenderPassTransformBeginInfoQCOMBuilder {
44010 inner: Self::default(),
44011 marker: ::std::marker::PhantomData,
44012 }
44013 }
44014}
44015#[repr(transparent)]
44016pub struct RenderPassTransformBeginInfoQCOMBuilder<'a> {
44017 inner: RenderPassTransformBeginInfoQCOM,
44018 marker: ::std::marker::PhantomData<&'a ()>,
44019}
44020unsafe impl ExtendsRenderPassBeginInfo for RenderPassTransformBeginInfoQCOMBuilder<'_> {}
44021unsafe impl ExtendsRenderPassBeginInfo for RenderPassTransformBeginInfoQCOM {}
44022impl<'a> ::std::ops::Deref for RenderPassTransformBeginInfoQCOMBuilder<'a> {
44023 type Target = RenderPassTransformBeginInfoQCOM;
44024 fn deref(&self) -> &Self::Target {
44025 &self.inner
44026 }
44027}
44028impl<'a> ::std::ops::DerefMut for RenderPassTransformBeginInfoQCOMBuilder<'a> {
44029 fn deref_mut(&mut self) -> &mut Self::Target {
44030 &mut self.inner
44031 }
44032}
44033impl<'a> RenderPassTransformBeginInfoQCOMBuilder<'a> {
44034 pub fn transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self {
44035 self.inner.transform = transform;
44036 self
44037 }
44038 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44039 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44040 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
44041 pub fn build(self) -> RenderPassTransformBeginInfoQCOM {
44042 self.inner
44043 }
44044}
44045#[repr(C)]
44046#[cfg_attr(feature = "debug", derive(Debug))]
44047#[derive(Copy, Clone)]
44048#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyCommandTransformInfoQCOM.html>"]
44049pub struct CopyCommandTransformInfoQCOM {
44050 pub s_type: StructureType,
44051 pub p_next: *const c_void,
44052 pub transform: SurfaceTransformFlagsKHR,
44053}
44054impl ::std::default::Default for CopyCommandTransformInfoQCOM {
44055 fn default() -> Self {
44056 Self {
44057 s_type: StructureType::COPY_COMMAND_TRANSFORM_INFO_QCOM,
44058 p_next: ::std::ptr::null(),
44059 transform: SurfaceTransformFlagsKHR::default(),
44060 }
44061 }
44062}
44063impl CopyCommandTransformInfoQCOM {
44064 pub fn builder<'a>() -> CopyCommandTransformInfoQCOMBuilder<'a> {
44065 CopyCommandTransformInfoQCOMBuilder {
44066 inner: Self::default(),
44067 marker: ::std::marker::PhantomData,
44068 }
44069 }
44070}
44071#[repr(transparent)]
44072pub struct CopyCommandTransformInfoQCOMBuilder<'a> {
44073 inner: CopyCommandTransformInfoQCOM,
44074 marker: ::std::marker::PhantomData<&'a ()>,
44075}
44076unsafe impl ExtendsBufferImageCopy2 for CopyCommandTransformInfoQCOMBuilder<'_> {}
44077unsafe impl ExtendsBufferImageCopy2 for CopyCommandTransformInfoQCOM {}
44078unsafe impl ExtendsImageBlit2 for CopyCommandTransformInfoQCOMBuilder<'_> {}
44079unsafe impl ExtendsImageBlit2 for CopyCommandTransformInfoQCOM {}
44080impl<'a> ::std::ops::Deref for CopyCommandTransformInfoQCOMBuilder<'a> {
44081 type Target = CopyCommandTransformInfoQCOM;
44082 fn deref(&self) -> &Self::Target {
44083 &self.inner
44084 }
44085}
44086impl<'a> ::std::ops::DerefMut for CopyCommandTransformInfoQCOMBuilder<'a> {
44087 fn deref_mut(&mut self) -> &mut Self::Target {
44088 &mut self.inner
44089 }
44090}
44091impl<'a> CopyCommandTransformInfoQCOMBuilder<'a> {
44092 pub fn transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self {
44093 self.inner.transform = transform;
44094 self
44095 }
44096 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44097 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44098 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
44099 pub fn build(self) -> CopyCommandTransformInfoQCOM {
44100 self.inner
44101 }
44102}
44103#[repr(C)]
44104#[cfg_attr(feature = "debug", derive(Debug))]
44105#[derive(Copy, Clone)]
44106#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferInheritanceRenderPassTransformInfoQCOM.html>"]
44107pub struct CommandBufferInheritanceRenderPassTransformInfoQCOM {
44108 pub s_type: StructureType,
44109 pub p_next: *mut c_void,
44110 pub transform: SurfaceTransformFlagsKHR,
44111 pub render_area: Rect2D,
44112}
44113impl ::std::default::Default for CommandBufferInheritanceRenderPassTransformInfoQCOM {
44114 fn default() -> Self {
44115 Self {
44116 s_type: StructureType::COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM,
44117 p_next: ::std::ptr::null_mut(),
44118 transform: SurfaceTransformFlagsKHR::default(),
44119 render_area: Rect2D::default(),
44120 }
44121 }
44122}
44123impl CommandBufferInheritanceRenderPassTransformInfoQCOM {
44124 pub fn builder<'a>() -> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
44125 CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder {
44126 inner: Self::default(),
44127 marker: ::std::marker::PhantomData,
44128 }
44129 }
44130}
44131#[repr(transparent)]
44132pub struct CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
44133 inner: CommandBufferInheritanceRenderPassTransformInfoQCOM,
44134 marker: ::std::marker::PhantomData<&'a ()>,
44135}
44136unsafe impl ExtendsCommandBufferInheritanceInfo
44137 for CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'_>
44138{
44139}
44140unsafe impl ExtendsCommandBufferInheritanceInfo
44141 for CommandBufferInheritanceRenderPassTransformInfoQCOM
44142{
44143}
44144impl<'a> ::std::ops::Deref for CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
44145 type Target = CommandBufferInheritanceRenderPassTransformInfoQCOM;
44146 fn deref(&self) -> &Self::Target {
44147 &self.inner
44148 }
44149}
44150impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
44151 fn deref_mut(&mut self) -> &mut Self::Target {
44152 &mut self.inner
44153 }
44154}
44155impl<'a> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
44156 pub fn transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self {
44157 self.inner.transform = transform;
44158 self
44159 }
44160 pub fn render_area(mut self, render_area: Rect2D) -> Self {
44161 self.inner.render_area = render_area;
44162 self
44163 }
44164 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44165 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44166 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
44167 pub fn build(self) -> CommandBufferInheritanceRenderPassTransformInfoQCOM {
44168 self.inner
44169 }
44170}
44171#[repr(C)]
44172#[cfg_attr(feature = "debug", derive(Debug))]
44173#[derive(Copy, Clone)]
44174#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDiagnosticsConfigFeaturesNV.html>"]
44175pub struct PhysicalDeviceDiagnosticsConfigFeaturesNV {
44176 pub s_type: StructureType,
44177 pub p_next: *mut c_void,
44178 pub diagnostics_config: Bool32,
44179}
44180impl ::std::default::Default for PhysicalDeviceDiagnosticsConfigFeaturesNV {
44181 fn default() -> Self {
44182 Self {
44183 s_type: StructureType::PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV,
44184 p_next: ::std::ptr::null_mut(),
44185 diagnostics_config: Bool32::default(),
44186 }
44187 }
44188}
44189impl PhysicalDeviceDiagnosticsConfigFeaturesNV {
44190 pub fn builder<'a>() -> PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
44191 PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder {
44192 inner: Self::default(),
44193 marker: ::std::marker::PhantomData,
44194 }
44195 }
44196}
44197#[repr(transparent)]
44198pub struct PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
44199 inner: PhysicalDeviceDiagnosticsConfigFeaturesNV,
44200 marker: ::std::marker::PhantomData<&'a ()>,
44201}
44202unsafe impl ExtendsPhysicalDeviceFeatures2
44203 for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'_>
44204{
44205}
44206unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDiagnosticsConfigFeaturesNV {}
44207unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'_> {}
44208unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDiagnosticsConfigFeaturesNV {}
44209impl<'a> ::std::ops::Deref for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
44210 type Target = PhysicalDeviceDiagnosticsConfigFeaturesNV;
44211 fn deref(&self) -> &Self::Target {
44212 &self.inner
44213 }
44214}
44215impl<'a> ::std::ops::DerefMut for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
44216 fn deref_mut(&mut self) -> &mut Self::Target {
44217 &mut self.inner
44218 }
44219}
44220impl<'a> PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
44221 pub fn diagnostics_config(mut self, diagnostics_config: bool) -> Self {
44222 self.inner.diagnostics_config = diagnostics_config.into();
44223 self
44224 }
44225 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44226 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44227 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
44228 pub fn build(self) -> PhysicalDeviceDiagnosticsConfigFeaturesNV {
44229 self.inner
44230 }
44231}
44232#[repr(C)]
44233#[cfg_attr(feature = "debug", derive(Debug))]
44234#[derive(Copy, Clone)]
44235#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceDiagnosticsConfigCreateInfoNV.html>"]
44236pub struct DeviceDiagnosticsConfigCreateInfoNV {
44237 pub s_type: StructureType,
44238 pub p_next: *const c_void,
44239 pub flags: DeviceDiagnosticsConfigFlagsNV,
44240}
44241impl ::std::default::Default for DeviceDiagnosticsConfigCreateInfoNV {
44242 fn default() -> Self {
44243 Self {
44244 s_type: StructureType::DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV,
44245 p_next: ::std::ptr::null(),
44246 flags: DeviceDiagnosticsConfigFlagsNV::default(),
44247 }
44248 }
44249}
44250impl DeviceDiagnosticsConfigCreateInfoNV {
44251 pub fn builder<'a>() -> DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
44252 DeviceDiagnosticsConfigCreateInfoNVBuilder {
44253 inner: Self::default(),
44254 marker: ::std::marker::PhantomData,
44255 }
44256 }
44257}
44258#[repr(transparent)]
44259pub struct DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
44260 inner: DeviceDiagnosticsConfigCreateInfoNV,
44261 marker: ::std::marker::PhantomData<&'a ()>,
44262}
44263unsafe impl ExtendsDeviceCreateInfo for DeviceDiagnosticsConfigCreateInfoNVBuilder<'_> {}
44264unsafe impl ExtendsDeviceCreateInfo for DeviceDiagnosticsConfigCreateInfoNV {}
44265impl<'a> ::std::ops::Deref for DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
44266 type Target = DeviceDiagnosticsConfigCreateInfoNV;
44267 fn deref(&self) -> &Self::Target {
44268 &self.inner
44269 }
44270}
44271impl<'a> ::std::ops::DerefMut for DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
44272 fn deref_mut(&mut self) -> &mut Self::Target {
44273 &mut self.inner
44274 }
44275}
44276impl<'a> DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
44277 pub fn flags(mut self, flags: DeviceDiagnosticsConfigFlagsNV) -> Self {
44278 self.inner.flags = flags;
44279 self
44280 }
44281 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44282 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44283 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
44284 pub fn build(self) -> DeviceDiagnosticsConfigCreateInfoNV {
44285 self.inner
44286 }
44287}
44288#[repr(C)]
44289#[cfg_attr(feature = "debug", derive(Debug))]
44290#[derive(Copy, Clone)]
44291#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures.html>"]
44292pub struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
44293 pub s_type: StructureType,
44294 pub p_next: *mut c_void,
44295 pub shader_zero_initialize_workgroup_memory: Bool32,
44296}
44297impl ::std::default::Default for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
44298 fn default() -> Self {
44299 Self {
44300 s_type: StructureType::PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES,
44301 p_next: ::std::ptr::null_mut(),
44302 shader_zero_initialize_workgroup_memory: Bool32::default(),
44303 }
44304 }
44305}
44306impl PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
44307 pub fn builder<'a>() -> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> {
44308 PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder {
44309 inner: Self::default(),
44310 marker: ::std::marker::PhantomData,
44311 }
44312 }
44313}
44314#[repr(transparent)]
44315pub struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> {
44316 inner: PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures,
44317 marker: ::std::marker::PhantomData<&'a ()>,
44318}
44319unsafe impl ExtendsPhysicalDeviceFeatures2
44320 for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'_>
44321{
44322}
44323unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {}
44324unsafe impl ExtendsDeviceCreateInfo
44325 for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'_>
44326{
44327}
44328unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {}
44329impl<'a> ::std::ops::Deref for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> {
44330 type Target = PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;
44331 fn deref(&self) -> &Self::Target {
44332 &self.inner
44333 }
44334}
44335impl<'a> ::std::ops::DerefMut for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> {
44336 fn deref_mut(&mut self) -> &mut Self::Target {
44337 &mut self.inner
44338 }
44339}
44340impl<'a> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> {
44341 pub fn shader_zero_initialize_workgroup_memory(
44342 mut self,
44343 shader_zero_initialize_workgroup_memory: bool,
44344 ) -> Self {
44345 self.inner.shader_zero_initialize_workgroup_memory =
44346 shader_zero_initialize_workgroup_memory.into();
44347 self
44348 }
44349 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44350 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44351 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
44352 pub fn build(self) -> PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
44353 self.inner
44354 }
44355}
44356#[repr(C)]
44357#[cfg_attr(feature = "debug", derive(Debug))]
44358#[derive(Copy, Clone)]
44359#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.html>"]
44360pub struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
44361 pub s_type: StructureType,
44362 pub p_next: *mut c_void,
44363 pub shader_subgroup_uniform_control_flow: Bool32,
44364}
44365impl ::std::default::Default for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
44366 fn default() -> Self {
44367 Self {
44368 s_type:
44369 StructureType::PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR,
44370 p_next: ::std::ptr::null_mut(),
44371 shader_subgroup_uniform_control_flow: Bool32::default(),
44372 }
44373 }
44374}
44375impl PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
44376 pub fn builder<'a>() -> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> {
44377 PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder {
44378 inner: Self::default(),
44379 marker: ::std::marker::PhantomData,
44380 }
44381 }
44382}
44383#[repr(transparent)]
44384pub struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> {
44385 inner: PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR,
44386 marker: ::std::marker::PhantomData<&'a ()>,
44387}
44388unsafe impl ExtendsPhysicalDeviceFeatures2
44389 for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'_>
44390{
44391}
44392unsafe impl ExtendsPhysicalDeviceFeatures2
44393 for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR
44394{
44395}
44396unsafe impl ExtendsDeviceCreateInfo
44397 for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'_>
44398{
44399}
44400unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {}
44401impl<'a> ::std::ops::Deref
44402 for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a>
44403{
44404 type Target = PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
44405 fn deref(&self) -> &Self::Target {
44406 &self.inner
44407 }
44408}
44409impl<'a> ::std::ops::DerefMut
44410 for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a>
44411{
44412 fn deref_mut(&mut self) -> &mut Self::Target {
44413 &mut self.inner
44414 }
44415}
44416impl<'a> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> {
44417 pub fn shader_subgroup_uniform_control_flow(
44418 mut self,
44419 shader_subgroup_uniform_control_flow: bool,
44420 ) -> Self {
44421 self.inner.shader_subgroup_uniform_control_flow =
44422 shader_subgroup_uniform_control_flow.into();
44423 self
44424 }
44425 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44426 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44427 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
44428 pub fn build(self) -> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
44429 self.inner
44430 }
44431}
44432#[repr(C)]
44433#[cfg_attr(feature = "debug", derive(Debug))]
44434#[derive(Copy, Clone)]
44435#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRobustness2FeaturesEXT.html>"]
44436pub struct PhysicalDeviceRobustness2FeaturesEXT {
44437 pub s_type: StructureType,
44438 pub p_next: *mut c_void,
44439 pub robust_buffer_access2: Bool32,
44440 pub robust_image_access2: Bool32,
44441 pub null_descriptor: Bool32,
44442}
44443impl ::std::default::Default for PhysicalDeviceRobustness2FeaturesEXT {
44444 fn default() -> Self {
44445 Self {
44446 s_type: StructureType::PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT,
44447 p_next: ::std::ptr::null_mut(),
44448 robust_buffer_access2: Bool32::default(),
44449 robust_image_access2: Bool32::default(),
44450 null_descriptor: Bool32::default(),
44451 }
44452 }
44453}
44454impl PhysicalDeviceRobustness2FeaturesEXT {
44455 pub fn builder<'a>() -> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> {
44456 PhysicalDeviceRobustness2FeaturesEXTBuilder {
44457 inner: Self::default(),
44458 marker: ::std::marker::PhantomData,
44459 }
44460 }
44461}
44462#[repr(transparent)]
44463pub struct PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> {
44464 inner: PhysicalDeviceRobustness2FeaturesEXT,
44465 marker: ::std::marker::PhantomData<&'a ()>,
44466}
44467unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRobustness2FeaturesEXTBuilder<'_> {}
44468unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRobustness2FeaturesEXT {}
44469unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRobustness2FeaturesEXTBuilder<'_> {}
44470unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRobustness2FeaturesEXT {}
44471impl<'a> ::std::ops::Deref for PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> {
44472 type Target = PhysicalDeviceRobustness2FeaturesEXT;
44473 fn deref(&self) -> &Self::Target {
44474 &self.inner
44475 }
44476}
44477impl<'a> ::std::ops::DerefMut for PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> {
44478 fn deref_mut(&mut self) -> &mut Self::Target {
44479 &mut self.inner
44480 }
44481}
44482impl<'a> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> {
44483 pub fn robust_buffer_access2(mut self, robust_buffer_access2: bool) -> Self {
44484 self.inner.robust_buffer_access2 = robust_buffer_access2.into();
44485 self
44486 }
44487 pub fn robust_image_access2(mut self, robust_image_access2: bool) -> Self {
44488 self.inner.robust_image_access2 = robust_image_access2.into();
44489 self
44490 }
44491 pub fn null_descriptor(mut self, null_descriptor: bool) -> Self {
44492 self.inner.null_descriptor = null_descriptor.into();
44493 self
44494 }
44495 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44496 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44497 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
44498 pub fn build(self) -> PhysicalDeviceRobustness2FeaturesEXT {
44499 self.inner
44500 }
44501}
44502#[repr(C)]
44503#[cfg_attr(feature = "debug", derive(Debug))]
44504#[derive(Copy, Clone)]
44505#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRobustness2PropertiesEXT.html>"]
44506pub struct PhysicalDeviceRobustness2PropertiesEXT {
44507 pub s_type: StructureType,
44508 pub p_next: *mut c_void,
44509 pub robust_storage_buffer_access_size_alignment: DeviceSize,
44510 pub robust_uniform_buffer_access_size_alignment: DeviceSize,
44511}
44512impl ::std::default::Default for PhysicalDeviceRobustness2PropertiesEXT {
44513 fn default() -> Self {
44514 Self {
44515 s_type: StructureType::PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT,
44516 p_next: ::std::ptr::null_mut(),
44517 robust_storage_buffer_access_size_alignment: DeviceSize::default(),
44518 robust_uniform_buffer_access_size_alignment: DeviceSize::default(),
44519 }
44520 }
44521}
44522impl PhysicalDeviceRobustness2PropertiesEXT {
44523 pub fn builder<'a>() -> PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> {
44524 PhysicalDeviceRobustness2PropertiesEXTBuilder {
44525 inner: Self::default(),
44526 marker: ::std::marker::PhantomData,
44527 }
44528 }
44529}
44530#[repr(transparent)]
44531pub struct PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> {
44532 inner: PhysicalDeviceRobustness2PropertiesEXT,
44533 marker: ::std::marker::PhantomData<&'a ()>,
44534}
44535unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRobustness2PropertiesEXTBuilder<'_> {}
44536unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRobustness2PropertiesEXT {}
44537impl<'a> ::std::ops::Deref for PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> {
44538 type Target = PhysicalDeviceRobustness2PropertiesEXT;
44539 fn deref(&self) -> &Self::Target {
44540 &self.inner
44541 }
44542}
44543impl<'a> ::std::ops::DerefMut for PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> {
44544 fn deref_mut(&mut self) -> &mut Self::Target {
44545 &mut self.inner
44546 }
44547}
44548impl<'a> PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> {
44549 pub fn robust_storage_buffer_access_size_alignment(
44550 mut self,
44551 robust_storage_buffer_access_size_alignment: DeviceSize,
44552 ) -> Self {
44553 self.inner.robust_storage_buffer_access_size_alignment =
44554 robust_storage_buffer_access_size_alignment;
44555 self
44556 }
44557 pub fn robust_uniform_buffer_access_size_alignment(
44558 mut self,
44559 robust_uniform_buffer_access_size_alignment: DeviceSize,
44560 ) -> Self {
44561 self.inner.robust_uniform_buffer_access_size_alignment =
44562 robust_uniform_buffer_access_size_alignment;
44563 self
44564 }
44565 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44566 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44567 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
44568 pub fn build(self) -> PhysicalDeviceRobustness2PropertiesEXT {
44569 self.inner
44570 }
44571}
44572#[repr(C)]
44573#[cfg_attr(feature = "debug", derive(Debug))]
44574#[derive(Copy, Clone)]
44575#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageRobustnessFeatures.html>"]
44576pub struct PhysicalDeviceImageRobustnessFeatures {
44577 pub s_type: StructureType,
44578 pub p_next: *mut c_void,
44579 pub robust_image_access: Bool32,
44580}
44581impl ::std::default::Default for PhysicalDeviceImageRobustnessFeatures {
44582 fn default() -> Self {
44583 Self {
44584 s_type: StructureType::PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES,
44585 p_next: ::std::ptr::null_mut(),
44586 robust_image_access: Bool32::default(),
44587 }
44588 }
44589}
44590impl PhysicalDeviceImageRobustnessFeatures {
44591 pub fn builder<'a>() -> PhysicalDeviceImageRobustnessFeaturesBuilder<'a> {
44592 PhysicalDeviceImageRobustnessFeaturesBuilder {
44593 inner: Self::default(),
44594 marker: ::std::marker::PhantomData,
44595 }
44596 }
44597}
44598#[repr(transparent)]
44599pub struct PhysicalDeviceImageRobustnessFeaturesBuilder<'a> {
44600 inner: PhysicalDeviceImageRobustnessFeatures,
44601 marker: ::std::marker::PhantomData<&'a ()>,
44602}
44603unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageRobustnessFeaturesBuilder<'_> {}
44604unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageRobustnessFeatures {}
44605unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageRobustnessFeaturesBuilder<'_> {}
44606unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageRobustnessFeatures {}
44607impl<'a> ::std::ops::Deref for PhysicalDeviceImageRobustnessFeaturesBuilder<'a> {
44608 type Target = PhysicalDeviceImageRobustnessFeatures;
44609 fn deref(&self) -> &Self::Target {
44610 &self.inner
44611 }
44612}
44613impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageRobustnessFeaturesBuilder<'a> {
44614 fn deref_mut(&mut self) -> &mut Self::Target {
44615 &mut self.inner
44616 }
44617}
44618impl<'a> PhysicalDeviceImageRobustnessFeaturesBuilder<'a> {
44619 pub fn robust_image_access(mut self, robust_image_access: bool) -> Self {
44620 self.inner.robust_image_access = robust_image_access.into();
44621 self
44622 }
44623 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44624 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44625 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
44626 pub fn build(self) -> PhysicalDeviceImageRobustnessFeatures {
44627 self.inner
44628 }
44629}
44630#[repr(C)]
44631#[cfg_attr(feature = "debug", derive(Debug))]
44632#[derive(Copy, Clone)]
44633#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.html>"]
44634pub struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
44635 pub s_type: StructureType,
44636 pub p_next: *mut c_void,
44637 pub workgroup_memory_explicit_layout: Bool32,
44638 pub workgroup_memory_explicit_layout_scalar_block_layout: Bool32,
44639 pub workgroup_memory_explicit_layout8_bit_access: Bool32,
44640 pub workgroup_memory_explicit_layout16_bit_access: Bool32,
44641}
44642impl ::std::default::Default for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
44643 fn default() -> Self {
44644 Self {
44645 s_type: StructureType::PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR,
44646 p_next: ::std::ptr::null_mut(),
44647 workgroup_memory_explicit_layout: Bool32::default(),
44648 workgroup_memory_explicit_layout_scalar_block_layout: Bool32::default(),
44649 workgroup_memory_explicit_layout8_bit_access: Bool32::default(),
44650 workgroup_memory_explicit_layout16_bit_access: Bool32::default(),
44651 }
44652 }
44653}
44654impl PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
44655 pub fn builder<'a>() -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
44656 PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder {
44657 inner: Self::default(),
44658 marker: ::std::marker::PhantomData,
44659 }
44660 }
44661}
44662#[repr(transparent)]
44663pub struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
44664 inner: PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR,
44665 marker: ::std::marker::PhantomData<&'a ()>,
44666}
44667unsafe impl ExtendsPhysicalDeviceFeatures2
44668 for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'_>
44669{
44670}
44671unsafe impl ExtendsPhysicalDeviceFeatures2
44672 for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR
44673{
44674}
44675unsafe impl ExtendsDeviceCreateInfo
44676 for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'_>
44677{
44678}
44679unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {}
44680impl<'a> ::std::ops::Deref for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
44681 type Target = PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
44682 fn deref(&self) -> &Self::Target {
44683 &self.inner
44684 }
44685}
44686impl<'a> ::std::ops::DerefMut
44687 for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a>
44688{
44689 fn deref_mut(&mut self) -> &mut Self::Target {
44690 &mut self.inner
44691 }
44692}
44693impl<'a> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
44694 pub fn workgroup_memory_explicit_layout(
44695 mut self,
44696 workgroup_memory_explicit_layout: bool,
44697 ) -> Self {
44698 self.inner.workgroup_memory_explicit_layout = workgroup_memory_explicit_layout.into();
44699 self
44700 }
44701 pub fn workgroup_memory_explicit_layout_scalar_block_layout(
44702 mut self,
44703 workgroup_memory_explicit_layout_scalar_block_layout: bool,
44704 ) -> Self {
44705 self.inner
44706 .workgroup_memory_explicit_layout_scalar_block_layout =
44707 workgroup_memory_explicit_layout_scalar_block_layout.into();
44708 self
44709 }
44710 pub fn workgroup_memory_explicit_layout8_bit_access(
44711 mut self,
44712 workgroup_memory_explicit_layout8_bit_access: bool,
44713 ) -> Self {
44714 self.inner.workgroup_memory_explicit_layout8_bit_access =
44715 workgroup_memory_explicit_layout8_bit_access.into();
44716 self
44717 }
44718 pub fn workgroup_memory_explicit_layout16_bit_access(
44719 mut self,
44720 workgroup_memory_explicit_layout16_bit_access: bool,
44721 ) -> Self {
44722 self.inner.workgroup_memory_explicit_layout16_bit_access =
44723 workgroup_memory_explicit_layout16_bit_access.into();
44724 self
44725 }
44726 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44727 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44728 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
44729 pub fn build(self) -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
44730 self.inner
44731 }
44732}
44733#[repr(C)]
44734#[cfg_attr(feature = "debug", derive(Debug))]
44735#[derive(Copy, Clone)]
44736#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePortabilitySubsetFeaturesKHR.html>"]
44737pub struct PhysicalDevicePortabilitySubsetFeaturesKHR {
44738 pub s_type: StructureType,
44739 pub p_next: *mut c_void,
44740 pub constant_alpha_color_blend_factors: Bool32,
44741 pub events: Bool32,
44742 pub image_view_format_reinterpretation: Bool32,
44743 pub image_view_format_swizzle: Bool32,
44744 pub image_view2_d_on3_d_image: Bool32,
44745 pub multisample_array_image: Bool32,
44746 pub mutable_comparison_samplers: Bool32,
44747 pub point_polygons: Bool32,
44748 pub sampler_mip_lod_bias: Bool32,
44749 pub separate_stencil_mask_ref: Bool32,
44750 pub shader_sample_rate_interpolation_functions: Bool32,
44751 pub tessellation_isolines: Bool32,
44752 pub tessellation_point_mode: Bool32,
44753 pub triangle_fans: Bool32,
44754 pub vertex_attribute_access_beyond_stride: Bool32,
44755}
44756impl ::std::default::Default for PhysicalDevicePortabilitySubsetFeaturesKHR {
44757 fn default() -> Self {
44758 Self {
44759 s_type: StructureType::PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR,
44760 p_next: ::std::ptr::null_mut(),
44761 constant_alpha_color_blend_factors: Bool32::default(),
44762 events: Bool32::default(),
44763 image_view_format_reinterpretation: Bool32::default(),
44764 image_view_format_swizzle: Bool32::default(),
44765 image_view2_d_on3_d_image: Bool32::default(),
44766 multisample_array_image: Bool32::default(),
44767 mutable_comparison_samplers: Bool32::default(),
44768 point_polygons: Bool32::default(),
44769 sampler_mip_lod_bias: Bool32::default(),
44770 separate_stencil_mask_ref: Bool32::default(),
44771 shader_sample_rate_interpolation_functions: Bool32::default(),
44772 tessellation_isolines: Bool32::default(),
44773 tessellation_point_mode: Bool32::default(),
44774 triangle_fans: Bool32::default(),
44775 vertex_attribute_access_beyond_stride: Bool32::default(),
44776 }
44777 }
44778}
44779impl PhysicalDevicePortabilitySubsetFeaturesKHR {
44780 pub fn builder<'a>() -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
44781 PhysicalDevicePortabilitySubsetFeaturesKHRBuilder {
44782 inner: Self::default(),
44783 marker: ::std::marker::PhantomData,
44784 }
44785 }
44786}
44787#[repr(transparent)]
44788pub struct PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
44789 inner: PhysicalDevicePortabilitySubsetFeaturesKHR,
44790 marker: ::std::marker::PhantomData<&'a ()>,
44791}
44792unsafe impl ExtendsPhysicalDeviceFeatures2
44793 for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'_>
44794{
44795}
44796unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePortabilitySubsetFeaturesKHR {}
44797unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'_> {}
44798unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePortabilitySubsetFeaturesKHR {}
44799impl<'a> ::std::ops::Deref for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
44800 type Target = PhysicalDevicePortabilitySubsetFeaturesKHR;
44801 fn deref(&self) -> &Self::Target {
44802 &self.inner
44803 }
44804}
44805impl<'a> ::std::ops::DerefMut for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
44806 fn deref_mut(&mut self) -> &mut Self::Target {
44807 &mut self.inner
44808 }
44809}
44810impl<'a> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
44811 pub fn constant_alpha_color_blend_factors(
44812 mut self,
44813 constant_alpha_color_blend_factors: bool,
44814 ) -> Self {
44815 self.inner.constant_alpha_color_blend_factors = constant_alpha_color_blend_factors.into();
44816 self
44817 }
44818 pub fn events(mut self, events: bool) -> Self {
44819 self.inner.events = events.into();
44820 self
44821 }
44822 pub fn image_view_format_reinterpretation(
44823 mut self,
44824 image_view_format_reinterpretation: bool,
44825 ) -> Self {
44826 self.inner.image_view_format_reinterpretation = image_view_format_reinterpretation.into();
44827 self
44828 }
44829 pub fn image_view_format_swizzle(mut self, image_view_format_swizzle: bool) -> Self {
44830 self.inner.image_view_format_swizzle = image_view_format_swizzle.into();
44831 self
44832 }
44833 pub fn image_view2_d_on3_d_image(mut self, image_view2_d_on3_d_image: bool) -> Self {
44834 self.inner.image_view2_d_on3_d_image = image_view2_d_on3_d_image.into();
44835 self
44836 }
44837 pub fn multisample_array_image(mut self, multisample_array_image: bool) -> Self {
44838 self.inner.multisample_array_image = multisample_array_image.into();
44839 self
44840 }
44841 pub fn mutable_comparison_samplers(mut self, mutable_comparison_samplers: bool) -> Self {
44842 self.inner.mutable_comparison_samplers = mutable_comparison_samplers.into();
44843 self
44844 }
44845 pub fn point_polygons(mut self, point_polygons: bool) -> Self {
44846 self.inner.point_polygons = point_polygons.into();
44847 self
44848 }
44849 pub fn sampler_mip_lod_bias(mut self, sampler_mip_lod_bias: bool) -> Self {
44850 self.inner.sampler_mip_lod_bias = sampler_mip_lod_bias.into();
44851 self
44852 }
44853 pub fn separate_stencil_mask_ref(mut self, separate_stencil_mask_ref: bool) -> Self {
44854 self.inner.separate_stencil_mask_ref = separate_stencil_mask_ref.into();
44855 self
44856 }
44857 pub fn shader_sample_rate_interpolation_functions(
44858 mut self,
44859 shader_sample_rate_interpolation_functions: bool,
44860 ) -> Self {
44861 self.inner.shader_sample_rate_interpolation_functions =
44862 shader_sample_rate_interpolation_functions.into();
44863 self
44864 }
44865 pub fn tessellation_isolines(mut self, tessellation_isolines: bool) -> Self {
44866 self.inner.tessellation_isolines = tessellation_isolines.into();
44867 self
44868 }
44869 pub fn tessellation_point_mode(mut self, tessellation_point_mode: bool) -> Self {
44870 self.inner.tessellation_point_mode = tessellation_point_mode.into();
44871 self
44872 }
44873 pub fn triangle_fans(mut self, triangle_fans: bool) -> Self {
44874 self.inner.triangle_fans = triangle_fans.into();
44875 self
44876 }
44877 pub fn vertex_attribute_access_beyond_stride(
44878 mut self,
44879 vertex_attribute_access_beyond_stride: bool,
44880 ) -> Self {
44881 self.inner.vertex_attribute_access_beyond_stride =
44882 vertex_attribute_access_beyond_stride.into();
44883 self
44884 }
44885 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44886 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44887 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
44888 pub fn build(self) -> PhysicalDevicePortabilitySubsetFeaturesKHR {
44889 self.inner
44890 }
44891}
44892#[repr(C)]
44893#[cfg_attr(feature = "debug", derive(Debug))]
44894#[derive(Copy, Clone)]
44895#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePortabilitySubsetPropertiesKHR.html>"]
44896pub struct PhysicalDevicePortabilitySubsetPropertiesKHR {
44897 pub s_type: StructureType,
44898 pub p_next: *mut c_void,
44899 pub min_vertex_input_binding_stride_alignment: u32,
44900}
44901impl ::std::default::Default for PhysicalDevicePortabilitySubsetPropertiesKHR {
44902 fn default() -> Self {
44903 Self {
44904 s_type: StructureType::PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR,
44905 p_next: ::std::ptr::null_mut(),
44906 min_vertex_input_binding_stride_alignment: u32::default(),
44907 }
44908 }
44909}
44910impl PhysicalDevicePortabilitySubsetPropertiesKHR {
44911 pub fn builder<'a>() -> PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> {
44912 PhysicalDevicePortabilitySubsetPropertiesKHRBuilder {
44913 inner: Self::default(),
44914 marker: ::std::marker::PhantomData,
44915 }
44916 }
44917}
44918#[repr(transparent)]
44919pub struct PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> {
44920 inner: PhysicalDevicePortabilitySubsetPropertiesKHR,
44921 marker: ::std::marker::PhantomData<&'a ()>,
44922}
44923unsafe impl ExtendsPhysicalDeviceProperties2
44924 for PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'_>
44925{
44926}
44927unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePortabilitySubsetPropertiesKHR {}
44928impl<'a> ::std::ops::Deref for PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> {
44929 type Target = PhysicalDevicePortabilitySubsetPropertiesKHR;
44930 fn deref(&self) -> &Self::Target {
44931 &self.inner
44932 }
44933}
44934impl<'a> ::std::ops::DerefMut for PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> {
44935 fn deref_mut(&mut self) -> &mut Self::Target {
44936 &mut self.inner
44937 }
44938}
44939impl<'a> PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> {
44940 pub fn min_vertex_input_binding_stride_alignment(
44941 mut self,
44942 min_vertex_input_binding_stride_alignment: u32,
44943 ) -> Self {
44944 self.inner.min_vertex_input_binding_stride_alignment =
44945 min_vertex_input_binding_stride_alignment;
44946 self
44947 }
44948 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44949 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44950 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
44951 pub fn build(self) -> PhysicalDevicePortabilitySubsetPropertiesKHR {
44952 self.inner
44953 }
44954}
44955#[repr(C)]
44956#[cfg_attr(feature = "debug", derive(Debug))]
44957#[derive(Copy, Clone)]
44958#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevice4444FormatsFeaturesEXT.html>"]
44959pub struct PhysicalDevice4444FormatsFeaturesEXT {
44960 pub s_type: StructureType,
44961 pub p_next: *mut c_void,
44962 pub format_a4r4g4b4: Bool32,
44963 pub format_a4b4g4r4: Bool32,
44964}
44965impl ::std::default::Default for PhysicalDevice4444FormatsFeaturesEXT {
44966 fn default() -> Self {
44967 Self {
44968 s_type: StructureType::PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT,
44969 p_next: ::std::ptr::null_mut(),
44970 format_a4r4g4b4: Bool32::default(),
44971 format_a4b4g4r4: Bool32::default(),
44972 }
44973 }
44974}
44975impl PhysicalDevice4444FormatsFeaturesEXT {
44976 pub fn builder<'a>() -> PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
44977 PhysicalDevice4444FormatsFeaturesEXTBuilder {
44978 inner: Self::default(),
44979 marker: ::std::marker::PhantomData,
44980 }
44981 }
44982}
44983#[repr(transparent)]
44984pub struct PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
44985 inner: PhysicalDevice4444FormatsFeaturesEXT,
44986 marker: ::std::marker::PhantomData<&'a ()>,
44987}
44988unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice4444FormatsFeaturesEXTBuilder<'_> {}
44989unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice4444FormatsFeaturesEXT {}
44990unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice4444FormatsFeaturesEXTBuilder<'_> {}
44991unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice4444FormatsFeaturesEXT {}
44992impl<'a> ::std::ops::Deref for PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
44993 type Target = PhysicalDevice4444FormatsFeaturesEXT;
44994 fn deref(&self) -> &Self::Target {
44995 &self.inner
44996 }
44997}
44998impl<'a> ::std::ops::DerefMut for PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
44999 fn deref_mut(&mut self) -> &mut Self::Target {
45000 &mut self.inner
45001 }
45002}
45003impl<'a> PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
45004 pub fn format_a4r4g4b4(mut self, format_a4r4g4b4: bool) -> Self {
45005 self.inner.format_a4r4g4b4 = format_a4r4g4b4.into();
45006 self
45007 }
45008 pub fn format_a4b4g4r4(mut self, format_a4b4g4r4: bool) -> Self {
45009 self.inner.format_a4b4g4r4 = format_a4b4g4r4.into();
45010 self
45011 }
45012 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45013 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45014 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
45015 pub fn build(self) -> PhysicalDevice4444FormatsFeaturesEXT {
45016 self.inner
45017 }
45018}
45019#[repr(C)]
45020#[cfg_attr(feature = "debug", derive(Debug))]
45021#[derive(Copy, Clone)]
45022#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSubpassShadingFeaturesHUAWEI.html>"]
45023pub struct PhysicalDeviceSubpassShadingFeaturesHUAWEI {
45024 pub s_type: StructureType,
45025 pub p_next: *mut c_void,
45026 pub subpass_shading: Bool32,
45027}
45028impl ::std::default::Default for PhysicalDeviceSubpassShadingFeaturesHUAWEI {
45029 fn default() -> Self {
45030 Self {
45031 s_type: StructureType::PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI,
45032 p_next: ::std::ptr::null_mut(),
45033 subpass_shading: Bool32::default(),
45034 }
45035 }
45036}
45037impl PhysicalDeviceSubpassShadingFeaturesHUAWEI {
45038 pub fn builder<'a>() -> PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> {
45039 PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder {
45040 inner: Self::default(),
45041 marker: ::std::marker::PhantomData,
45042 }
45043 }
45044}
45045#[repr(transparent)]
45046pub struct PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> {
45047 inner: PhysicalDeviceSubpassShadingFeaturesHUAWEI,
45048 marker: ::std::marker::PhantomData<&'a ()>,
45049}
45050unsafe impl ExtendsPhysicalDeviceFeatures2
45051 for PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'_>
45052{
45053}
45054unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSubpassShadingFeaturesHUAWEI {}
45055unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'_> {}
45056unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubpassShadingFeaturesHUAWEI {}
45057impl<'a> ::std::ops::Deref for PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> {
45058 type Target = PhysicalDeviceSubpassShadingFeaturesHUAWEI;
45059 fn deref(&self) -> &Self::Target {
45060 &self.inner
45061 }
45062}
45063impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> {
45064 fn deref_mut(&mut self) -> &mut Self::Target {
45065 &mut self.inner
45066 }
45067}
45068impl<'a> PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> {
45069 pub fn subpass_shading(mut self, subpass_shading: bool) -> Self {
45070 self.inner.subpass_shading = subpass_shading.into();
45071 self
45072 }
45073 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45074 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45075 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
45076 pub fn build(self) -> PhysicalDeviceSubpassShadingFeaturesHUAWEI {
45077 self.inner
45078 }
45079}
45080#[repr(C)]
45081#[cfg_attr(feature = "debug", derive(Debug))]
45082#[derive(Copy, Clone)]
45083#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCopy2.html>"]
45084pub struct BufferCopy2 {
45085 pub s_type: StructureType,
45086 pub p_next: *const c_void,
45087 pub src_offset: DeviceSize,
45088 pub dst_offset: DeviceSize,
45089 pub size: DeviceSize,
45090}
45091impl ::std::default::Default for BufferCopy2 {
45092 fn default() -> Self {
45093 Self {
45094 s_type: StructureType::BUFFER_COPY_2,
45095 p_next: ::std::ptr::null(),
45096 src_offset: DeviceSize::default(),
45097 dst_offset: DeviceSize::default(),
45098 size: DeviceSize::default(),
45099 }
45100 }
45101}
45102impl BufferCopy2 {
45103 pub fn builder<'a>() -> BufferCopy2Builder<'a> {
45104 BufferCopy2Builder {
45105 inner: Self::default(),
45106 marker: ::std::marker::PhantomData,
45107 }
45108 }
45109}
45110#[repr(transparent)]
45111pub struct BufferCopy2Builder<'a> {
45112 inner: BufferCopy2,
45113 marker: ::std::marker::PhantomData<&'a ()>,
45114}
45115impl<'a> ::std::ops::Deref for BufferCopy2Builder<'a> {
45116 type Target = BufferCopy2;
45117 fn deref(&self) -> &Self::Target {
45118 &self.inner
45119 }
45120}
45121impl<'a> ::std::ops::DerefMut for BufferCopy2Builder<'a> {
45122 fn deref_mut(&mut self) -> &mut Self::Target {
45123 &mut self.inner
45124 }
45125}
45126impl<'a> BufferCopy2Builder<'a> {
45127 pub fn src_offset(mut self, src_offset: DeviceSize) -> Self {
45128 self.inner.src_offset = src_offset;
45129 self
45130 }
45131 pub fn dst_offset(mut self, dst_offset: DeviceSize) -> Self {
45132 self.inner.dst_offset = dst_offset;
45133 self
45134 }
45135 pub fn size(mut self, size: DeviceSize) -> Self {
45136 self.inner.size = size;
45137 self
45138 }
45139 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45140 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45141 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
45142 pub fn build(self) -> BufferCopy2 {
45143 self.inner
45144 }
45145}
45146#[repr(C)]
45147#[cfg_attr(feature = "debug", derive(Debug))]
45148#[derive(Copy, Clone)]
45149#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCopy2.html>"]
45150pub struct ImageCopy2 {
45151 pub s_type: StructureType,
45152 pub p_next: *const c_void,
45153 pub src_subresource: ImageSubresourceLayers,
45154 pub src_offset: Offset3D,
45155 pub dst_subresource: ImageSubresourceLayers,
45156 pub dst_offset: Offset3D,
45157 pub extent: Extent3D,
45158}
45159impl ::std::default::Default for ImageCopy2 {
45160 fn default() -> Self {
45161 Self {
45162 s_type: StructureType::IMAGE_COPY_2,
45163 p_next: ::std::ptr::null(),
45164 src_subresource: ImageSubresourceLayers::default(),
45165 src_offset: Offset3D::default(),
45166 dst_subresource: ImageSubresourceLayers::default(),
45167 dst_offset: Offset3D::default(),
45168 extent: Extent3D::default(),
45169 }
45170 }
45171}
45172impl ImageCopy2 {
45173 pub fn builder<'a>() -> ImageCopy2Builder<'a> {
45174 ImageCopy2Builder {
45175 inner: Self::default(),
45176 marker: ::std::marker::PhantomData,
45177 }
45178 }
45179}
45180#[repr(transparent)]
45181pub struct ImageCopy2Builder<'a> {
45182 inner: ImageCopy2,
45183 marker: ::std::marker::PhantomData<&'a ()>,
45184}
45185impl<'a> ::std::ops::Deref for ImageCopy2Builder<'a> {
45186 type Target = ImageCopy2;
45187 fn deref(&self) -> &Self::Target {
45188 &self.inner
45189 }
45190}
45191impl<'a> ::std::ops::DerefMut for ImageCopy2Builder<'a> {
45192 fn deref_mut(&mut self) -> &mut Self::Target {
45193 &mut self.inner
45194 }
45195}
45196impl<'a> ImageCopy2Builder<'a> {
45197 pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self {
45198 self.inner.src_subresource = src_subresource;
45199 self
45200 }
45201 pub fn src_offset(mut self, src_offset: Offset3D) -> Self {
45202 self.inner.src_offset = src_offset;
45203 self
45204 }
45205 pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self {
45206 self.inner.dst_subresource = dst_subresource;
45207 self
45208 }
45209 pub fn dst_offset(mut self, dst_offset: Offset3D) -> Self {
45210 self.inner.dst_offset = dst_offset;
45211 self
45212 }
45213 pub fn extent(mut self, extent: Extent3D) -> Self {
45214 self.inner.extent = extent;
45215 self
45216 }
45217 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45218 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45219 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
45220 pub fn build(self) -> ImageCopy2 {
45221 self.inner
45222 }
45223}
45224#[repr(C)]
45225#[cfg_attr(feature = "debug", derive(Debug))]
45226#[derive(Copy, Clone)]
45227#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageBlit2.html>"]
45228pub struct ImageBlit2 {
45229 pub s_type: StructureType,
45230 pub p_next: *const c_void,
45231 pub src_subresource: ImageSubresourceLayers,
45232 pub src_offsets: [Offset3D; 2],
45233 pub dst_subresource: ImageSubresourceLayers,
45234 pub dst_offsets: [Offset3D; 2],
45235}
45236impl ::std::default::Default for ImageBlit2 {
45237 fn default() -> Self {
45238 Self {
45239 s_type: StructureType::IMAGE_BLIT_2,
45240 p_next: ::std::ptr::null(),
45241 src_subresource: ImageSubresourceLayers::default(),
45242 src_offsets: unsafe { ::std::mem::zeroed() },
45243 dst_subresource: ImageSubresourceLayers::default(),
45244 dst_offsets: unsafe { ::std::mem::zeroed() },
45245 }
45246 }
45247}
45248impl ImageBlit2 {
45249 pub fn builder<'a>() -> ImageBlit2Builder<'a> {
45250 ImageBlit2Builder {
45251 inner: Self::default(),
45252 marker: ::std::marker::PhantomData,
45253 }
45254 }
45255}
45256#[repr(transparent)]
45257pub struct ImageBlit2Builder<'a> {
45258 inner: ImageBlit2,
45259 marker: ::std::marker::PhantomData<&'a ()>,
45260}
45261pub unsafe trait ExtendsImageBlit2 {}
45262impl<'a> ::std::ops::Deref for ImageBlit2Builder<'a> {
45263 type Target = ImageBlit2;
45264 fn deref(&self) -> &Self::Target {
45265 &self.inner
45266 }
45267}
45268impl<'a> ::std::ops::DerefMut for ImageBlit2Builder<'a> {
45269 fn deref_mut(&mut self) -> &mut Self::Target {
45270 &mut self.inner
45271 }
45272}
45273impl<'a> ImageBlit2Builder<'a> {
45274 pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self {
45275 self.inner.src_subresource = src_subresource;
45276 self
45277 }
45278 pub fn src_offsets(mut self, src_offsets: [Offset3D; 2]) -> Self {
45279 self.inner.src_offsets = src_offsets;
45280 self
45281 }
45282 pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self {
45283 self.inner.dst_subresource = dst_subresource;
45284 self
45285 }
45286 pub fn dst_offsets(mut self, dst_offsets: [Offset3D; 2]) -> Self {
45287 self.inner.dst_offsets = dst_offsets;
45288 self
45289 }
45290 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
45291 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
45292 #[doc = r" valid extension structs can be pushed into the chain."]
45293 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
45294 #[doc = r" chain will look like `A -> D -> B -> C`."]
45295 pub fn push_next<T: ExtendsImageBlit2>(mut self, next: &'a mut T) -> Self {
45296 unsafe {
45297 let next_ptr = <*const T>::cast(next);
45298 let last_next = ptr_chain_iter(next).last().unwrap();
45299 (*last_next).p_next = self.inner.p_next as _;
45300 self.inner.p_next = next_ptr;
45301 }
45302 self
45303 }
45304 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45305 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45306 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
45307 pub fn build(self) -> ImageBlit2 {
45308 self.inner
45309 }
45310}
45311#[repr(C)]
45312#[cfg_attr(feature = "debug", derive(Debug))]
45313#[derive(Copy, Clone)]
45314#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferImageCopy2.html>"]
45315pub struct BufferImageCopy2 {
45316 pub s_type: StructureType,
45317 pub p_next: *const c_void,
45318 pub buffer_offset: DeviceSize,
45319 pub buffer_row_length: u32,
45320 pub buffer_image_height: u32,
45321 pub image_subresource: ImageSubresourceLayers,
45322 pub image_offset: Offset3D,
45323 pub image_extent: Extent3D,
45324}
45325impl ::std::default::Default for BufferImageCopy2 {
45326 fn default() -> Self {
45327 Self {
45328 s_type: StructureType::BUFFER_IMAGE_COPY_2,
45329 p_next: ::std::ptr::null(),
45330 buffer_offset: DeviceSize::default(),
45331 buffer_row_length: u32::default(),
45332 buffer_image_height: u32::default(),
45333 image_subresource: ImageSubresourceLayers::default(),
45334 image_offset: Offset3D::default(),
45335 image_extent: Extent3D::default(),
45336 }
45337 }
45338}
45339impl BufferImageCopy2 {
45340 pub fn builder<'a>() -> BufferImageCopy2Builder<'a> {
45341 BufferImageCopy2Builder {
45342 inner: Self::default(),
45343 marker: ::std::marker::PhantomData,
45344 }
45345 }
45346}
45347#[repr(transparent)]
45348pub struct BufferImageCopy2Builder<'a> {
45349 inner: BufferImageCopy2,
45350 marker: ::std::marker::PhantomData<&'a ()>,
45351}
45352pub unsafe trait ExtendsBufferImageCopy2 {}
45353impl<'a> ::std::ops::Deref for BufferImageCopy2Builder<'a> {
45354 type Target = BufferImageCopy2;
45355 fn deref(&self) -> &Self::Target {
45356 &self.inner
45357 }
45358}
45359impl<'a> ::std::ops::DerefMut for BufferImageCopy2Builder<'a> {
45360 fn deref_mut(&mut self) -> &mut Self::Target {
45361 &mut self.inner
45362 }
45363}
45364impl<'a> BufferImageCopy2Builder<'a> {
45365 pub fn buffer_offset(mut self, buffer_offset: DeviceSize) -> Self {
45366 self.inner.buffer_offset = buffer_offset;
45367 self
45368 }
45369 pub fn buffer_row_length(mut self, buffer_row_length: u32) -> Self {
45370 self.inner.buffer_row_length = buffer_row_length;
45371 self
45372 }
45373 pub fn buffer_image_height(mut self, buffer_image_height: u32) -> Self {
45374 self.inner.buffer_image_height = buffer_image_height;
45375 self
45376 }
45377 pub fn image_subresource(mut self, image_subresource: ImageSubresourceLayers) -> Self {
45378 self.inner.image_subresource = image_subresource;
45379 self
45380 }
45381 pub fn image_offset(mut self, image_offset: Offset3D) -> Self {
45382 self.inner.image_offset = image_offset;
45383 self
45384 }
45385 pub fn image_extent(mut self, image_extent: Extent3D) -> Self {
45386 self.inner.image_extent = image_extent;
45387 self
45388 }
45389 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
45390 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
45391 #[doc = r" valid extension structs can be pushed into the chain."]
45392 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
45393 #[doc = r" chain will look like `A -> D -> B -> C`."]
45394 pub fn push_next<T: ExtendsBufferImageCopy2>(mut self, next: &'a mut T) -> Self {
45395 unsafe {
45396 let next_ptr = <*const T>::cast(next);
45397 let last_next = ptr_chain_iter(next).last().unwrap();
45398 (*last_next).p_next = self.inner.p_next as _;
45399 self.inner.p_next = next_ptr;
45400 }
45401 self
45402 }
45403 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45404 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45405 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
45406 pub fn build(self) -> BufferImageCopy2 {
45407 self.inner
45408 }
45409}
45410#[repr(C)]
45411#[cfg_attr(feature = "debug", derive(Debug))]
45412#[derive(Copy, Clone)]
45413#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageResolve2.html>"]
45414pub struct ImageResolve2 {
45415 pub s_type: StructureType,
45416 pub p_next: *const c_void,
45417 pub src_subresource: ImageSubresourceLayers,
45418 pub src_offset: Offset3D,
45419 pub dst_subresource: ImageSubresourceLayers,
45420 pub dst_offset: Offset3D,
45421 pub extent: Extent3D,
45422}
45423impl ::std::default::Default for ImageResolve2 {
45424 fn default() -> Self {
45425 Self {
45426 s_type: StructureType::IMAGE_RESOLVE_2,
45427 p_next: ::std::ptr::null(),
45428 src_subresource: ImageSubresourceLayers::default(),
45429 src_offset: Offset3D::default(),
45430 dst_subresource: ImageSubresourceLayers::default(),
45431 dst_offset: Offset3D::default(),
45432 extent: Extent3D::default(),
45433 }
45434 }
45435}
45436impl ImageResolve2 {
45437 pub fn builder<'a>() -> ImageResolve2Builder<'a> {
45438 ImageResolve2Builder {
45439 inner: Self::default(),
45440 marker: ::std::marker::PhantomData,
45441 }
45442 }
45443}
45444#[repr(transparent)]
45445pub struct ImageResolve2Builder<'a> {
45446 inner: ImageResolve2,
45447 marker: ::std::marker::PhantomData<&'a ()>,
45448}
45449impl<'a> ::std::ops::Deref for ImageResolve2Builder<'a> {
45450 type Target = ImageResolve2;
45451 fn deref(&self) -> &Self::Target {
45452 &self.inner
45453 }
45454}
45455impl<'a> ::std::ops::DerefMut for ImageResolve2Builder<'a> {
45456 fn deref_mut(&mut self) -> &mut Self::Target {
45457 &mut self.inner
45458 }
45459}
45460impl<'a> ImageResolve2Builder<'a> {
45461 pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self {
45462 self.inner.src_subresource = src_subresource;
45463 self
45464 }
45465 pub fn src_offset(mut self, src_offset: Offset3D) -> Self {
45466 self.inner.src_offset = src_offset;
45467 self
45468 }
45469 pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self {
45470 self.inner.dst_subresource = dst_subresource;
45471 self
45472 }
45473 pub fn dst_offset(mut self, dst_offset: Offset3D) -> Self {
45474 self.inner.dst_offset = dst_offset;
45475 self
45476 }
45477 pub fn extent(mut self, extent: Extent3D) -> Self {
45478 self.inner.extent = extent;
45479 self
45480 }
45481 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45482 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45483 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
45484 pub fn build(self) -> ImageResolve2 {
45485 self.inner
45486 }
45487}
45488#[repr(C)]
45489#[cfg_attr(feature = "debug", derive(Debug))]
45490#[derive(Copy, Clone)]
45491#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyBufferInfo2.html>"]
45492pub struct CopyBufferInfo2 {
45493 pub s_type: StructureType,
45494 pub p_next: *const c_void,
45495 pub src_buffer: Buffer,
45496 pub dst_buffer: Buffer,
45497 pub region_count: u32,
45498 pub p_regions: *const BufferCopy2,
45499}
45500impl ::std::default::Default for CopyBufferInfo2 {
45501 fn default() -> Self {
45502 Self {
45503 s_type: StructureType::COPY_BUFFER_INFO_2,
45504 p_next: ::std::ptr::null(),
45505 src_buffer: Buffer::default(),
45506 dst_buffer: Buffer::default(),
45507 region_count: u32::default(),
45508 p_regions: ::std::ptr::null(),
45509 }
45510 }
45511}
45512impl CopyBufferInfo2 {
45513 pub fn builder<'a>() -> CopyBufferInfo2Builder<'a> {
45514 CopyBufferInfo2Builder {
45515 inner: Self::default(),
45516 marker: ::std::marker::PhantomData,
45517 }
45518 }
45519}
45520#[repr(transparent)]
45521pub struct CopyBufferInfo2Builder<'a> {
45522 inner: CopyBufferInfo2,
45523 marker: ::std::marker::PhantomData<&'a ()>,
45524}
45525impl<'a> ::std::ops::Deref for CopyBufferInfo2Builder<'a> {
45526 type Target = CopyBufferInfo2;
45527 fn deref(&self) -> &Self::Target {
45528 &self.inner
45529 }
45530}
45531impl<'a> ::std::ops::DerefMut for CopyBufferInfo2Builder<'a> {
45532 fn deref_mut(&mut self) -> &mut Self::Target {
45533 &mut self.inner
45534 }
45535}
45536impl<'a> CopyBufferInfo2Builder<'a> {
45537 pub fn src_buffer(mut self, src_buffer: Buffer) -> Self {
45538 self.inner.src_buffer = src_buffer;
45539 self
45540 }
45541 pub fn dst_buffer(mut self, dst_buffer: Buffer) -> Self {
45542 self.inner.dst_buffer = dst_buffer;
45543 self
45544 }
45545 pub fn regions(mut self, regions: &'a [BufferCopy2]) -> Self {
45546 self.inner.region_count = regions.len() as _;
45547 self.inner.p_regions = regions.as_ptr();
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."]
45553 pub fn build(self) -> CopyBufferInfo2 {
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/VkCopyImageInfo2.html>"]
45561pub struct CopyImageInfo2 {
45562 pub s_type: StructureType,
45563 pub p_next: *const c_void,
45564 pub src_image: Image,
45565 pub src_image_layout: ImageLayout,
45566 pub dst_image: Image,
45567 pub dst_image_layout: ImageLayout,
45568 pub region_count: u32,
45569 pub p_regions: *const ImageCopy2,
45570}
45571impl ::std::default::Default for CopyImageInfo2 {
45572 fn default() -> Self {
45573 Self {
45574 s_type: StructureType::COPY_IMAGE_INFO_2,
45575 p_next: ::std::ptr::null(),
45576 src_image: Image::default(),
45577 src_image_layout: ImageLayout::default(),
45578 dst_image: Image::default(),
45579 dst_image_layout: ImageLayout::default(),
45580 region_count: u32::default(),
45581 p_regions: ::std::ptr::null(),
45582 }
45583 }
45584}
45585impl CopyImageInfo2 {
45586 pub fn builder<'a>() -> CopyImageInfo2Builder<'a> {
45587 CopyImageInfo2Builder {
45588 inner: Self::default(),
45589 marker: ::std::marker::PhantomData,
45590 }
45591 }
45592}
45593#[repr(transparent)]
45594pub struct CopyImageInfo2Builder<'a> {
45595 inner: CopyImageInfo2,
45596 marker: ::std::marker::PhantomData<&'a ()>,
45597}
45598impl<'a> ::std::ops::Deref for CopyImageInfo2Builder<'a> {
45599 type Target = CopyImageInfo2;
45600 fn deref(&self) -> &Self::Target {
45601 &self.inner
45602 }
45603}
45604impl<'a> ::std::ops::DerefMut for CopyImageInfo2Builder<'a> {
45605 fn deref_mut(&mut self) -> &mut Self::Target {
45606 &mut self.inner
45607 }
45608}
45609impl<'a> CopyImageInfo2Builder<'a> {
45610 pub fn src_image(mut self, src_image: Image) -> Self {
45611 self.inner.src_image = src_image;
45612 self
45613 }
45614 pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self {
45615 self.inner.src_image_layout = src_image_layout;
45616 self
45617 }
45618 pub fn dst_image(mut self, dst_image: Image) -> Self {
45619 self.inner.dst_image = dst_image;
45620 self
45621 }
45622 pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self {
45623 self.inner.dst_image_layout = dst_image_layout;
45624 self
45625 }
45626 pub fn regions(mut self, regions: &'a [ImageCopy2]) -> Self {
45627 self.inner.region_count = regions.len() as _;
45628 self.inner.p_regions = regions.as_ptr();
45629 self
45630 }
45631 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45632 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45633 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
45634 pub fn build(self) -> CopyImageInfo2 {
45635 self.inner
45636 }
45637}
45638#[repr(C)]
45639#[cfg_attr(feature = "debug", derive(Debug))]
45640#[derive(Copy, Clone)]
45641#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBlitImageInfo2.html>"]
45642pub struct BlitImageInfo2 {
45643 pub s_type: StructureType,
45644 pub p_next: *const c_void,
45645 pub src_image: Image,
45646 pub src_image_layout: ImageLayout,
45647 pub dst_image: Image,
45648 pub dst_image_layout: ImageLayout,
45649 pub region_count: u32,
45650 pub p_regions: *const ImageBlit2,
45651 pub filter: Filter,
45652}
45653impl ::std::default::Default for BlitImageInfo2 {
45654 fn default() -> Self {
45655 Self {
45656 s_type: StructureType::BLIT_IMAGE_INFO_2,
45657 p_next: ::std::ptr::null(),
45658 src_image: Image::default(),
45659 src_image_layout: ImageLayout::default(),
45660 dst_image: Image::default(),
45661 dst_image_layout: ImageLayout::default(),
45662 region_count: u32::default(),
45663 p_regions: ::std::ptr::null(),
45664 filter: Filter::default(),
45665 }
45666 }
45667}
45668impl BlitImageInfo2 {
45669 pub fn builder<'a>() -> BlitImageInfo2Builder<'a> {
45670 BlitImageInfo2Builder {
45671 inner: Self::default(),
45672 marker: ::std::marker::PhantomData,
45673 }
45674 }
45675}
45676#[repr(transparent)]
45677pub struct BlitImageInfo2Builder<'a> {
45678 inner: BlitImageInfo2,
45679 marker: ::std::marker::PhantomData<&'a ()>,
45680}
45681impl<'a> ::std::ops::Deref for BlitImageInfo2Builder<'a> {
45682 type Target = BlitImageInfo2;
45683 fn deref(&self) -> &Self::Target {
45684 &self.inner
45685 }
45686}
45687impl<'a> ::std::ops::DerefMut for BlitImageInfo2Builder<'a> {
45688 fn deref_mut(&mut self) -> &mut Self::Target {
45689 &mut self.inner
45690 }
45691}
45692impl<'a> BlitImageInfo2Builder<'a> {
45693 pub fn src_image(mut self, src_image: Image) -> Self {
45694 self.inner.src_image = src_image;
45695 self
45696 }
45697 pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self {
45698 self.inner.src_image_layout = src_image_layout;
45699 self
45700 }
45701 pub fn dst_image(mut self, dst_image: Image) -> Self {
45702 self.inner.dst_image = dst_image;
45703 self
45704 }
45705 pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self {
45706 self.inner.dst_image_layout = dst_image_layout;
45707 self
45708 }
45709 pub fn regions(mut self, regions: &'a [ImageBlit2]) -> Self {
45710 self.inner.region_count = regions.len() as _;
45711 self.inner.p_regions = regions.as_ptr();
45712 self
45713 }
45714 pub fn filter(mut self, filter: Filter) -> Self {
45715 self.inner.filter = filter;
45716 self
45717 }
45718 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45719 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45720 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
45721 pub fn build(self) -> BlitImageInfo2 {
45722 self.inner
45723 }
45724}
45725#[repr(C)]
45726#[cfg_attr(feature = "debug", derive(Debug))]
45727#[derive(Copy, Clone)]
45728#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyBufferToImageInfo2.html>"]
45729pub struct CopyBufferToImageInfo2 {
45730 pub s_type: StructureType,
45731 pub p_next: *const c_void,
45732 pub src_buffer: Buffer,
45733 pub dst_image: Image,
45734 pub dst_image_layout: ImageLayout,
45735 pub region_count: u32,
45736 pub p_regions: *const BufferImageCopy2,
45737}
45738impl ::std::default::Default for CopyBufferToImageInfo2 {
45739 fn default() -> Self {
45740 Self {
45741 s_type: StructureType::COPY_BUFFER_TO_IMAGE_INFO_2,
45742 p_next: ::std::ptr::null(),
45743 src_buffer: Buffer::default(),
45744 dst_image: Image::default(),
45745 dst_image_layout: ImageLayout::default(),
45746 region_count: u32::default(),
45747 p_regions: ::std::ptr::null(),
45748 }
45749 }
45750}
45751impl CopyBufferToImageInfo2 {
45752 pub fn builder<'a>() -> CopyBufferToImageInfo2Builder<'a> {
45753 CopyBufferToImageInfo2Builder {
45754 inner: Self::default(),
45755 marker: ::std::marker::PhantomData,
45756 }
45757 }
45758}
45759#[repr(transparent)]
45760pub struct CopyBufferToImageInfo2Builder<'a> {
45761 inner: CopyBufferToImageInfo2,
45762 marker: ::std::marker::PhantomData<&'a ()>,
45763}
45764impl<'a> ::std::ops::Deref for CopyBufferToImageInfo2Builder<'a> {
45765 type Target = CopyBufferToImageInfo2;
45766 fn deref(&self) -> &Self::Target {
45767 &self.inner
45768 }
45769}
45770impl<'a> ::std::ops::DerefMut for CopyBufferToImageInfo2Builder<'a> {
45771 fn deref_mut(&mut self) -> &mut Self::Target {
45772 &mut self.inner
45773 }
45774}
45775impl<'a> CopyBufferToImageInfo2Builder<'a> {
45776 pub fn src_buffer(mut self, src_buffer: Buffer) -> Self {
45777 self.inner.src_buffer = src_buffer;
45778 self
45779 }
45780 pub fn dst_image(mut self, dst_image: Image) -> Self {
45781 self.inner.dst_image = dst_image;
45782 self
45783 }
45784 pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self {
45785 self.inner.dst_image_layout = dst_image_layout;
45786 self
45787 }
45788 pub fn regions(mut self, regions: &'a [BufferImageCopy2]) -> Self {
45789 self.inner.region_count = regions.len() as _;
45790 self.inner.p_regions = regions.as_ptr();
45791 self
45792 }
45793 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45794 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45795 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
45796 pub fn build(self) -> CopyBufferToImageInfo2 {
45797 self.inner
45798 }
45799}
45800#[repr(C)]
45801#[cfg_attr(feature = "debug", derive(Debug))]
45802#[derive(Copy, Clone)]
45803#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyImageToBufferInfo2.html>"]
45804pub struct CopyImageToBufferInfo2 {
45805 pub s_type: StructureType,
45806 pub p_next: *const c_void,
45807 pub src_image: Image,
45808 pub src_image_layout: ImageLayout,
45809 pub dst_buffer: Buffer,
45810 pub region_count: u32,
45811 pub p_regions: *const BufferImageCopy2,
45812}
45813impl ::std::default::Default for CopyImageToBufferInfo2 {
45814 fn default() -> Self {
45815 Self {
45816 s_type: StructureType::COPY_IMAGE_TO_BUFFER_INFO_2,
45817 p_next: ::std::ptr::null(),
45818 src_image: Image::default(),
45819 src_image_layout: ImageLayout::default(),
45820 dst_buffer: Buffer::default(),
45821 region_count: u32::default(),
45822 p_regions: ::std::ptr::null(),
45823 }
45824 }
45825}
45826impl CopyImageToBufferInfo2 {
45827 pub fn builder<'a>() -> CopyImageToBufferInfo2Builder<'a> {
45828 CopyImageToBufferInfo2Builder {
45829 inner: Self::default(),
45830 marker: ::std::marker::PhantomData,
45831 }
45832 }
45833}
45834#[repr(transparent)]
45835pub struct CopyImageToBufferInfo2Builder<'a> {
45836 inner: CopyImageToBufferInfo2,
45837 marker: ::std::marker::PhantomData<&'a ()>,
45838}
45839impl<'a> ::std::ops::Deref for CopyImageToBufferInfo2Builder<'a> {
45840 type Target = CopyImageToBufferInfo2;
45841 fn deref(&self) -> &Self::Target {
45842 &self.inner
45843 }
45844}
45845impl<'a> ::std::ops::DerefMut for CopyImageToBufferInfo2Builder<'a> {
45846 fn deref_mut(&mut self) -> &mut Self::Target {
45847 &mut self.inner
45848 }
45849}
45850impl<'a> CopyImageToBufferInfo2Builder<'a> {
45851 pub fn src_image(mut self, src_image: Image) -> Self {
45852 self.inner.src_image = src_image;
45853 self
45854 }
45855 pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self {
45856 self.inner.src_image_layout = src_image_layout;
45857 self
45858 }
45859 pub fn dst_buffer(mut self, dst_buffer: Buffer) -> Self {
45860 self.inner.dst_buffer = dst_buffer;
45861 self
45862 }
45863 pub fn regions(mut self, regions: &'a [BufferImageCopy2]) -> Self {
45864 self.inner.region_count = regions.len() as _;
45865 self.inner.p_regions = regions.as_ptr();
45866 self
45867 }
45868 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45869 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45870 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
45871 pub fn build(self) -> CopyImageToBufferInfo2 {
45872 self.inner
45873 }
45874}
45875#[repr(C)]
45876#[cfg_attr(feature = "debug", derive(Debug))]
45877#[derive(Copy, Clone)]
45878#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkResolveImageInfo2.html>"]
45879pub struct ResolveImageInfo2 {
45880 pub s_type: StructureType,
45881 pub p_next: *const c_void,
45882 pub src_image: Image,
45883 pub src_image_layout: ImageLayout,
45884 pub dst_image: Image,
45885 pub dst_image_layout: ImageLayout,
45886 pub region_count: u32,
45887 pub p_regions: *const ImageResolve2,
45888}
45889impl ::std::default::Default for ResolveImageInfo2 {
45890 fn default() -> Self {
45891 Self {
45892 s_type: StructureType::RESOLVE_IMAGE_INFO_2,
45893 p_next: ::std::ptr::null(),
45894 src_image: Image::default(),
45895 src_image_layout: ImageLayout::default(),
45896 dst_image: Image::default(),
45897 dst_image_layout: ImageLayout::default(),
45898 region_count: u32::default(),
45899 p_regions: ::std::ptr::null(),
45900 }
45901 }
45902}
45903impl ResolveImageInfo2 {
45904 pub fn builder<'a>() -> ResolveImageInfo2Builder<'a> {
45905 ResolveImageInfo2Builder {
45906 inner: Self::default(),
45907 marker: ::std::marker::PhantomData,
45908 }
45909 }
45910}
45911#[repr(transparent)]
45912pub struct ResolveImageInfo2Builder<'a> {
45913 inner: ResolveImageInfo2,
45914 marker: ::std::marker::PhantomData<&'a ()>,
45915}
45916impl<'a> ::std::ops::Deref for ResolveImageInfo2Builder<'a> {
45917 type Target = ResolveImageInfo2;
45918 fn deref(&self) -> &Self::Target {
45919 &self.inner
45920 }
45921}
45922impl<'a> ::std::ops::DerefMut for ResolveImageInfo2Builder<'a> {
45923 fn deref_mut(&mut self) -> &mut Self::Target {
45924 &mut self.inner
45925 }
45926}
45927impl<'a> ResolveImageInfo2Builder<'a> {
45928 pub fn src_image(mut self, src_image: Image) -> Self {
45929 self.inner.src_image = src_image;
45930 self
45931 }
45932 pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self {
45933 self.inner.src_image_layout = src_image_layout;
45934 self
45935 }
45936 pub fn dst_image(mut self, dst_image: Image) -> Self {
45937 self.inner.dst_image = dst_image;
45938 self
45939 }
45940 pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self {
45941 self.inner.dst_image_layout = dst_image_layout;
45942 self
45943 }
45944 pub fn regions(mut self, regions: &'a [ImageResolve2]) -> Self {
45945 self.inner.region_count = regions.len() as _;
45946 self.inner.p_regions = regions.as_ptr();
45947 self
45948 }
45949 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45950 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45951 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
45952 pub fn build(self) -> ResolveImageInfo2 {
45953 self.inner
45954 }
45955}
45956#[repr(C)]
45957#[cfg_attr(feature = "debug", derive(Debug))]
45958#[derive(Copy, Clone)]
45959#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT.html>"]
45960pub struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
45961 pub s_type: StructureType,
45962 pub p_next: *mut c_void,
45963 pub shader_image_int64_atomics: Bool32,
45964 pub sparse_image_int64_atomics: Bool32,
45965}
45966impl ::std::default::Default for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
45967 fn default() -> Self {
45968 Self {
45969 s_type: StructureType::PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT,
45970 p_next: ::std::ptr::null_mut(),
45971 shader_image_int64_atomics: Bool32::default(),
45972 sparse_image_int64_atomics: Bool32::default(),
45973 }
45974 }
45975}
45976impl PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
45977 pub fn builder<'a>() -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
45978 PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder {
45979 inner: Self::default(),
45980 marker: ::std::marker::PhantomData,
45981 }
45982 }
45983}
45984#[repr(transparent)]
45985pub struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
45986 inner: PhysicalDeviceShaderImageAtomicInt64FeaturesEXT,
45987 marker: ::std::marker::PhantomData<&'a ()>,
45988}
45989unsafe impl ExtendsPhysicalDeviceFeatures2
45990 for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'_>
45991{
45992}
45993unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {}
45994unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'_> {}
45995unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {}
45996impl<'a> ::std::ops::Deref for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
45997 type Target = PhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
45998 fn deref(&self) -> &Self::Target {
45999 &self.inner
46000 }
46001}
46002impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
46003 fn deref_mut(&mut self) -> &mut Self::Target {
46004 &mut self.inner
46005 }
46006}
46007impl<'a> PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
46008 pub fn shader_image_int64_atomics(mut self, shader_image_int64_atomics: bool) -> Self {
46009 self.inner.shader_image_int64_atomics = shader_image_int64_atomics.into();
46010 self
46011 }
46012 pub fn sparse_image_int64_atomics(mut self, sparse_image_int64_atomics: bool) -> Self {
46013 self.inner.sparse_image_int64_atomics = sparse_image_int64_atomics.into();
46014 self
46015 }
46016 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46017 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46018 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
46019 pub fn build(self) -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
46020 self.inner
46021 }
46022}
46023#[repr(C)]
46024#[cfg_attr(feature = "debug", derive(Debug))]
46025#[derive(Copy, Clone)]
46026#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFragmentShadingRateAttachmentInfoKHR.html>"]
46027pub struct FragmentShadingRateAttachmentInfoKHR {
46028 pub s_type: StructureType,
46029 pub p_next: *const c_void,
46030 pub p_fragment_shading_rate_attachment: *const AttachmentReference2,
46031 pub shading_rate_attachment_texel_size: Extent2D,
46032}
46033impl ::std::default::Default for FragmentShadingRateAttachmentInfoKHR {
46034 fn default() -> Self {
46035 Self {
46036 s_type: StructureType::FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR,
46037 p_next: ::std::ptr::null(),
46038 p_fragment_shading_rate_attachment: ::std::ptr::null(),
46039 shading_rate_attachment_texel_size: Extent2D::default(),
46040 }
46041 }
46042}
46043impl FragmentShadingRateAttachmentInfoKHR {
46044 pub fn builder<'a>() -> FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
46045 FragmentShadingRateAttachmentInfoKHRBuilder {
46046 inner: Self::default(),
46047 marker: ::std::marker::PhantomData,
46048 }
46049 }
46050}
46051#[repr(transparent)]
46052pub struct FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
46053 inner: FragmentShadingRateAttachmentInfoKHR,
46054 marker: ::std::marker::PhantomData<&'a ()>,
46055}
46056unsafe impl ExtendsSubpassDescription2 for FragmentShadingRateAttachmentInfoKHRBuilder<'_> {}
46057unsafe impl ExtendsSubpassDescription2 for FragmentShadingRateAttachmentInfoKHR {}
46058impl<'a> ::std::ops::Deref for FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
46059 type Target = FragmentShadingRateAttachmentInfoKHR;
46060 fn deref(&self) -> &Self::Target {
46061 &self.inner
46062 }
46063}
46064impl<'a> ::std::ops::DerefMut for FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
46065 fn deref_mut(&mut self) -> &mut Self::Target {
46066 &mut self.inner
46067 }
46068}
46069impl<'a> FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
46070 pub fn fragment_shading_rate_attachment(
46071 mut self,
46072 fragment_shading_rate_attachment: &'a AttachmentReference2,
46073 ) -> Self {
46074 self.inner.p_fragment_shading_rate_attachment = fragment_shading_rate_attachment;
46075 self
46076 }
46077 pub fn shading_rate_attachment_texel_size(
46078 mut self,
46079 shading_rate_attachment_texel_size: Extent2D,
46080 ) -> Self {
46081 self.inner.shading_rate_attachment_texel_size = shading_rate_attachment_texel_size;
46082 self
46083 }
46084 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46085 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46086 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
46087 pub fn build(self) -> FragmentShadingRateAttachmentInfoKHR {
46088 self.inner
46089 }
46090}
46091#[repr(C)]
46092#[cfg_attr(feature = "debug", derive(Debug))]
46093#[derive(Copy, Clone)]
46094#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineFragmentShadingRateStateCreateInfoKHR.html>"]
46095pub struct PipelineFragmentShadingRateStateCreateInfoKHR {
46096 pub s_type: StructureType,
46097 pub p_next: *const c_void,
46098 pub fragment_size: Extent2D,
46099 pub combiner_ops: [FragmentShadingRateCombinerOpKHR; 2],
46100}
46101impl ::std::default::Default for PipelineFragmentShadingRateStateCreateInfoKHR {
46102 fn default() -> Self {
46103 Self {
46104 s_type: StructureType::PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR,
46105 p_next: ::std::ptr::null(),
46106 fragment_size: Extent2D::default(),
46107 combiner_ops: unsafe { ::std::mem::zeroed() },
46108 }
46109 }
46110}
46111impl PipelineFragmentShadingRateStateCreateInfoKHR {
46112 pub fn builder<'a>() -> PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
46113 PipelineFragmentShadingRateStateCreateInfoKHRBuilder {
46114 inner: Self::default(),
46115 marker: ::std::marker::PhantomData,
46116 }
46117 }
46118}
46119#[repr(transparent)]
46120pub struct PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
46121 inner: PipelineFragmentShadingRateStateCreateInfoKHR,
46122 marker: ::std::marker::PhantomData<&'a ()>,
46123}
46124unsafe impl ExtendsGraphicsPipelineCreateInfo
46125 for PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'_>
46126{
46127}
46128unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineFragmentShadingRateStateCreateInfoKHR {}
46129impl<'a> ::std::ops::Deref for PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
46130 type Target = PipelineFragmentShadingRateStateCreateInfoKHR;
46131 fn deref(&self) -> &Self::Target {
46132 &self.inner
46133 }
46134}
46135impl<'a> ::std::ops::DerefMut for PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
46136 fn deref_mut(&mut self) -> &mut Self::Target {
46137 &mut self.inner
46138 }
46139}
46140impl<'a> PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
46141 pub fn fragment_size(mut self, fragment_size: Extent2D) -> Self {
46142 self.inner.fragment_size = fragment_size;
46143 self
46144 }
46145 pub fn combiner_ops(mut self, combiner_ops: [FragmentShadingRateCombinerOpKHR; 2]) -> Self {
46146 self.inner.combiner_ops = combiner_ops;
46147 self
46148 }
46149 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46150 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46151 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
46152 pub fn build(self) -> PipelineFragmentShadingRateStateCreateInfoKHR {
46153 self.inner
46154 }
46155}
46156#[repr(C)]
46157#[cfg_attr(feature = "debug", derive(Debug))]
46158#[derive(Copy, Clone)]
46159#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShadingRateFeaturesKHR.html>"]
46160pub struct PhysicalDeviceFragmentShadingRateFeaturesKHR {
46161 pub s_type: StructureType,
46162 pub p_next: *mut c_void,
46163 pub pipeline_fragment_shading_rate: Bool32,
46164 pub primitive_fragment_shading_rate: Bool32,
46165 pub attachment_fragment_shading_rate: Bool32,
46166}
46167impl ::std::default::Default for PhysicalDeviceFragmentShadingRateFeaturesKHR {
46168 fn default() -> Self {
46169 Self {
46170 s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR,
46171 p_next: ::std::ptr::null_mut(),
46172 pipeline_fragment_shading_rate: Bool32::default(),
46173 primitive_fragment_shading_rate: Bool32::default(),
46174 attachment_fragment_shading_rate: Bool32::default(),
46175 }
46176 }
46177}
46178impl PhysicalDeviceFragmentShadingRateFeaturesKHR {
46179 pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
46180 PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder {
46181 inner: Self::default(),
46182 marker: ::std::marker::PhantomData,
46183 }
46184 }
46185}
46186#[repr(transparent)]
46187pub struct PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
46188 inner: PhysicalDeviceFragmentShadingRateFeaturesKHR,
46189 marker: ::std::marker::PhantomData<&'a ()>,
46190}
46191unsafe impl ExtendsPhysicalDeviceFeatures2
46192 for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'_>
46193{
46194}
46195unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShadingRateFeaturesKHR {}
46196unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'_> {}
46197unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateFeaturesKHR {}
46198impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
46199 type Target = PhysicalDeviceFragmentShadingRateFeaturesKHR;
46200 fn deref(&self) -> &Self::Target {
46201 &self.inner
46202 }
46203}
46204impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
46205 fn deref_mut(&mut self) -> &mut Self::Target {
46206 &mut self.inner
46207 }
46208}
46209impl<'a> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
46210 pub fn pipeline_fragment_shading_rate(mut self, pipeline_fragment_shading_rate: bool) -> Self {
46211 self.inner.pipeline_fragment_shading_rate = pipeline_fragment_shading_rate.into();
46212 self
46213 }
46214 pub fn primitive_fragment_shading_rate(
46215 mut self,
46216 primitive_fragment_shading_rate: bool,
46217 ) -> Self {
46218 self.inner.primitive_fragment_shading_rate = primitive_fragment_shading_rate.into();
46219 self
46220 }
46221 pub fn attachment_fragment_shading_rate(
46222 mut self,
46223 attachment_fragment_shading_rate: bool,
46224 ) -> Self {
46225 self.inner.attachment_fragment_shading_rate = attachment_fragment_shading_rate.into();
46226 self
46227 }
46228 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46229 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46230 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
46231 pub fn build(self) -> PhysicalDeviceFragmentShadingRateFeaturesKHR {
46232 self.inner
46233 }
46234}
46235#[repr(C)]
46236#[cfg_attr(feature = "debug", derive(Debug))]
46237#[derive(Copy, Clone)]
46238#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShadingRatePropertiesKHR.html>"]
46239pub struct PhysicalDeviceFragmentShadingRatePropertiesKHR {
46240 pub s_type: StructureType,
46241 pub p_next: *mut c_void,
46242 pub min_fragment_shading_rate_attachment_texel_size: Extent2D,
46243 pub max_fragment_shading_rate_attachment_texel_size: Extent2D,
46244 pub max_fragment_shading_rate_attachment_texel_size_aspect_ratio: u32,
46245 pub primitive_fragment_shading_rate_with_multiple_viewports: Bool32,
46246 pub layered_shading_rate_attachments: Bool32,
46247 pub fragment_shading_rate_non_trivial_combiner_ops: Bool32,
46248 pub max_fragment_size: Extent2D,
46249 pub max_fragment_size_aspect_ratio: u32,
46250 pub max_fragment_shading_rate_coverage_samples: u32,
46251 pub max_fragment_shading_rate_rasterization_samples: SampleCountFlags,
46252 pub fragment_shading_rate_with_shader_depth_stencil_writes: Bool32,
46253 pub fragment_shading_rate_with_sample_mask: Bool32,
46254 pub fragment_shading_rate_with_shader_sample_mask: Bool32,
46255 pub fragment_shading_rate_with_conservative_rasterization: Bool32,
46256 pub fragment_shading_rate_with_fragment_shader_interlock: Bool32,
46257 pub fragment_shading_rate_with_custom_sample_locations: Bool32,
46258 pub fragment_shading_rate_strict_multiply_combiner: Bool32,
46259}
46260impl ::std::default::Default for PhysicalDeviceFragmentShadingRatePropertiesKHR {
46261 fn default() -> Self {
46262 Self {
46263 s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR,
46264 p_next: ::std::ptr::null_mut(),
46265 min_fragment_shading_rate_attachment_texel_size: Extent2D::default(),
46266 max_fragment_shading_rate_attachment_texel_size: Extent2D::default(),
46267 max_fragment_shading_rate_attachment_texel_size_aspect_ratio: u32::default(),
46268 primitive_fragment_shading_rate_with_multiple_viewports: Bool32::default(),
46269 layered_shading_rate_attachments: Bool32::default(),
46270 fragment_shading_rate_non_trivial_combiner_ops: Bool32::default(),
46271 max_fragment_size: Extent2D::default(),
46272 max_fragment_size_aspect_ratio: u32::default(),
46273 max_fragment_shading_rate_coverage_samples: u32::default(),
46274 max_fragment_shading_rate_rasterization_samples: SampleCountFlags::default(),
46275 fragment_shading_rate_with_shader_depth_stencil_writes: Bool32::default(),
46276 fragment_shading_rate_with_sample_mask: Bool32::default(),
46277 fragment_shading_rate_with_shader_sample_mask: Bool32::default(),
46278 fragment_shading_rate_with_conservative_rasterization: Bool32::default(),
46279 fragment_shading_rate_with_fragment_shader_interlock: Bool32::default(),
46280 fragment_shading_rate_with_custom_sample_locations: Bool32::default(),
46281 fragment_shading_rate_strict_multiply_combiner: Bool32::default(),
46282 }
46283 }
46284}
46285impl PhysicalDeviceFragmentShadingRatePropertiesKHR {
46286 pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
46287 PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder {
46288 inner: Self::default(),
46289 marker: ::std::marker::PhantomData,
46290 }
46291 }
46292}
46293#[repr(transparent)]
46294pub struct PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
46295 inner: PhysicalDeviceFragmentShadingRatePropertiesKHR,
46296 marker: ::std::marker::PhantomData<&'a ()>,
46297}
46298unsafe impl ExtendsPhysicalDeviceProperties2
46299 for PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'_>
46300{
46301}
46302unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentShadingRatePropertiesKHR {}
46303impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
46304 type Target = PhysicalDeviceFragmentShadingRatePropertiesKHR;
46305 fn deref(&self) -> &Self::Target {
46306 &self.inner
46307 }
46308}
46309impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
46310 fn deref_mut(&mut self) -> &mut Self::Target {
46311 &mut self.inner
46312 }
46313}
46314impl<'a> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
46315 pub fn min_fragment_shading_rate_attachment_texel_size(
46316 mut self,
46317 min_fragment_shading_rate_attachment_texel_size: Extent2D,
46318 ) -> Self {
46319 self.inner.min_fragment_shading_rate_attachment_texel_size =
46320 min_fragment_shading_rate_attachment_texel_size;
46321 self
46322 }
46323 pub fn max_fragment_shading_rate_attachment_texel_size(
46324 mut self,
46325 max_fragment_shading_rate_attachment_texel_size: Extent2D,
46326 ) -> Self {
46327 self.inner.max_fragment_shading_rate_attachment_texel_size =
46328 max_fragment_shading_rate_attachment_texel_size;
46329 self
46330 }
46331 pub fn max_fragment_shading_rate_attachment_texel_size_aspect_ratio(
46332 mut self,
46333 max_fragment_shading_rate_attachment_texel_size_aspect_ratio: u32,
46334 ) -> Self {
46335 self.inner
46336 .max_fragment_shading_rate_attachment_texel_size_aspect_ratio =
46337 max_fragment_shading_rate_attachment_texel_size_aspect_ratio;
46338 self
46339 }
46340 pub fn primitive_fragment_shading_rate_with_multiple_viewports(
46341 mut self,
46342 primitive_fragment_shading_rate_with_multiple_viewports: bool,
46343 ) -> Self {
46344 self.inner
46345 .primitive_fragment_shading_rate_with_multiple_viewports =
46346 primitive_fragment_shading_rate_with_multiple_viewports.into();
46347 self
46348 }
46349 pub fn layered_shading_rate_attachments(
46350 mut self,
46351 layered_shading_rate_attachments: bool,
46352 ) -> Self {
46353 self.inner.layered_shading_rate_attachments = layered_shading_rate_attachments.into();
46354 self
46355 }
46356 pub fn fragment_shading_rate_non_trivial_combiner_ops(
46357 mut self,
46358 fragment_shading_rate_non_trivial_combiner_ops: bool,
46359 ) -> Self {
46360 self.inner.fragment_shading_rate_non_trivial_combiner_ops =
46361 fragment_shading_rate_non_trivial_combiner_ops.into();
46362 self
46363 }
46364 pub fn max_fragment_size(mut self, max_fragment_size: Extent2D) -> Self {
46365 self.inner.max_fragment_size = max_fragment_size;
46366 self
46367 }
46368 pub fn max_fragment_size_aspect_ratio(mut self, max_fragment_size_aspect_ratio: u32) -> Self {
46369 self.inner.max_fragment_size_aspect_ratio = max_fragment_size_aspect_ratio;
46370 self
46371 }
46372 pub fn max_fragment_shading_rate_coverage_samples(
46373 mut self,
46374 max_fragment_shading_rate_coverage_samples: u32,
46375 ) -> Self {
46376 self.inner.max_fragment_shading_rate_coverage_samples =
46377 max_fragment_shading_rate_coverage_samples;
46378 self
46379 }
46380 pub fn max_fragment_shading_rate_rasterization_samples(
46381 mut self,
46382 max_fragment_shading_rate_rasterization_samples: SampleCountFlags,
46383 ) -> Self {
46384 self.inner.max_fragment_shading_rate_rasterization_samples =
46385 max_fragment_shading_rate_rasterization_samples;
46386 self
46387 }
46388 pub fn fragment_shading_rate_with_shader_depth_stencil_writes(
46389 mut self,
46390 fragment_shading_rate_with_shader_depth_stencil_writes: bool,
46391 ) -> Self {
46392 self.inner
46393 .fragment_shading_rate_with_shader_depth_stencil_writes =
46394 fragment_shading_rate_with_shader_depth_stencil_writes.into();
46395 self
46396 }
46397 pub fn fragment_shading_rate_with_sample_mask(
46398 mut self,
46399 fragment_shading_rate_with_sample_mask: bool,
46400 ) -> Self {
46401 self.inner.fragment_shading_rate_with_sample_mask =
46402 fragment_shading_rate_with_sample_mask.into();
46403 self
46404 }
46405 pub fn fragment_shading_rate_with_shader_sample_mask(
46406 mut self,
46407 fragment_shading_rate_with_shader_sample_mask: bool,
46408 ) -> Self {
46409 self.inner.fragment_shading_rate_with_shader_sample_mask =
46410 fragment_shading_rate_with_shader_sample_mask.into();
46411 self
46412 }
46413 pub fn fragment_shading_rate_with_conservative_rasterization(
46414 mut self,
46415 fragment_shading_rate_with_conservative_rasterization: bool,
46416 ) -> Self {
46417 self.inner
46418 .fragment_shading_rate_with_conservative_rasterization =
46419 fragment_shading_rate_with_conservative_rasterization.into();
46420 self
46421 }
46422 pub fn fragment_shading_rate_with_fragment_shader_interlock(
46423 mut self,
46424 fragment_shading_rate_with_fragment_shader_interlock: bool,
46425 ) -> Self {
46426 self.inner
46427 .fragment_shading_rate_with_fragment_shader_interlock =
46428 fragment_shading_rate_with_fragment_shader_interlock.into();
46429 self
46430 }
46431 pub fn fragment_shading_rate_with_custom_sample_locations(
46432 mut self,
46433 fragment_shading_rate_with_custom_sample_locations: bool,
46434 ) -> Self {
46435 self.inner
46436 .fragment_shading_rate_with_custom_sample_locations =
46437 fragment_shading_rate_with_custom_sample_locations.into();
46438 self
46439 }
46440 pub fn fragment_shading_rate_strict_multiply_combiner(
46441 mut self,
46442 fragment_shading_rate_strict_multiply_combiner: bool,
46443 ) -> Self {
46444 self.inner.fragment_shading_rate_strict_multiply_combiner =
46445 fragment_shading_rate_strict_multiply_combiner.into();
46446 self
46447 }
46448 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46449 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46450 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
46451 pub fn build(self) -> PhysicalDeviceFragmentShadingRatePropertiesKHR {
46452 self.inner
46453 }
46454}
46455#[repr(C)]
46456#[cfg_attr(feature = "debug", derive(Debug))]
46457#[derive(Copy, Clone)]
46458#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShadingRateKHR.html>"]
46459pub struct PhysicalDeviceFragmentShadingRateKHR {
46460 pub s_type: StructureType,
46461 pub p_next: *mut c_void,
46462 pub sample_counts: SampleCountFlags,
46463 pub fragment_size: Extent2D,
46464}
46465impl ::std::default::Default for PhysicalDeviceFragmentShadingRateKHR {
46466 fn default() -> Self {
46467 Self {
46468 s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR,
46469 p_next: ::std::ptr::null_mut(),
46470 sample_counts: SampleCountFlags::default(),
46471 fragment_size: Extent2D::default(),
46472 }
46473 }
46474}
46475impl PhysicalDeviceFragmentShadingRateKHR {
46476 pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
46477 PhysicalDeviceFragmentShadingRateKHRBuilder {
46478 inner: Self::default(),
46479 marker: ::std::marker::PhantomData,
46480 }
46481 }
46482}
46483#[repr(transparent)]
46484pub struct PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
46485 inner: PhysicalDeviceFragmentShadingRateKHR,
46486 marker: ::std::marker::PhantomData<&'a ()>,
46487}
46488impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
46489 type Target = PhysicalDeviceFragmentShadingRateKHR;
46490 fn deref(&self) -> &Self::Target {
46491 &self.inner
46492 }
46493}
46494impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
46495 fn deref_mut(&mut self) -> &mut Self::Target {
46496 &mut self.inner
46497 }
46498}
46499impl<'a> PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
46500 pub fn sample_counts(mut self, sample_counts: SampleCountFlags) -> Self {
46501 self.inner.sample_counts = sample_counts;
46502 self
46503 }
46504 pub fn fragment_size(mut self, fragment_size: Extent2D) -> Self {
46505 self.inner.fragment_size = fragment_size;
46506 self
46507 }
46508 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46509 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46510 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
46511 pub fn build(self) -> PhysicalDeviceFragmentShadingRateKHR {
46512 self.inner
46513 }
46514}
46515#[repr(C)]
46516#[cfg_attr(feature = "debug", derive(Debug))]
46517#[derive(Copy, Clone)]
46518#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderTerminateInvocationFeatures.html>"]
46519pub struct PhysicalDeviceShaderTerminateInvocationFeatures {
46520 pub s_type: StructureType,
46521 pub p_next: *mut c_void,
46522 pub shader_terminate_invocation: Bool32,
46523}
46524impl ::std::default::Default for PhysicalDeviceShaderTerminateInvocationFeatures {
46525 fn default() -> Self {
46526 Self {
46527 s_type: StructureType::PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES,
46528 p_next: ::std::ptr::null_mut(),
46529 shader_terminate_invocation: Bool32::default(),
46530 }
46531 }
46532}
46533impl PhysicalDeviceShaderTerminateInvocationFeatures {
46534 pub fn builder<'a>() -> PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> {
46535 PhysicalDeviceShaderTerminateInvocationFeaturesBuilder {
46536 inner: Self::default(),
46537 marker: ::std::marker::PhantomData,
46538 }
46539 }
46540}
46541#[repr(transparent)]
46542pub struct PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> {
46543 inner: PhysicalDeviceShaderTerminateInvocationFeatures,
46544 marker: ::std::marker::PhantomData<&'a ()>,
46545}
46546unsafe impl ExtendsPhysicalDeviceFeatures2
46547 for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'_>
46548{
46549}
46550unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderTerminateInvocationFeatures {}
46551unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'_> {}
46552unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderTerminateInvocationFeatures {}
46553impl<'a> ::std::ops::Deref for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> {
46554 type Target = PhysicalDeviceShaderTerminateInvocationFeatures;
46555 fn deref(&self) -> &Self::Target {
46556 &self.inner
46557 }
46558}
46559impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> {
46560 fn deref_mut(&mut self) -> &mut Self::Target {
46561 &mut self.inner
46562 }
46563}
46564impl<'a> PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> {
46565 pub fn shader_terminate_invocation(mut self, shader_terminate_invocation: bool) -> Self {
46566 self.inner.shader_terminate_invocation = shader_terminate_invocation.into();
46567 self
46568 }
46569 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46570 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46571 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
46572 pub fn build(self) -> PhysicalDeviceShaderTerminateInvocationFeatures {
46573 self.inner
46574 }
46575}
46576#[repr(C)]
46577#[cfg_attr(feature = "debug", derive(Debug))]
46578#[derive(Copy, Clone)]
46579#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV.html>"]
46580pub struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
46581 pub s_type: StructureType,
46582 pub p_next: *mut c_void,
46583 pub fragment_shading_rate_enums: Bool32,
46584 pub supersample_fragment_shading_rates: Bool32,
46585 pub no_invocation_fragment_shading_rates: Bool32,
46586}
46587impl ::std::default::Default for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
46588 fn default() -> Self {
46589 Self {
46590 s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV,
46591 p_next: ::std::ptr::null_mut(),
46592 fragment_shading_rate_enums: Bool32::default(),
46593 supersample_fragment_shading_rates: Bool32::default(),
46594 no_invocation_fragment_shading_rates: Bool32::default(),
46595 }
46596 }
46597}
46598impl PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
46599 pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
46600 PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder {
46601 inner: Self::default(),
46602 marker: ::std::marker::PhantomData,
46603 }
46604 }
46605}
46606#[repr(transparent)]
46607pub struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
46608 inner: PhysicalDeviceFragmentShadingRateEnumsFeaturesNV,
46609 marker: ::std::marker::PhantomData<&'a ()>,
46610}
46611unsafe impl ExtendsPhysicalDeviceFeatures2
46612 for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'_>
46613{
46614}
46615unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {}
46616unsafe impl ExtendsDeviceCreateInfo
46617 for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'_>
46618{
46619}
46620unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {}
46621impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
46622 type Target = PhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
46623 fn deref(&self) -> &Self::Target {
46624 &self.inner
46625 }
46626}
46627impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
46628 fn deref_mut(&mut self) -> &mut Self::Target {
46629 &mut self.inner
46630 }
46631}
46632impl<'a> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
46633 pub fn fragment_shading_rate_enums(mut self, fragment_shading_rate_enums: bool) -> Self {
46634 self.inner.fragment_shading_rate_enums = fragment_shading_rate_enums.into();
46635 self
46636 }
46637 pub fn supersample_fragment_shading_rates(
46638 mut self,
46639 supersample_fragment_shading_rates: bool,
46640 ) -> Self {
46641 self.inner.supersample_fragment_shading_rates = supersample_fragment_shading_rates.into();
46642 self
46643 }
46644 pub fn no_invocation_fragment_shading_rates(
46645 mut self,
46646 no_invocation_fragment_shading_rates: bool,
46647 ) -> Self {
46648 self.inner.no_invocation_fragment_shading_rates =
46649 no_invocation_fragment_shading_rates.into();
46650 self
46651 }
46652 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46653 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46654 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
46655 pub fn build(self) -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
46656 self.inner
46657 }
46658}
46659#[repr(C)]
46660#[cfg_attr(feature = "debug", derive(Debug))]
46661#[derive(Copy, Clone)]
46662#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV.html>"]
46663pub struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
46664 pub s_type: StructureType,
46665 pub p_next: *mut c_void,
46666 pub max_fragment_shading_rate_invocation_count: SampleCountFlags,
46667}
46668impl ::std::default::Default for PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
46669 fn default() -> Self {
46670 Self {
46671 s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV,
46672 p_next: ::std::ptr::null_mut(),
46673 max_fragment_shading_rate_invocation_count: SampleCountFlags::default(),
46674 }
46675 }
46676}
46677impl PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
46678 pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> {
46679 PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder {
46680 inner: Self::default(),
46681 marker: ::std::marker::PhantomData,
46682 }
46683 }
46684}
46685#[repr(transparent)]
46686pub struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> {
46687 inner: PhysicalDeviceFragmentShadingRateEnumsPropertiesNV,
46688 marker: ::std::marker::PhantomData<&'a ()>,
46689}
46690unsafe impl ExtendsPhysicalDeviceProperties2
46691 for PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'_>
46692{
46693}
46694unsafe impl ExtendsPhysicalDeviceProperties2
46695 for PhysicalDeviceFragmentShadingRateEnumsPropertiesNV
46696{
46697}
46698impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> {
46699 type Target = PhysicalDeviceFragmentShadingRateEnumsPropertiesNV;
46700 fn deref(&self) -> &Self::Target {
46701 &self.inner
46702 }
46703}
46704impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> {
46705 fn deref_mut(&mut self) -> &mut Self::Target {
46706 &mut self.inner
46707 }
46708}
46709impl<'a> PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> {
46710 pub fn max_fragment_shading_rate_invocation_count(
46711 mut self,
46712 max_fragment_shading_rate_invocation_count: SampleCountFlags,
46713 ) -> Self {
46714 self.inner.max_fragment_shading_rate_invocation_count =
46715 max_fragment_shading_rate_invocation_count;
46716 self
46717 }
46718 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46719 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46720 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
46721 pub fn build(self) -> PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
46722 self.inner
46723 }
46724}
46725#[repr(C)]
46726#[cfg_attr(feature = "debug", derive(Debug))]
46727#[derive(Copy, Clone)]
46728#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineFragmentShadingRateEnumStateCreateInfoNV.html>"]
46729pub struct PipelineFragmentShadingRateEnumStateCreateInfoNV {
46730 pub s_type: StructureType,
46731 pub p_next: *const c_void,
46732 pub shading_rate_type: FragmentShadingRateTypeNV,
46733 pub shading_rate: FragmentShadingRateNV,
46734 pub combiner_ops: [FragmentShadingRateCombinerOpKHR; 2],
46735}
46736impl ::std::default::Default for PipelineFragmentShadingRateEnumStateCreateInfoNV {
46737 fn default() -> Self {
46738 Self {
46739 s_type: StructureType::PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV,
46740 p_next: ::std::ptr::null(),
46741 shading_rate_type: FragmentShadingRateTypeNV::default(),
46742 shading_rate: FragmentShadingRateNV::default(),
46743 combiner_ops: unsafe { ::std::mem::zeroed() },
46744 }
46745 }
46746}
46747impl PipelineFragmentShadingRateEnumStateCreateInfoNV {
46748 pub fn builder<'a>() -> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
46749 PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder {
46750 inner: Self::default(),
46751 marker: ::std::marker::PhantomData,
46752 }
46753 }
46754}
46755#[repr(transparent)]
46756pub struct PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
46757 inner: PipelineFragmentShadingRateEnumStateCreateInfoNV,
46758 marker: ::std::marker::PhantomData<&'a ()>,
46759}
46760unsafe impl ExtendsGraphicsPipelineCreateInfo
46761 for PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'_>
46762{
46763}
46764unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineFragmentShadingRateEnumStateCreateInfoNV {}
46765impl<'a> ::std::ops::Deref for PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
46766 type Target = PipelineFragmentShadingRateEnumStateCreateInfoNV;
46767 fn deref(&self) -> &Self::Target {
46768 &self.inner
46769 }
46770}
46771impl<'a> ::std::ops::DerefMut for PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
46772 fn deref_mut(&mut self) -> &mut Self::Target {
46773 &mut self.inner
46774 }
46775}
46776impl<'a> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
46777 pub fn shading_rate_type(mut self, shading_rate_type: FragmentShadingRateTypeNV) -> Self {
46778 self.inner.shading_rate_type = shading_rate_type;
46779 self
46780 }
46781 pub fn shading_rate(mut self, shading_rate: FragmentShadingRateNV) -> Self {
46782 self.inner.shading_rate = shading_rate;
46783 self
46784 }
46785 pub fn combiner_ops(mut self, combiner_ops: [FragmentShadingRateCombinerOpKHR; 2]) -> Self {
46786 self.inner.combiner_ops = combiner_ops;
46787 self
46788 }
46789 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46790 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46791 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
46792 pub fn build(self) -> PipelineFragmentShadingRateEnumStateCreateInfoNV {
46793 self.inner
46794 }
46795}
46796#[repr(C)]
46797#[cfg_attr(feature = "debug", derive(Debug))]
46798#[derive(Copy, Clone)]
46799#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureBuildSizesInfoKHR.html>"]
46800pub struct AccelerationStructureBuildSizesInfoKHR {
46801 pub s_type: StructureType,
46802 pub p_next: *const c_void,
46803 pub acceleration_structure_size: DeviceSize,
46804 pub update_scratch_size: DeviceSize,
46805 pub build_scratch_size: DeviceSize,
46806}
46807impl ::std::default::Default for AccelerationStructureBuildSizesInfoKHR {
46808 fn default() -> Self {
46809 Self {
46810 s_type: StructureType::ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR,
46811 p_next: ::std::ptr::null(),
46812 acceleration_structure_size: DeviceSize::default(),
46813 update_scratch_size: DeviceSize::default(),
46814 build_scratch_size: DeviceSize::default(),
46815 }
46816 }
46817}
46818impl AccelerationStructureBuildSizesInfoKHR {
46819 pub fn builder<'a>() -> AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
46820 AccelerationStructureBuildSizesInfoKHRBuilder {
46821 inner: Self::default(),
46822 marker: ::std::marker::PhantomData,
46823 }
46824 }
46825}
46826#[repr(transparent)]
46827pub struct AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
46828 inner: AccelerationStructureBuildSizesInfoKHR,
46829 marker: ::std::marker::PhantomData<&'a ()>,
46830}
46831impl<'a> ::std::ops::Deref for AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
46832 type Target = AccelerationStructureBuildSizesInfoKHR;
46833 fn deref(&self) -> &Self::Target {
46834 &self.inner
46835 }
46836}
46837impl<'a> ::std::ops::DerefMut for AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
46838 fn deref_mut(&mut self) -> &mut Self::Target {
46839 &mut self.inner
46840 }
46841}
46842impl<'a> AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
46843 pub fn acceleration_structure_size(mut self, acceleration_structure_size: DeviceSize) -> Self {
46844 self.inner.acceleration_structure_size = acceleration_structure_size;
46845 self
46846 }
46847 pub fn update_scratch_size(mut self, update_scratch_size: DeviceSize) -> Self {
46848 self.inner.update_scratch_size = update_scratch_size;
46849 self
46850 }
46851 pub fn build_scratch_size(mut self, build_scratch_size: DeviceSize) -> Self {
46852 self.inner.build_scratch_size = build_scratch_size;
46853 self
46854 }
46855 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46856 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46857 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
46858 pub fn build(self) -> AccelerationStructureBuildSizesInfoKHR {
46859 self.inner
46860 }
46861}
46862#[repr(C)]
46863#[cfg_attr(feature = "debug", derive(Debug))]
46864#[derive(Copy, Clone)]
46865#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE.html>"]
46866pub struct PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
46867 pub s_type: StructureType,
46868 pub p_next: *mut c_void,
46869 pub mutable_descriptor_type: Bool32,
46870}
46871impl ::std::default::Default for PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
46872 fn default() -> Self {
46873 Self {
46874 s_type: StructureType::PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE,
46875 p_next: ::std::ptr::null_mut(),
46876 mutable_descriptor_type: Bool32::default(),
46877 }
46878 }
46879}
46880impl PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
46881 pub fn builder<'a>() -> PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> {
46882 PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder {
46883 inner: Self::default(),
46884 marker: ::std::marker::PhantomData,
46885 }
46886 }
46887}
46888#[repr(transparent)]
46889pub struct PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> {
46890 inner: PhysicalDeviceMutableDescriptorTypeFeaturesVALVE,
46891 marker: ::std::marker::PhantomData<&'a ()>,
46892}
46893unsafe impl ExtendsPhysicalDeviceFeatures2
46894 for PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'_>
46895{
46896}
46897unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {}
46898unsafe impl ExtendsDeviceCreateInfo
46899 for PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'_>
46900{
46901}
46902unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {}
46903impl<'a> ::std::ops::Deref for PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> {
46904 type Target = PhysicalDeviceMutableDescriptorTypeFeaturesVALVE;
46905 fn deref(&self) -> &Self::Target {
46906 &self.inner
46907 }
46908}
46909impl<'a> ::std::ops::DerefMut for PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> {
46910 fn deref_mut(&mut self) -> &mut Self::Target {
46911 &mut self.inner
46912 }
46913}
46914impl<'a> PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> {
46915 pub fn mutable_descriptor_type(mut self, mutable_descriptor_type: bool) -> Self {
46916 self.inner.mutable_descriptor_type = mutable_descriptor_type.into();
46917 self
46918 }
46919 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46920 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46921 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
46922 pub fn build(self) -> PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
46923 self.inner
46924 }
46925}
46926#[repr(C)]
46927#[cfg_attr(feature = "debug", derive(Debug))]
46928#[derive(Copy, Clone)]
46929#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMutableDescriptorTypeListVALVE.html>"]
46930pub struct MutableDescriptorTypeListVALVE {
46931 pub descriptor_type_count: u32,
46932 pub p_descriptor_types: *const DescriptorType,
46933}
46934impl ::std::default::Default for MutableDescriptorTypeListVALVE {
46935 fn default() -> Self {
46936 Self {
46937 descriptor_type_count: u32::default(),
46938 p_descriptor_types: ::std::ptr::null(),
46939 }
46940 }
46941}
46942impl MutableDescriptorTypeListVALVE {
46943 pub fn builder<'a>() -> MutableDescriptorTypeListVALVEBuilder<'a> {
46944 MutableDescriptorTypeListVALVEBuilder {
46945 inner: Self::default(),
46946 marker: ::std::marker::PhantomData,
46947 }
46948 }
46949}
46950#[repr(transparent)]
46951pub struct MutableDescriptorTypeListVALVEBuilder<'a> {
46952 inner: MutableDescriptorTypeListVALVE,
46953 marker: ::std::marker::PhantomData<&'a ()>,
46954}
46955impl<'a> ::std::ops::Deref for MutableDescriptorTypeListVALVEBuilder<'a> {
46956 type Target = MutableDescriptorTypeListVALVE;
46957 fn deref(&self) -> &Self::Target {
46958 &self.inner
46959 }
46960}
46961impl<'a> ::std::ops::DerefMut for MutableDescriptorTypeListVALVEBuilder<'a> {
46962 fn deref_mut(&mut self) -> &mut Self::Target {
46963 &mut self.inner
46964 }
46965}
46966impl<'a> MutableDescriptorTypeListVALVEBuilder<'a> {
46967 pub fn descriptor_types(mut self, descriptor_types: &'a [DescriptorType]) -> Self {
46968 self.inner.descriptor_type_count = descriptor_types.len() as _;
46969 self.inner.p_descriptor_types = descriptor_types.as_ptr();
46970 self
46971 }
46972 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46973 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46974 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
46975 pub fn build(self) -> MutableDescriptorTypeListVALVE {
46976 self.inner
46977 }
46978}
46979#[repr(C)]
46980#[cfg_attr(feature = "debug", derive(Debug))]
46981#[derive(Copy, Clone)]
46982#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMutableDescriptorTypeCreateInfoVALVE.html>"]
46983pub struct MutableDescriptorTypeCreateInfoVALVE {
46984 pub s_type: StructureType,
46985 pub p_next: *const c_void,
46986 pub mutable_descriptor_type_list_count: u32,
46987 pub p_mutable_descriptor_type_lists: *const MutableDescriptorTypeListVALVE,
46988}
46989impl ::std::default::Default for MutableDescriptorTypeCreateInfoVALVE {
46990 fn default() -> Self {
46991 Self {
46992 s_type: StructureType::MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE,
46993 p_next: ::std::ptr::null(),
46994 mutable_descriptor_type_list_count: u32::default(),
46995 p_mutable_descriptor_type_lists: ::std::ptr::null(),
46996 }
46997 }
46998}
46999impl MutableDescriptorTypeCreateInfoVALVE {
47000 pub fn builder<'a>() -> MutableDescriptorTypeCreateInfoVALVEBuilder<'a> {
47001 MutableDescriptorTypeCreateInfoVALVEBuilder {
47002 inner: Self::default(),
47003 marker: ::std::marker::PhantomData,
47004 }
47005 }
47006}
47007#[repr(transparent)]
47008pub struct MutableDescriptorTypeCreateInfoVALVEBuilder<'a> {
47009 inner: MutableDescriptorTypeCreateInfoVALVE,
47010 marker: ::std::marker::PhantomData<&'a ()>,
47011}
47012unsafe impl ExtendsDescriptorSetLayoutCreateInfo
47013 for MutableDescriptorTypeCreateInfoVALVEBuilder<'_>
47014{
47015}
47016unsafe impl ExtendsDescriptorSetLayoutCreateInfo for MutableDescriptorTypeCreateInfoVALVE {}
47017unsafe impl ExtendsDescriptorPoolCreateInfo for MutableDescriptorTypeCreateInfoVALVEBuilder<'_> {}
47018unsafe impl ExtendsDescriptorPoolCreateInfo for MutableDescriptorTypeCreateInfoVALVE {}
47019impl<'a> ::std::ops::Deref for MutableDescriptorTypeCreateInfoVALVEBuilder<'a> {
47020 type Target = MutableDescriptorTypeCreateInfoVALVE;
47021 fn deref(&self) -> &Self::Target {
47022 &self.inner
47023 }
47024}
47025impl<'a> ::std::ops::DerefMut for MutableDescriptorTypeCreateInfoVALVEBuilder<'a> {
47026 fn deref_mut(&mut self) -> &mut Self::Target {
47027 &mut self.inner
47028 }
47029}
47030impl<'a> MutableDescriptorTypeCreateInfoVALVEBuilder<'a> {
47031 pub fn mutable_descriptor_type_lists(
47032 mut self,
47033 mutable_descriptor_type_lists: &'a [MutableDescriptorTypeListVALVE],
47034 ) -> Self {
47035 self.inner.mutable_descriptor_type_list_count = mutable_descriptor_type_lists.len() as _;
47036 self.inner.p_mutable_descriptor_type_lists = mutable_descriptor_type_lists.as_ptr();
47037 self
47038 }
47039 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47040 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47041 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
47042 pub fn build(self) -> MutableDescriptorTypeCreateInfoVALVE {
47043 self.inner
47044 }
47045}
47046#[repr(C)]
47047#[cfg_attr(feature = "debug", derive(Debug))]
47048#[derive(Copy, Clone)]
47049#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDepthClipControlFeaturesEXT.html>"]
47050pub struct PhysicalDeviceDepthClipControlFeaturesEXT {
47051 pub s_type: StructureType,
47052 pub p_next: *mut c_void,
47053 pub depth_clip_control: Bool32,
47054}
47055impl ::std::default::Default for PhysicalDeviceDepthClipControlFeaturesEXT {
47056 fn default() -> Self {
47057 Self {
47058 s_type: StructureType::PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT,
47059 p_next: ::std::ptr::null_mut(),
47060 depth_clip_control: Bool32::default(),
47061 }
47062 }
47063}
47064impl PhysicalDeviceDepthClipControlFeaturesEXT {
47065 pub fn builder<'a>() -> PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> {
47066 PhysicalDeviceDepthClipControlFeaturesEXTBuilder {
47067 inner: Self::default(),
47068 marker: ::std::marker::PhantomData,
47069 }
47070 }
47071}
47072#[repr(transparent)]
47073pub struct PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> {
47074 inner: PhysicalDeviceDepthClipControlFeaturesEXT,
47075 marker: ::std::marker::PhantomData<&'a ()>,
47076}
47077unsafe impl ExtendsPhysicalDeviceFeatures2
47078 for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'_>
47079{
47080}
47081unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClipControlFeaturesEXT {}
47082unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'_> {}
47083unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipControlFeaturesEXT {}
47084impl<'a> ::std::ops::Deref for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> {
47085 type Target = PhysicalDeviceDepthClipControlFeaturesEXT;
47086 fn deref(&self) -> &Self::Target {
47087 &self.inner
47088 }
47089}
47090impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> {
47091 fn deref_mut(&mut self) -> &mut Self::Target {
47092 &mut self.inner
47093 }
47094}
47095impl<'a> PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> {
47096 pub fn depth_clip_control(mut self, depth_clip_control: bool) -> Self {
47097 self.inner.depth_clip_control = depth_clip_control.into();
47098 self
47099 }
47100 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47101 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47102 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
47103 pub fn build(self) -> PhysicalDeviceDepthClipControlFeaturesEXT {
47104 self.inner
47105 }
47106}
47107#[repr(C)]
47108#[cfg_attr(feature = "debug", derive(Debug))]
47109#[derive(Copy, Clone)]
47110#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportDepthClipControlCreateInfoEXT.html>"]
47111pub struct PipelineViewportDepthClipControlCreateInfoEXT {
47112 pub s_type: StructureType,
47113 pub p_next: *const c_void,
47114 pub negative_one_to_one: Bool32,
47115}
47116impl ::std::default::Default for PipelineViewportDepthClipControlCreateInfoEXT {
47117 fn default() -> Self {
47118 Self {
47119 s_type: StructureType::PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT,
47120 p_next: ::std::ptr::null(),
47121 negative_one_to_one: Bool32::default(),
47122 }
47123 }
47124}
47125impl PipelineViewportDepthClipControlCreateInfoEXT {
47126 pub fn builder<'a>() -> PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> {
47127 PipelineViewportDepthClipControlCreateInfoEXTBuilder {
47128 inner: Self::default(),
47129 marker: ::std::marker::PhantomData,
47130 }
47131 }
47132}
47133#[repr(transparent)]
47134pub struct PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> {
47135 inner: PipelineViewportDepthClipControlCreateInfoEXT,
47136 marker: ::std::marker::PhantomData<&'a ()>,
47137}
47138unsafe impl ExtendsPipelineViewportStateCreateInfo
47139 for PipelineViewportDepthClipControlCreateInfoEXTBuilder<'_>
47140{
47141}
47142unsafe impl ExtendsPipelineViewportStateCreateInfo
47143 for PipelineViewportDepthClipControlCreateInfoEXT
47144{
47145}
47146impl<'a> ::std::ops::Deref for PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> {
47147 type Target = PipelineViewportDepthClipControlCreateInfoEXT;
47148 fn deref(&self) -> &Self::Target {
47149 &self.inner
47150 }
47151}
47152impl<'a> ::std::ops::DerefMut for PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> {
47153 fn deref_mut(&mut self) -> &mut Self::Target {
47154 &mut self.inner
47155 }
47156}
47157impl<'a> PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> {
47158 pub fn negative_one_to_one(mut self, negative_one_to_one: bool) -> Self {
47159 self.inner.negative_one_to_one = negative_one_to_one.into();
47160 self
47161 }
47162 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47163 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47164 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
47165 pub fn build(self) -> PipelineViewportDepthClipControlCreateInfoEXT {
47166 self.inner
47167 }
47168}
47169#[repr(C)]
47170#[cfg_attr(feature = "debug", derive(Debug))]
47171#[derive(Copy, Clone)]
47172#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT.html>"]
47173pub struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT {
47174 pub s_type: StructureType,
47175 pub p_next: *mut c_void,
47176 pub vertex_input_dynamic_state: Bool32,
47177}
47178impl ::std::default::Default for PhysicalDeviceVertexInputDynamicStateFeaturesEXT {
47179 fn default() -> Self {
47180 Self {
47181 s_type: StructureType::PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT,
47182 p_next: ::std::ptr::null_mut(),
47183 vertex_input_dynamic_state: Bool32::default(),
47184 }
47185 }
47186}
47187impl PhysicalDeviceVertexInputDynamicStateFeaturesEXT {
47188 pub fn builder<'a>() -> PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> {
47189 PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder {
47190 inner: Self::default(),
47191 marker: ::std::marker::PhantomData,
47192 }
47193 }
47194}
47195#[repr(transparent)]
47196pub struct PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> {
47197 inner: PhysicalDeviceVertexInputDynamicStateFeaturesEXT,
47198 marker: ::std::marker::PhantomData<&'a ()>,
47199}
47200unsafe impl ExtendsPhysicalDeviceFeatures2
47201 for PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'_>
47202{
47203}
47204unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVertexInputDynamicStateFeaturesEXT {}
47205unsafe impl ExtendsDeviceCreateInfo
47206 for PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'_>
47207{
47208}
47209unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexInputDynamicStateFeaturesEXT {}
47210impl<'a> ::std::ops::Deref for PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> {
47211 type Target = PhysicalDeviceVertexInputDynamicStateFeaturesEXT;
47212 fn deref(&self) -> &Self::Target {
47213 &self.inner
47214 }
47215}
47216impl<'a> ::std::ops::DerefMut for PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> {
47217 fn deref_mut(&mut self) -> &mut Self::Target {
47218 &mut self.inner
47219 }
47220}
47221impl<'a> PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> {
47222 pub fn vertex_input_dynamic_state(mut self, vertex_input_dynamic_state: bool) -> Self {
47223 self.inner.vertex_input_dynamic_state = vertex_input_dynamic_state.into();
47224 self
47225 }
47226 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47227 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47228 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
47229 pub fn build(self) -> PhysicalDeviceVertexInputDynamicStateFeaturesEXT {
47230 self.inner
47231 }
47232}
47233#[repr(C)]
47234#[cfg_attr(feature = "debug", derive(Debug))]
47235#[derive(Copy, Clone)]
47236#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalMemoryRDMAFeaturesNV.html>"]
47237pub struct PhysicalDeviceExternalMemoryRDMAFeaturesNV {
47238 pub s_type: StructureType,
47239 pub p_next: *mut c_void,
47240 pub external_memory_rdma: Bool32,
47241}
47242impl ::std::default::Default for PhysicalDeviceExternalMemoryRDMAFeaturesNV {
47243 fn default() -> Self {
47244 Self {
47245 s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV,
47246 p_next: ::std::ptr::null_mut(),
47247 external_memory_rdma: Bool32::default(),
47248 }
47249 }
47250}
47251impl PhysicalDeviceExternalMemoryRDMAFeaturesNV {
47252 pub fn builder<'a>() -> PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> {
47253 PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder {
47254 inner: Self::default(),
47255 marker: ::std::marker::PhantomData,
47256 }
47257 }
47258}
47259#[repr(transparent)]
47260pub struct PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> {
47261 inner: PhysicalDeviceExternalMemoryRDMAFeaturesNV,
47262 marker: ::std::marker::PhantomData<&'a ()>,
47263}
47264unsafe impl ExtendsPhysicalDeviceFeatures2
47265 for PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'_>
47266{
47267}
47268unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExternalMemoryRDMAFeaturesNV {}
47269unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'_> {}
47270unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExternalMemoryRDMAFeaturesNV {}
47271impl<'a> ::std::ops::Deref for PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> {
47272 type Target = PhysicalDeviceExternalMemoryRDMAFeaturesNV;
47273 fn deref(&self) -> &Self::Target {
47274 &self.inner
47275 }
47276}
47277impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> {
47278 fn deref_mut(&mut self) -> &mut Self::Target {
47279 &mut self.inner
47280 }
47281}
47282impl<'a> PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> {
47283 pub fn external_memory_rdma(mut self, external_memory_rdma: bool) -> Self {
47284 self.inner.external_memory_rdma = external_memory_rdma.into();
47285 self
47286 }
47287 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47288 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47289 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
47290 pub fn build(self) -> PhysicalDeviceExternalMemoryRDMAFeaturesNV {
47291 self.inner
47292 }
47293}
47294#[repr(C)]
47295#[cfg_attr(feature = "debug", derive(Debug))]
47296#[derive(Copy, Clone)]
47297#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVertexInputBindingDescription2EXT.html>"]
47298pub struct VertexInputBindingDescription2EXT {
47299 pub s_type: StructureType,
47300 pub p_next: *mut c_void,
47301 pub binding: u32,
47302 pub stride: u32,
47303 pub input_rate: VertexInputRate,
47304 pub divisor: u32,
47305}
47306impl ::std::default::Default for VertexInputBindingDescription2EXT {
47307 fn default() -> Self {
47308 Self {
47309 s_type: StructureType::VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT,
47310 p_next: ::std::ptr::null_mut(),
47311 binding: u32::default(),
47312 stride: u32::default(),
47313 input_rate: VertexInputRate::default(),
47314 divisor: u32::default(),
47315 }
47316 }
47317}
47318impl VertexInputBindingDescription2EXT {
47319 pub fn builder<'a>() -> VertexInputBindingDescription2EXTBuilder<'a> {
47320 VertexInputBindingDescription2EXTBuilder {
47321 inner: Self::default(),
47322 marker: ::std::marker::PhantomData,
47323 }
47324 }
47325}
47326#[repr(transparent)]
47327pub struct VertexInputBindingDescription2EXTBuilder<'a> {
47328 inner: VertexInputBindingDescription2EXT,
47329 marker: ::std::marker::PhantomData<&'a ()>,
47330}
47331impl<'a> ::std::ops::Deref for VertexInputBindingDescription2EXTBuilder<'a> {
47332 type Target = VertexInputBindingDescription2EXT;
47333 fn deref(&self) -> &Self::Target {
47334 &self.inner
47335 }
47336}
47337impl<'a> ::std::ops::DerefMut for VertexInputBindingDescription2EXTBuilder<'a> {
47338 fn deref_mut(&mut self) -> &mut Self::Target {
47339 &mut self.inner
47340 }
47341}
47342impl<'a> VertexInputBindingDescription2EXTBuilder<'a> {
47343 pub fn binding(mut self, binding: u32) -> Self {
47344 self.inner.binding = binding;
47345 self
47346 }
47347 pub fn stride(mut self, stride: u32) -> Self {
47348 self.inner.stride = stride;
47349 self
47350 }
47351 pub fn input_rate(mut self, input_rate: VertexInputRate) -> Self {
47352 self.inner.input_rate = input_rate;
47353 self
47354 }
47355 pub fn divisor(mut self, divisor: u32) -> Self {
47356 self.inner.divisor = divisor;
47357 self
47358 }
47359 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47360 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47361 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
47362 pub fn build(self) -> VertexInputBindingDescription2EXT {
47363 self.inner
47364 }
47365}
47366#[repr(C)]
47367#[cfg_attr(feature = "debug", derive(Debug))]
47368#[derive(Copy, Clone)]
47369#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVertexInputAttributeDescription2EXT.html>"]
47370pub struct VertexInputAttributeDescription2EXT {
47371 pub s_type: StructureType,
47372 pub p_next: *mut c_void,
47373 pub location: u32,
47374 pub binding: u32,
47375 pub format: Format,
47376 pub offset: u32,
47377}
47378impl ::std::default::Default for VertexInputAttributeDescription2EXT {
47379 fn default() -> Self {
47380 Self {
47381 s_type: StructureType::VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT,
47382 p_next: ::std::ptr::null_mut(),
47383 location: u32::default(),
47384 binding: u32::default(),
47385 format: Format::default(),
47386 offset: u32::default(),
47387 }
47388 }
47389}
47390impl VertexInputAttributeDescription2EXT {
47391 pub fn builder<'a>() -> VertexInputAttributeDescription2EXTBuilder<'a> {
47392 VertexInputAttributeDescription2EXTBuilder {
47393 inner: Self::default(),
47394 marker: ::std::marker::PhantomData,
47395 }
47396 }
47397}
47398#[repr(transparent)]
47399pub struct VertexInputAttributeDescription2EXTBuilder<'a> {
47400 inner: VertexInputAttributeDescription2EXT,
47401 marker: ::std::marker::PhantomData<&'a ()>,
47402}
47403impl<'a> ::std::ops::Deref for VertexInputAttributeDescription2EXTBuilder<'a> {
47404 type Target = VertexInputAttributeDescription2EXT;
47405 fn deref(&self) -> &Self::Target {
47406 &self.inner
47407 }
47408}
47409impl<'a> ::std::ops::DerefMut for VertexInputAttributeDescription2EXTBuilder<'a> {
47410 fn deref_mut(&mut self) -> &mut Self::Target {
47411 &mut self.inner
47412 }
47413}
47414impl<'a> VertexInputAttributeDescription2EXTBuilder<'a> {
47415 pub fn location(mut self, location: u32) -> Self {
47416 self.inner.location = location;
47417 self
47418 }
47419 pub fn binding(mut self, binding: u32) -> Self {
47420 self.inner.binding = binding;
47421 self
47422 }
47423 pub fn format(mut self, format: Format) -> Self {
47424 self.inner.format = format;
47425 self
47426 }
47427 pub fn offset(mut self, offset: u32) -> Self {
47428 self.inner.offset = offset;
47429 self
47430 }
47431 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47432 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47433 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
47434 pub fn build(self) -> VertexInputAttributeDescription2EXT {
47435 self.inner
47436 }
47437}
47438#[repr(C)]
47439#[cfg_attr(feature = "debug", derive(Debug))]
47440#[derive(Copy, Clone)]
47441#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceColorWriteEnableFeaturesEXT.html>"]
47442pub struct PhysicalDeviceColorWriteEnableFeaturesEXT {
47443 pub s_type: StructureType,
47444 pub p_next: *mut c_void,
47445 pub color_write_enable: Bool32,
47446}
47447impl ::std::default::Default for PhysicalDeviceColorWriteEnableFeaturesEXT {
47448 fn default() -> Self {
47449 Self {
47450 s_type: StructureType::PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT,
47451 p_next: ::std::ptr::null_mut(),
47452 color_write_enable: Bool32::default(),
47453 }
47454 }
47455}
47456impl PhysicalDeviceColorWriteEnableFeaturesEXT {
47457 pub fn builder<'a>() -> PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> {
47458 PhysicalDeviceColorWriteEnableFeaturesEXTBuilder {
47459 inner: Self::default(),
47460 marker: ::std::marker::PhantomData,
47461 }
47462 }
47463}
47464#[repr(transparent)]
47465pub struct PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> {
47466 inner: PhysicalDeviceColorWriteEnableFeaturesEXT,
47467 marker: ::std::marker::PhantomData<&'a ()>,
47468}
47469unsafe impl ExtendsPhysicalDeviceFeatures2
47470 for PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'_>
47471{
47472}
47473unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceColorWriteEnableFeaturesEXT {}
47474unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'_> {}
47475unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceColorWriteEnableFeaturesEXT {}
47476impl<'a> ::std::ops::Deref for PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> {
47477 type Target = PhysicalDeviceColorWriteEnableFeaturesEXT;
47478 fn deref(&self) -> &Self::Target {
47479 &self.inner
47480 }
47481}
47482impl<'a> ::std::ops::DerefMut for PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> {
47483 fn deref_mut(&mut self) -> &mut Self::Target {
47484 &mut self.inner
47485 }
47486}
47487impl<'a> PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> {
47488 pub fn color_write_enable(mut self, color_write_enable: bool) -> Self {
47489 self.inner.color_write_enable = color_write_enable.into();
47490 self
47491 }
47492 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47493 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47494 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
47495 pub fn build(self) -> PhysicalDeviceColorWriteEnableFeaturesEXT {
47496 self.inner
47497 }
47498}
47499#[repr(C)]
47500#[cfg_attr(feature = "debug", derive(Debug))]
47501#[derive(Copy, Clone)]
47502#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineColorWriteCreateInfoEXT.html>"]
47503pub struct PipelineColorWriteCreateInfoEXT {
47504 pub s_type: StructureType,
47505 pub p_next: *const c_void,
47506 pub attachment_count: u32,
47507 pub p_color_write_enables: *const Bool32,
47508}
47509impl ::std::default::Default for PipelineColorWriteCreateInfoEXT {
47510 fn default() -> Self {
47511 Self {
47512 s_type: StructureType::PIPELINE_COLOR_WRITE_CREATE_INFO_EXT,
47513 p_next: ::std::ptr::null(),
47514 attachment_count: u32::default(),
47515 p_color_write_enables: ::std::ptr::null(),
47516 }
47517 }
47518}
47519impl PipelineColorWriteCreateInfoEXT {
47520 pub fn builder<'a>() -> PipelineColorWriteCreateInfoEXTBuilder<'a> {
47521 PipelineColorWriteCreateInfoEXTBuilder {
47522 inner: Self::default(),
47523 marker: ::std::marker::PhantomData,
47524 }
47525 }
47526}
47527#[repr(transparent)]
47528pub struct PipelineColorWriteCreateInfoEXTBuilder<'a> {
47529 inner: PipelineColorWriteCreateInfoEXT,
47530 marker: ::std::marker::PhantomData<&'a ()>,
47531}
47532unsafe impl ExtendsPipelineColorBlendStateCreateInfo
47533 for PipelineColorWriteCreateInfoEXTBuilder<'_>
47534{
47535}
47536unsafe impl ExtendsPipelineColorBlendStateCreateInfo for PipelineColorWriteCreateInfoEXT {}
47537impl<'a> ::std::ops::Deref for PipelineColorWriteCreateInfoEXTBuilder<'a> {
47538 type Target = PipelineColorWriteCreateInfoEXT;
47539 fn deref(&self) -> &Self::Target {
47540 &self.inner
47541 }
47542}
47543impl<'a> ::std::ops::DerefMut for PipelineColorWriteCreateInfoEXTBuilder<'a> {
47544 fn deref_mut(&mut self) -> &mut Self::Target {
47545 &mut self.inner
47546 }
47547}
47548impl<'a> PipelineColorWriteCreateInfoEXTBuilder<'a> {
47549 pub fn color_write_enables(mut self, color_write_enables: &'a [Bool32]) -> Self {
47550 self.inner.attachment_count = color_write_enables.len() as _;
47551 self.inner.p_color_write_enables = color_write_enables.as_ptr();
47552 self
47553 }
47554 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47555 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47556 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
47557 pub fn build(self) -> PipelineColorWriteCreateInfoEXT {
47558 self.inner
47559 }
47560}
47561#[repr(C)]
47562#[cfg_attr(feature = "debug", derive(Debug))]
47563#[derive(Copy, Clone)]
47564#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryBarrier2.html>"]
47565pub struct MemoryBarrier2 {
47566 pub s_type: StructureType,
47567 pub p_next: *const c_void,
47568 pub src_stage_mask: PipelineStageFlags2,
47569 pub src_access_mask: AccessFlags2,
47570 pub dst_stage_mask: PipelineStageFlags2,
47571 pub dst_access_mask: AccessFlags2,
47572}
47573impl ::std::default::Default for MemoryBarrier2 {
47574 fn default() -> Self {
47575 Self {
47576 s_type: StructureType::MEMORY_BARRIER_2,
47577 p_next: ::std::ptr::null(),
47578 src_stage_mask: PipelineStageFlags2::default(),
47579 src_access_mask: AccessFlags2::default(),
47580 dst_stage_mask: PipelineStageFlags2::default(),
47581 dst_access_mask: AccessFlags2::default(),
47582 }
47583 }
47584}
47585impl MemoryBarrier2 {
47586 pub fn builder<'a>() -> MemoryBarrier2Builder<'a> {
47587 MemoryBarrier2Builder {
47588 inner: Self::default(),
47589 marker: ::std::marker::PhantomData,
47590 }
47591 }
47592}
47593#[repr(transparent)]
47594pub struct MemoryBarrier2Builder<'a> {
47595 inner: MemoryBarrier2,
47596 marker: ::std::marker::PhantomData<&'a ()>,
47597}
47598unsafe impl ExtendsSubpassDependency2 for MemoryBarrier2Builder<'_> {}
47599unsafe impl ExtendsSubpassDependency2 for MemoryBarrier2 {}
47600impl<'a> ::std::ops::Deref for MemoryBarrier2Builder<'a> {
47601 type Target = MemoryBarrier2;
47602 fn deref(&self) -> &Self::Target {
47603 &self.inner
47604 }
47605}
47606impl<'a> ::std::ops::DerefMut for MemoryBarrier2Builder<'a> {
47607 fn deref_mut(&mut self) -> &mut Self::Target {
47608 &mut self.inner
47609 }
47610}
47611impl<'a> MemoryBarrier2Builder<'a> {
47612 pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags2) -> Self {
47613 self.inner.src_stage_mask = src_stage_mask;
47614 self
47615 }
47616 pub fn src_access_mask(mut self, src_access_mask: AccessFlags2) -> Self {
47617 self.inner.src_access_mask = src_access_mask;
47618 self
47619 }
47620 pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags2) -> Self {
47621 self.inner.dst_stage_mask = dst_stage_mask;
47622 self
47623 }
47624 pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags2) -> Self {
47625 self.inner.dst_access_mask = dst_access_mask;
47626 self
47627 }
47628 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47629 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47630 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
47631 pub fn build(self) -> MemoryBarrier2 {
47632 self.inner
47633 }
47634}
47635#[repr(C)]
47636#[cfg_attr(feature = "debug", derive(Debug))]
47637#[derive(Copy, Clone)]
47638#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageMemoryBarrier2.html>"]
47639pub struct ImageMemoryBarrier2 {
47640 pub s_type: StructureType,
47641 pub p_next: *const c_void,
47642 pub src_stage_mask: PipelineStageFlags2,
47643 pub src_access_mask: AccessFlags2,
47644 pub dst_stage_mask: PipelineStageFlags2,
47645 pub dst_access_mask: AccessFlags2,
47646 pub old_layout: ImageLayout,
47647 pub new_layout: ImageLayout,
47648 pub src_queue_family_index: u32,
47649 pub dst_queue_family_index: u32,
47650 pub image: Image,
47651 pub subresource_range: ImageSubresourceRange,
47652}
47653impl ::std::default::Default for ImageMemoryBarrier2 {
47654 fn default() -> Self {
47655 Self {
47656 s_type: StructureType::IMAGE_MEMORY_BARRIER_2,
47657 p_next: ::std::ptr::null(),
47658 src_stage_mask: PipelineStageFlags2::default(),
47659 src_access_mask: AccessFlags2::default(),
47660 dst_stage_mask: PipelineStageFlags2::default(),
47661 dst_access_mask: AccessFlags2::default(),
47662 old_layout: ImageLayout::default(),
47663 new_layout: ImageLayout::default(),
47664 src_queue_family_index: u32::default(),
47665 dst_queue_family_index: u32::default(),
47666 image: Image::default(),
47667 subresource_range: ImageSubresourceRange::default(),
47668 }
47669 }
47670}
47671impl ImageMemoryBarrier2 {
47672 pub fn builder<'a>() -> ImageMemoryBarrier2Builder<'a> {
47673 ImageMemoryBarrier2Builder {
47674 inner: Self::default(),
47675 marker: ::std::marker::PhantomData,
47676 }
47677 }
47678}
47679#[repr(transparent)]
47680pub struct ImageMemoryBarrier2Builder<'a> {
47681 inner: ImageMemoryBarrier2,
47682 marker: ::std::marker::PhantomData<&'a ()>,
47683}
47684pub unsafe trait ExtendsImageMemoryBarrier2 {}
47685impl<'a> ::std::ops::Deref for ImageMemoryBarrier2Builder<'a> {
47686 type Target = ImageMemoryBarrier2;
47687 fn deref(&self) -> &Self::Target {
47688 &self.inner
47689 }
47690}
47691impl<'a> ::std::ops::DerefMut for ImageMemoryBarrier2Builder<'a> {
47692 fn deref_mut(&mut self) -> &mut Self::Target {
47693 &mut self.inner
47694 }
47695}
47696impl<'a> ImageMemoryBarrier2Builder<'a> {
47697 pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags2) -> Self {
47698 self.inner.src_stage_mask = src_stage_mask;
47699 self
47700 }
47701 pub fn src_access_mask(mut self, src_access_mask: AccessFlags2) -> Self {
47702 self.inner.src_access_mask = src_access_mask;
47703 self
47704 }
47705 pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags2) -> Self {
47706 self.inner.dst_stage_mask = dst_stage_mask;
47707 self
47708 }
47709 pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags2) -> Self {
47710 self.inner.dst_access_mask = dst_access_mask;
47711 self
47712 }
47713 pub fn old_layout(mut self, old_layout: ImageLayout) -> Self {
47714 self.inner.old_layout = old_layout;
47715 self
47716 }
47717 pub fn new_layout(mut self, new_layout: ImageLayout) -> Self {
47718 self.inner.new_layout = new_layout;
47719 self
47720 }
47721 pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self {
47722 self.inner.src_queue_family_index = src_queue_family_index;
47723 self
47724 }
47725 pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self {
47726 self.inner.dst_queue_family_index = dst_queue_family_index;
47727 self
47728 }
47729 pub fn image(mut self, image: Image) -> Self {
47730 self.inner.image = image;
47731 self
47732 }
47733 pub fn subresource_range(mut self, subresource_range: ImageSubresourceRange) -> Self {
47734 self.inner.subresource_range = subresource_range;
47735 self
47736 }
47737 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
47738 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
47739 #[doc = r" valid extension structs can be pushed into the chain."]
47740 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
47741 #[doc = r" chain will look like `A -> D -> B -> C`."]
47742 pub fn push_next<T: ExtendsImageMemoryBarrier2>(mut self, next: &'a mut T) -> Self {
47743 unsafe {
47744 let next_ptr = <*const T>::cast(next);
47745 let last_next = ptr_chain_iter(next).last().unwrap();
47746 (*last_next).p_next = self.inner.p_next as _;
47747 self.inner.p_next = next_ptr;
47748 }
47749 self
47750 }
47751 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47752 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47753 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
47754 pub fn build(self) -> ImageMemoryBarrier2 {
47755 self.inner
47756 }
47757}
47758#[repr(C)]
47759#[cfg_attr(feature = "debug", derive(Debug))]
47760#[derive(Copy, Clone)]
47761#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferMemoryBarrier2.html>"]
47762pub struct BufferMemoryBarrier2 {
47763 pub s_type: StructureType,
47764 pub p_next: *const c_void,
47765 pub src_stage_mask: PipelineStageFlags2,
47766 pub src_access_mask: AccessFlags2,
47767 pub dst_stage_mask: PipelineStageFlags2,
47768 pub dst_access_mask: AccessFlags2,
47769 pub src_queue_family_index: u32,
47770 pub dst_queue_family_index: u32,
47771 pub buffer: Buffer,
47772 pub offset: DeviceSize,
47773 pub size: DeviceSize,
47774}
47775impl ::std::default::Default for BufferMemoryBarrier2 {
47776 fn default() -> Self {
47777 Self {
47778 s_type: StructureType::BUFFER_MEMORY_BARRIER_2,
47779 p_next: ::std::ptr::null(),
47780 src_stage_mask: PipelineStageFlags2::default(),
47781 src_access_mask: AccessFlags2::default(),
47782 dst_stage_mask: PipelineStageFlags2::default(),
47783 dst_access_mask: AccessFlags2::default(),
47784 src_queue_family_index: u32::default(),
47785 dst_queue_family_index: u32::default(),
47786 buffer: Buffer::default(),
47787 offset: DeviceSize::default(),
47788 size: DeviceSize::default(),
47789 }
47790 }
47791}
47792impl BufferMemoryBarrier2 {
47793 pub fn builder<'a>() -> BufferMemoryBarrier2Builder<'a> {
47794 BufferMemoryBarrier2Builder {
47795 inner: Self::default(),
47796 marker: ::std::marker::PhantomData,
47797 }
47798 }
47799}
47800#[repr(transparent)]
47801pub struct BufferMemoryBarrier2Builder<'a> {
47802 inner: BufferMemoryBarrier2,
47803 marker: ::std::marker::PhantomData<&'a ()>,
47804}
47805impl<'a> ::std::ops::Deref for BufferMemoryBarrier2Builder<'a> {
47806 type Target = BufferMemoryBarrier2;
47807 fn deref(&self) -> &Self::Target {
47808 &self.inner
47809 }
47810}
47811impl<'a> ::std::ops::DerefMut for BufferMemoryBarrier2Builder<'a> {
47812 fn deref_mut(&mut self) -> &mut Self::Target {
47813 &mut self.inner
47814 }
47815}
47816impl<'a> BufferMemoryBarrier2Builder<'a> {
47817 pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags2) -> Self {
47818 self.inner.src_stage_mask = src_stage_mask;
47819 self
47820 }
47821 pub fn src_access_mask(mut self, src_access_mask: AccessFlags2) -> Self {
47822 self.inner.src_access_mask = src_access_mask;
47823 self
47824 }
47825 pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags2) -> Self {
47826 self.inner.dst_stage_mask = dst_stage_mask;
47827 self
47828 }
47829 pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags2) -> Self {
47830 self.inner.dst_access_mask = dst_access_mask;
47831 self
47832 }
47833 pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self {
47834 self.inner.src_queue_family_index = src_queue_family_index;
47835 self
47836 }
47837 pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self {
47838 self.inner.dst_queue_family_index = dst_queue_family_index;
47839 self
47840 }
47841 pub fn buffer(mut self, buffer: Buffer) -> Self {
47842 self.inner.buffer = buffer;
47843 self
47844 }
47845 pub fn offset(mut self, offset: DeviceSize) -> Self {
47846 self.inner.offset = offset;
47847 self
47848 }
47849 pub fn size(mut self, size: DeviceSize) -> Self {
47850 self.inner.size = size;
47851 self
47852 }
47853 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47854 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47855 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
47856 pub fn build(self) -> BufferMemoryBarrier2 {
47857 self.inner
47858 }
47859}
47860#[repr(C)]
47861#[cfg_attr(feature = "debug", derive(Debug))]
47862#[derive(Copy, Clone)]
47863#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDependencyInfo.html>"]
47864pub struct DependencyInfo {
47865 pub s_type: StructureType,
47866 pub p_next: *const c_void,
47867 pub dependency_flags: DependencyFlags,
47868 pub memory_barrier_count: u32,
47869 pub p_memory_barriers: *const MemoryBarrier2,
47870 pub buffer_memory_barrier_count: u32,
47871 pub p_buffer_memory_barriers: *const BufferMemoryBarrier2,
47872 pub image_memory_barrier_count: u32,
47873 pub p_image_memory_barriers: *const ImageMemoryBarrier2,
47874}
47875impl ::std::default::Default for DependencyInfo {
47876 fn default() -> Self {
47877 Self {
47878 s_type: StructureType::DEPENDENCY_INFO,
47879 p_next: ::std::ptr::null(),
47880 dependency_flags: DependencyFlags::default(),
47881 memory_barrier_count: u32::default(),
47882 p_memory_barriers: ::std::ptr::null(),
47883 buffer_memory_barrier_count: u32::default(),
47884 p_buffer_memory_barriers: ::std::ptr::null(),
47885 image_memory_barrier_count: u32::default(),
47886 p_image_memory_barriers: ::std::ptr::null(),
47887 }
47888 }
47889}
47890impl DependencyInfo {
47891 pub fn builder<'a>() -> DependencyInfoBuilder<'a> {
47892 DependencyInfoBuilder {
47893 inner: Self::default(),
47894 marker: ::std::marker::PhantomData,
47895 }
47896 }
47897}
47898#[repr(transparent)]
47899pub struct DependencyInfoBuilder<'a> {
47900 inner: DependencyInfo,
47901 marker: ::std::marker::PhantomData<&'a ()>,
47902}
47903impl<'a> ::std::ops::Deref for DependencyInfoBuilder<'a> {
47904 type Target = DependencyInfo;
47905 fn deref(&self) -> &Self::Target {
47906 &self.inner
47907 }
47908}
47909impl<'a> ::std::ops::DerefMut for DependencyInfoBuilder<'a> {
47910 fn deref_mut(&mut self) -> &mut Self::Target {
47911 &mut self.inner
47912 }
47913}
47914impl<'a> DependencyInfoBuilder<'a> {
47915 pub fn dependency_flags(mut self, dependency_flags: DependencyFlags) -> Self {
47916 self.inner.dependency_flags = dependency_flags;
47917 self
47918 }
47919 pub fn memory_barriers(mut self, memory_barriers: &'a [MemoryBarrier2]) -> Self {
47920 self.inner.memory_barrier_count = memory_barriers.len() as _;
47921 self.inner.p_memory_barriers = memory_barriers.as_ptr();
47922 self
47923 }
47924 pub fn buffer_memory_barriers(
47925 mut self,
47926 buffer_memory_barriers: &'a [BufferMemoryBarrier2],
47927 ) -> Self {
47928 self.inner.buffer_memory_barrier_count = buffer_memory_barriers.len() as _;
47929 self.inner.p_buffer_memory_barriers = buffer_memory_barriers.as_ptr();
47930 self
47931 }
47932 pub fn image_memory_barriers(
47933 mut self,
47934 image_memory_barriers: &'a [ImageMemoryBarrier2],
47935 ) -> Self {
47936 self.inner.image_memory_barrier_count = image_memory_barriers.len() as _;
47937 self.inner.p_image_memory_barriers = image_memory_barriers.as_ptr();
47938 self
47939 }
47940 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47941 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47942 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
47943 pub fn build(self) -> DependencyInfo {
47944 self.inner
47945 }
47946}
47947#[repr(C)]
47948#[cfg_attr(feature = "debug", derive(Debug))]
47949#[derive(Copy, Clone)]
47950#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreSubmitInfo.html>"]
47951pub struct SemaphoreSubmitInfo {
47952 pub s_type: StructureType,
47953 pub p_next: *const c_void,
47954 pub semaphore: Semaphore,
47955 pub value: u64,
47956 pub stage_mask: PipelineStageFlags2,
47957 pub device_index: u32,
47958}
47959impl ::std::default::Default for SemaphoreSubmitInfo {
47960 fn default() -> Self {
47961 Self {
47962 s_type: StructureType::SEMAPHORE_SUBMIT_INFO,
47963 p_next: ::std::ptr::null(),
47964 semaphore: Semaphore::default(),
47965 value: u64::default(),
47966 stage_mask: PipelineStageFlags2::default(),
47967 device_index: u32::default(),
47968 }
47969 }
47970}
47971impl SemaphoreSubmitInfo {
47972 pub fn builder<'a>() -> SemaphoreSubmitInfoBuilder<'a> {
47973 SemaphoreSubmitInfoBuilder {
47974 inner: Self::default(),
47975 marker: ::std::marker::PhantomData,
47976 }
47977 }
47978}
47979#[repr(transparent)]
47980pub struct SemaphoreSubmitInfoBuilder<'a> {
47981 inner: SemaphoreSubmitInfo,
47982 marker: ::std::marker::PhantomData<&'a ()>,
47983}
47984impl<'a> ::std::ops::Deref for SemaphoreSubmitInfoBuilder<'a> {
47985 type Target = SemaphoreSubmitInfo;
47986 fn deref(&self) -> &Self::Target {
47987 &self.inner
47988 }
47989}
47990impl<'a> ::std::ops::DerefMut for SemaphoreSubmitInfoBuilder<'a> {
47991 fn deref_mut(&mut self) -> &mut Self::Target {
47992 &mut self.inner
47993 }
47994}
47995impl<'a> SemaphoreSubmitInfoBuilder<'a> {
47996 pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
47997 self.inner.semaphore = semaphore;
47998 self
47999 }
48000 pub fn value(mut self, value: u64) -> Self {
48001 self.inner.value = value;
48002 self
48003 }
48004 pub fn stage_mask(mut self, stage_mask: PipelineStageFlags2) -> Self {
48005 self.inner.stage_mask = stage_mask;
48006 self
48007 }
48008 pub fn device_index(mut self, device_index: u32) -> Self {
48009 self.inner.device_index = device_index;
48010 self
48011 }
48012 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48013 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48014 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
48015 pub fn build(self) -> SemaphoreSubmitInfo {
48016 self.inner
48017 }
48018}
48019#[repr(C)]
48020#[cfg_attr(feature = "debug", derive(Debug))]
48021#[derive(Copy, Clone)]
48022#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferSubmitInfo.html>"]
48023pub struct CommandBufferSubmitInfo {
48024 pub s_type: StructureType,
48025 pub p_next: *const c_void,
48026 pub command_buffer: CommandBuffer,
48027 pub device_mask: u32,
48028}
48029impl ::std::default::Default for CommandBufferSubmitInfo {
48030 fn default() -> Self {
48031 Self {
48032 s_type: StructureType::COMMAND_BUFFER_SUBMIT_INFO,
48033 p_next: ::std::ptr::null(),
48034 command_buffer: CommandBuffer::default(),
48035 device_mask: u32::default(),
48036 }
48037 }
48038}
48039impl CommandBufferSubmitInfo {
48040 pub fn builder<'a>() -> CommandBufferSubmitInfoBuilder<'a> {
48041 CommandBufferSubmitInfoBuilder {
48042 inner: Self::default(),
48043 marker: ::std::marker::PhantomData,
48044 }
48045 }
48046}
48047#[repr(transparent)]
48048pub struct CommandBufferSubmitInfoBuilder<'a> {
48049 inner: CommandBufferSubmitInfo,
48050 marker: ::std::marker::PhantomData<&'a ()>,
48051}
48052impl<'a> ::std::ops::Deref for CommandBufferSubmitInfoBuilder<'a> {
48053 type Target = CommandBufferSubmitInfo;
48054 fn deref(&self) -> &Self::Target {
48055 &self.inner
48056 }
48057}
48058impl<'a> ::std::ops::DerefMut for CommandBufferSubmitInfoBuilder<'a> {
48059 fn deref_mut(&mut self) -> &mut Self::Target {
48060 &mut self.inner
48061 }
48062}
48063impl<'a> CommandBufferSubmitInfoBuilder<'a> {
48064 pub fn command_buffer(mut self, command_buffer: CommandBuffer) -> Self {
48065 self.inner.command_buffer = command_buffer;
48066 self
48067 }
48068 pub fn device_mask(mut self, device_mask: u32) -> Self {
48069 self.inner.device_mask = device_mask;
48070 self
48071 }
48072 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48073 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48074 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
48075 pub fn build(self) -> CommandBufferSubmitInfo {
48076 self.inner
48077 }
48078}
48079#[repr(C)]
48080#[cfg_attr(feature = "debug", derive(Debug))]
48081#[derive(Copy, Clone)]
48082#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubmitInfo2.html>"]
48083pub struct SubmitInfo2 {
48084 pub s_type: StructureType,
48085 pub p_next: *const c_void,
48086 pub flags: SubmitFlags,
48087 pub wait_semaphore_info_count: u32,
48088 pub p_wait_semaphore_infos: *const SemaphoreSubmitInfo,
48089 pub command_buffer_info_count: u32,
48090 pub p_command_buffer_infos: *const CommandBufferSubmitInfo,
48091 pub signal_semaphore_info_count: u32,
48092 pub p_signal_semaphore_infos: *const SemaphoreSubmitInfo,
48093}
48094impl ::std::default::Default for SubmitInfo2 {
48095 fn default() -> Self {
48096 Self {
48097 s_type: StructureType::SUBMIT_INFO_2,
48098 p_next: ::std::ptr::null(),
48099 flags: SubmitFlags::default(),
48100 wait_semaphore_info_count: u32::default(),
48101 p_wait_semaphore_infos: ::std::ptr::null(),
48102 command_buffer_info_count: u32::default(),
48103 p_command_buffer_infos: ::std::ptr::null(),
48104 signal_semaphore_info_count: u32::default(),
48105 p_signal_semaphore_infos: ::std::ptr::null(),
48106 }
48107 }
48108}
48109impl SubmitInfo2 {
48110 pub fn builder<'a>() -> SubmitInfo2Builder<'a> {
48111 SubmitInfo2Builder {
48112 inner: Self::default(),
48113 marker: ::std::marker::PhantomData,
48114 }
48115 }
48116}
48117#[repr(transparent)]
48118pub struct SubmitInfo2Builder<'a> {
48119 inner: SubmitInfo2,
48120 marker: ::std::marker::PhantomData<&'a ()>,
48121}
48122pub unsafe trait ExtendsSubmitInfo2 {}
48123impl<'a> ::std::ops::Deref for SubmitInfo2Builder<'a> {
48124 type Target = SubmitInfo2;
48125 fn deref(&self) -> &Self::Target {
48126 &self.inner
48127 }
48128}
48129impl<'a> ::std::ops::DerefMut for SubmitInfo2Builder<'a> {
48130 fn deref_mut(&mut self) -> &mut Self::Target {
48131 &mut self.inner
48132 }
48133}
48134impl<'a> SubmitInfo2Builder<'a> {
48135 pub fn flags(mut self, flags: SubmitFlags) -> Self {
48136 self.inner.flags = flags;
48137 self
48138 }
48139 pub fn wait_semaphore_infos(mut self, wait_semaphore_infos: &'a [SemaphoreSubmitInfo]) -> Self {
48140 self.inner.wait_semaphore_info_count = wait_semaphore_infos.len() as _;
48141 self.inner.p_wait_semaphore_infos = wait_semaphore_infos.as_ptr();
48142 self
48143 }
48144 pub fn command_buffer_infos(
48145 mut self,
48146 command_buffer_infos: &'a [CommandBufferSubmitInfo],
48147 ) -> Self {
48148 self.inner.command_buffer_info_count = command_buffer_infos.len() as _;
48149 self.inner.p_command_buffer_infos = command_buffer_infos.as_ptr();
48150 self
48151 }
48152 pub fn signal_semaphore_infos(
48153 mut self,
48154 signal_semaphore_infos: &'a [SemaphoreSubmitInfo],
48155 ) -> Self {
48156 self.inner.signal_semaphore_info_count = signal_semaphore_infos.len() as _;
48157 self.inner.p_signal_semaphore_infos = signal_semaphore_infos.as_ptr();
48158 self
48159 }
48160 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
48161 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
48162 #[doc = r" valid extension structs can be pushed into the chain."]
48163 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
48164 #[doc = r" chain will look like `A -> D -> B -> C`."]
48165 pub fn push_next<T: ExtendsSubmitInfo2>(mut self, next: &'a mut T) -> Self {
48166 unsafe {
48167 let next_ptr = <*const T>::cast(next);
48168 let last_next = ptr_chain_iter(next).last().unwrap();
48169 (*last_next).p_next = self.inner.p_next as _;
48170 self.inner.p_next = next_ptr;
48171 }
48172 self
48173 }
48174 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48175 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48176 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
48177 pub fn build(self) -> SubmitInfo2 {
48178 self.inner
48179 }
48180}
48181#[repr(C)]
48182#[cfg_attr(feature = "debug", derive(Debug))]
48183#[derive(Copy, Clone)]
48184#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyCheckpointProperties2NV.html>"]
48185pub struct QueueFamilyCheckpointProperties2NV {
48186 pub s_type: StructureType,
48187 pub p_next: *mut c_void,
48188 pub checkpoint_execution_stage_mask: PipelineStageFlags2,
48189}
48190impl ::std::default::Default for QueueFamilyCheckpointProperties2NV {
48191 fn default() -> Self {
48192 Self {
48193 s_type: StructureType::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV,
48194 p_next: ::std::ptr::null_mut(),
48195 checkpoint_execution_stage_mask: PipelineStageFlags2::default(),
48196 }
48197 }
48198}
48199impl QueueFamilyCheckpointProperties2NV {
48200 pub fn builder<'a>() -> QueueFamilyCheckpointProperties2NVBuilder<'a> {
48201 QueueFamilyCheckpointProperties2NVBuilder {
48202 inner: Self::default(),
48203 marker: ::std::marker::PhantomData,
48204 }
48205 }
48206}
48207#[repr(transparent)]
48208pub struct QueueFamilyCheckpointProperties2NVBuilder<'a> {
48209 inner: QueueFamilyCheckpointProperties2NV,
48210 marker: ::std::marker::PhantomData<&'a ()>,
48211}
48212unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointProperties2NVBuilder<'_> {}
48213unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointProperties2NV {}
48214impl<'a> ::std::ops::Deref for QueueFamilyCheckpointProperties2NVBuilder<'a> {
48215 type Target = QueueFamilyCheckpointProperties2NV;
48216 fn deref(&self) -> &Self::Target {
48217 &self.inner
48218 }
48219}
48220impl<'a> ::std::ops::DerefMut for QueueFamilyCheckpointProperties2NVBuilder<'a> {
48221 fn deref_mut(&mut self) -> &mut Self::Target {
48222 &mut self.inner
48223 }
48224}
48225impl<'a> QueueFamilyCheckpointProperties2NVBuilder<'a> {
48226 pub fn checkpoint_execution_stage_mask(
48227 mut self,
48228 checkpoint_execution_stage_mask: PipelineStageFlags2,
48229 ) -> Self {
48230 self.inner.checkpoint_execution_stage_mask = checkpoint_execution_stage_mask;
48231 self
48232 }
48233 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48234 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48235 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
48236 pub fn build(self) -> QueueFamilyCheckpointProperties2NV {
48237 self.inner
48238 }
48239}
48240#[repr(C)]
48241#[cfg_attr(feature = "debug", derive(Debug))]
48242#[derive(Copy, Clone)]
48243#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCheckpointData2NV.html>"]
48244pub struct CheckpointData2NV {
48245 pub s_type: StructureType,
48246 pub p_next: *mut c_void,
48247 pub stage: PipelineStageFlags2,
48248 pub p_checkpoint_marker: *mut c_void,
48249}
48250impl ::std::default::Default for CheckpointData2NV {
48251 fn default() -> Self {
48252 Self {
48253 s_type: StructureType::CHECKPOINT_DATA_2_NV,
48254 p_next: ::std::ptr::null_mut(),
48255 stage: PipelineStageFlags2::default(),
48256 p_checkpoint_marker: ::std::ptr::null_mut(),
48257 }
48258 }
48259}
48260impl CheckpointData2NV {
48261 pub fn builder<'a>() -> CheckpointData2NVBuilder<'a> {
48262 CheckpointData2NVBuilder {
48263 inner: Self::default(),
48264 marker: ::std::marker::PhantomData,
48265 }
48266 }
48267}
48268#[repr(transparent)]
48269pub struct CheckpointData2NVBuilder<'a> {
48270 inner: CheckpointData2NV,
48271 marker: ::std::marker::PhantomData<&'a ()>,
48272}
48273impl<'a> ::std::ops::Deref for CheckpointData2NVBuilder<'a> {
48274 type Target = CheckpointData2NV;
48275 fn deref(&self) -> &Self::Target {
48276 &self.inner
48277 }
48278}
48279impl<'a> ::std::ops::DerefMut for CheckpointData2NVBuilder<'a> {
48280 fn deref_mut(&mut self) -> &mut Self::Target {
48281 &mut self.inner
48282 }
48283}
48284impl<'a> CheckpointData2NVBuilder<'a> {
48285 pub fn stage(mut self, stage: PipelineStageFlags2) -> Self {
48286 self.inner.stage = stage;
48287 self
48288 }
48289 pub fn checkpoint_marker(mut self, checkpoint_marker: *mut c_void) -> Self {
48290 self.inner.p_checkpoint_marker = checkpoint_marker;
48291 self
48292 }
48293 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48294 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48295 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
48296 pub fn build(self) -> CheckpointData2NV {
48297 self.inner
48298 }
48299}
48300#[repr(C)]
48301#[cfg_attr(feature = "debug", derive(Debug))]
48302#[derive(Copy, Clone)]
48303#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSynchronization2Features.html>"]
48304pub struct PhysicalDeviceSynchronization2Features {
48305 pub s_type: StructureType,
48306 pub p_next: *mut c_void,
48307 pub synchronization2: Bool32,
48308}
48309impl ::std::default::Default for PhysicalDeviceSynchronization2Features {
48310 fn default() -> Self {
48311 Self {
48312 s_type: StructureType::PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES,
48313 p_next: ::std::ptr::null_mut(),
48314 synchronization2: Bool32::default(),
48315 }
48316 }
48317}
48318impl PhysicalDeviceSynchronization2Features {
48319 pub fn builder<'a>() -> PhysicalDeviceSynchronization2FeaturesBuilder<'a> {
48320 PhysicalDeviceSynchronization2FeaturesBuilder {
48321 inner: Self::default(),
48322 marker: ::std::marker::PhantomData,
48323 }
48324 }
48325}
48326#[repr(transparent)]
48327pub struct PhysicalDeviceSynchronization2FeaturesBuilder<'a> {
48328 inner: PhysicalDeviceSynchronization2Features,
48329 marker: ::std::marker::PhantomData<&'a ()>,
48330}
48331unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSynchronization2FeaturesBuilder<'_> {}
48332unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSynchronization2Features {}
48333unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSynchronization2FeaturesBuilder<'_> {}
48334unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSynchronization2Features {}
48335impl<'a> ::std::ops::Deref for PhysicalDeviceSynchronization2FeaturesBuilder<'a> {
48336 type Target = PhysicalDeviceSynchronization2Features;
48337 fn deref(&self) -> &Self::Target {
48338 &self.inner
48339 }
48340}
48341impl<'a> ::std::ops::DerefMut for PhysicalDeviceSynchronization2FeaturesBuilder<'a> {
48342 fn deref_mut(&mut self) -> &mut Self::Target {
48343 &mut self.inner
48344 }
48345}
48346impl<'a> PhysicalDeviceSynchronization2FeaturesBuilder<'a> {
48347 pub fn synchronization2(mut self, synchronization2: bool) -> Self {
48348 self.inner.synchronization2 = synchronization2.into();
48349 self
48350 }
48351 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48352 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48353 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
48354 pub fn build(self) -> PhysicalDeviceSynchronization2Features {
48355 self.inner
48356 }
48357}
48358#[repr(C)]
48359#[cfg_attr(feature = "debug", derive(Debug))]
48360#[derive(Copy, Clone)]
48361#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoQueueFamilyProperties2KHR.html>"]
48362pub struct VideoQueueFamilyProperties2KHR {
48363 pub s_type: StructureType,
48364 pub p_next: *mut c_void,
48365 pub video_codec_operations: VideoCodecOperationFlagsKHR,
48366}
48367impl ::std::default::Default for VideoQueueFamilyProperties2KHR {
48368 fn default() -> Self {
48369 Self {
48370 s_type: StructureType::VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR,
48371 p_next: ::std::ptr::null_mut(),
48372 video_codec_operations: VideoCodecOperationFlagsKHR::default(),
48373 }
48374 }
48375}
48376impl VideoQueueFamilyProperties2KHR {
48377 pub fn builder<'a>() -> VideoQueueFamilyProperties2KHRBuilder<'a> {
48378 VideoQueueFamilyProperties2KHRBuilder {
48379 inner: Self::default(),
48380 marker: ::std::marker::PhantomData,
48381 }
48382 }
48383}
48384#[repr(transparent)]
48385pub struct VideoQueueFamilyProperties2KHRBuilder<'a> {
48386 inner: VideoQueueFamilyProperties2KHR,
48387 marker: ::std::marker::PhantomData<&'a ()>,
48388}
48389unsafe impl ExtendsQueueFamilyProperties2 for VideoQueueFamilyProperties2KHRBuilder<'_> {}
48390unsafe impl ExtendsQueueFamilyProperties2 for VideoQueueFamilyProperties2KHR {}
48391impl<'a> ::std::ops::Deref for VideoQueueFamilyProperties2KHRBuilder<'a> {
48392 type Target = VideoQueueFamilyProperties2KHR;
48393 fn deref(&self) -> &Self::Target {
48394 &self.inner
48395 }
48396}
48397impl<'a> ::std::ops::DerefMut for VideoQueueFamilyProperties2KHRBuilder<'a> {
48398 fn deref_mut(&mut self) -> &mut Self::Target {
48399 &mut self.inner
48400 }
48401}
48402impl<'a> VideoQueueFamilyProperties2KHRBuilder<'a> {
48403 pub fn video_codec_operations(
48404 mut self,
48405 video_codec_operations: VideoCodecOperationFlagsKHR,
48406 ) -> Self {
48407 self.inner.video_codec_operations = video_codec_operations;
48408 self
48409 }
48410 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48411 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48412 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
48413 pub fn build(self) -> VideoQueueFamilyProperties2KHR {
48414 self.inner
48415 }
48416}
48417#[repr(C)]
48418#[cfg_attr(feature = "debug", derive(Debug))]
48419#[derive(Copy, Clone)]
48420#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyQueryResultStatusProperties2KHR.html>"]
48421pub struct QueueFamilyQueryResultStatusProperties2KHR {
48422 pub s_type: StructureType,
48423 pub p_next: *mut c_void,
48424 pub supported: Bool32,
48425}
48426impl ::std::default::Default for QueueFamilyQueryResultStatusProperties2KHR {
48427 fn default() -> Self {
48428 Self {
48429 s_type: StructureType::QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_2_KHR,
48430 p_next: ::std::ptr::null_mut(),
48431 supported: Bool32::default(),
48432 }
48433 }
48434}
48435impl QueueFamilyQueryResultStatusProperties2KHR {
48436 pub fn builder<'a>() -> QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> {
48437 QueueFamilyQueryResultStatusProperties2KHRBuilder {
48438 inner: Self::default(),
48439 marker: ::std::marker::PhantomData,
48440 }
48441 }
48442}
48443#[repr(transparent)]
48444pub struct QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> {
48445 inner: QueueFamilyQueryResultStatusProperties2KHR,
48446 marker: ::std::marker::PhantomData<&'a ()>,
48447}
48448unsafe impl ExtendsQueueFamilyProperties2
48449 for QueueFamilyQueryResultStatusProperties2KHRBuilder<'_>
48450{
48451}
48452unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyQueryResultStatusProperties2KHR {}
48453impl<'a> ::std::ops::Deref for QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> {
48454 type Target = QueueFamilyQueryResultStatusProperties2KHR;
48455 fn deref(&self) -> &Self::Target {
48456 &self.inner
48457 }
48458}
48459impl<'a> ::std::ops::DerefMut for QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> {
48460 fn deref_mut(&mut self) -> &mut Self::Target {
48461 &mut self.inner
48462 }
48463}
48464impl<'a> QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> {
48465 pub fn supported(mut self, supported: bool) -> Self {
48466 self.inner.supported = supported.into();
48467 self
48468 }
48469 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48470 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48471 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
48472 pub fn build(self) -> QueueFamilyQueryResultStatusProperties2KHR {
48473 self.inner
48474 }
48475}
48476#[repr(C)]
48477#[cfg_attr(feature = "debug", derive(Debug))]
48478#[derive(Copy, Clone)]
48479#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoProfilesKHR.html>"]
48480pub struct VideoProfilesKHR {
48481 pub s_type: StructureType,
48482 pub p_next: *mut c_void,
48483 pub profile_count: u32,
48484 pub p_profiles: *const VideoProfileKHR,
48485}
48486impl ::std::default::Default for VideoProfilesKHR {
48487 fn default() -> Self {
48488 Self {
48489 s_type: StructureType::VIDEO_PROFILES_KHR,
48490 p_next: ::std::ptr::null_mut(),
48491 profile_count: u32::default(),
48492 p_profiles: ::std::ptr::null(),
48493 }
48494 }
48495}
48496impl VideoProfilesKHR {
48497 pub fn builder<'a>() -> VideoProfilesKHRBuilder<'a> {
48498 VideoProfilesKHRBuilder {
48499 inner: Self::default(),
48500 marker: ::std::marker::PhantomData,
48501 }
48502 }
48503}
48504#[repr(transparent)]
48505pub struct VideoProfilesKHRBuilder<'a> {
48506 inner: VideoProfilesKHR,
48507 marker: ::std::marker::PhantomData<&'a ()>,
48508}
48509unsafe impl ExtendsFormatProperties2 for VideoProfilesKHRBuilder<'_> {}
48510unsafe impl ExtendsFormatProperties2 for VideoProfilesKHR {}
48511unsafe impl ExtendsImageCreateInfo for VideoProfilesKHRBuilder<'_> {}
48512unsafe impl ExtendsImageCreateInfo for VideoProfilesKHR {}
48513unsafe impl ExtendsImageViewCreateInfo for VideoProfilesKHRBuilder<'_> {}
48514unsafe impl ExtendsImageViewCreateInfo for VideoProfilesKHR {}
48515unsafe impl ExtendsBufferCreateInfo for VideoProfilesKHRBuilder<'_> {}
48516unsafe impl ExtendsBufferCreateInfo for VideoProfilesKHR {}
48517impl<'a> ::std::ops::Deref for VideoProfilesKHRBuilder<'a> {
48518 type Target = VideoProfilesKHR;
48519 fn deref(&self) -> &Self::Target {
48520 &self.inner
48521 }
48522}
48523impl<'a> ::std::ops::DerefMut for VideoProfilesKHRBuilder<'a> {
48524 fn deref_mut(&mut self) -> &mut Self::Target {
48525 &mut self.inner
48526 }
48527}
48528impl<'a> VideoProfilesKHRBuilder<'a> {
48529 pub fn profiles(mut self, profiles: &'a [VideoProfileKHR]) -> Self {
48530 self.inner.profile_count = profiles.len() as _;
48531 self.inner.p_profiles = profiles.as_ptr();
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."]
48537 pub fn build(self) -> VideoProfilesKHR {
48538 self.inner
48539 }
48540}
48541#[repr(C)]
48542#[cfg_attr(feature = "debug", derive(Debug))]
48543#[derive(Copy, Clone)]
48544#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVideoFormatInfoKHR.html>"]
48545pub struct PhysicalDeviceVideoFormatInfoKHR {
48546 pub s_type: StructureType,
48547 pub p_next: *mut c_void,
48548 pub image_usage: ImageUsageFlags,
48549 pub p_video_profiles: *const VideoProfilesKHR,
48550}
48551impl ::std::default::Default for PhysicalDeviceVideoFormatInfoKHR {
48552 fn default() -> Self {
48553 Self {
48554 s_type: StructureType::PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR,
48555 p_next: ::std::ptr::null_mut(),
48556 image_usage: ImageUsageFlags::default(),
48557 p_video_profiles: ::std::ptr::null(),
48558 }
48559 }
48560}
48561impl PhysicalDeviceVideoFormatInfoKHR {
48562 pub fn builder<'a>() -> PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
48563 PhysicalDeviceVideoFormatInfoKHRBuilder {
48564 inner: Self::default(),
48565 marker: ::std::marker::PhantomData,
48566 }
48567 }
48568}
48569#[repr(transparent)]
48570pub struct PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
48571 inner: PhysicalDeviceVideoFormatInfoKHR,
48572 marker: ::std::marker::PhantomData<&'a ()>,
48573}
48574impl<'a> ::std::ops::Deref for PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
48575 type Target = PhysicalDeviceVideoFormatInfoKHR;
48576 fn deref(&self) -> &Self::Target {
48577 &self.inner
48578 }
48579}
48580impl<'a> ::std::ops::DerefMut for PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
48581 fn deref_mut(&mut self) -> &mut Self::Target {
48582 &mut self.inner
48583 }
48584}
48585impl<'a> PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
48586 pub fn image_usage(mut self, image_usage: ImageUsageFlags) -> Self {
48587 self.inner.image_usage = image_usage;
48588 self
48589 }
48590 pub fn video_profiles(mut self, video_profiles: &'a VideoProfilesKHR) -> Self {
48591 self.inner.p_video_profiles = video_profiles;
48592 self
48593 }
48594 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48595 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48596 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
48597 pub fn build(self) -> PhysicalDeviceVideoFormatInfoKHR {
48598 self.inner
48599 }
48600}
48601#[repr(C)]
48602#[cfg_attr(feature = "debug", derive(Debug))]
48603#[derive(Copy, Clone)]
48604#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoFormatPropertiesKHR.html>"]
48605pub struct VideoFormatPropertiesKHR {
48606 pub s_type: StructureType,
48607 pub p_next: *mut c_void,
48608 pub format: Format,
48609}
48610impl ::std::default::Default for VideoFormatPropertiesKHR {
48611 fn default() -> Self {
48612 Self {
48613 s_type: StructureType::VIDEO_FORMAT_PROPERTIES_KHR,
48614 p_next: ::std::ptr::null_mut(),
48615 format: Format::default(),
48616 }
48617 }
48618}
48619impl VideoFormatPropertiesKHR {
48620 pub fn builder<'a>() -> VideoFormatPropertiesKHRBuilder<'a> {
48621 VideoFormatPropertiesKHRBuilder {
48622 inner: Self::default(),
48623 marker: ::std::marker::PhantomData,
48624 }
48625 }
48626}
48627#[repr(transparent)]
48628pub struct VideoFormatPropertiesKHRBuilder<'a> {
48629 inner: VideoFormatPropertiesKHR,
48630 marker: ::std::marker::PhantomData<&'a ()>,
48631}
48632impl<'a> ::std::ops::Deref for VideoFormatPropertiesKHRBuilder<'a> {
48633 type Target = VideoFormatPropertiesKHR;
48634 fn deref(&self) -> &Self::Target {
48635 &self.inner
48636 }
48637}
48638impl<'a> ::std::ops::DerefMut for VideoFormatPropertiesKHRBuilder<'a> {
48639 fn deref_mut(&mut self) -> &mut Self::Target {
48640 &mut self.inner
48641 }
48642}
48643impl<'a> VideoFormatPropertiesKHRBuilder<'a> {
48644 pub fn format(mut self, format: Format) -> Self {
48645 self.inner.format = format;
48646 self
48647 }
48648 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48649 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48650 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
48651 pub fn build(self) -> VideoFormatPropertiesKHR {
48652 self.inner
48653 }
48654}
48655#[repr(C)]
48656#[cfg_attr(feature = "debug", derive(Debug))]
48657#[derive(Copy, Clone)]
48658#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoProfileKHR.html>"]
48659pub struct VideoProfileKHR {
48660 pub s_type: StructureType,
48661 pub p_next: *mut c_void,
48662 pub video_codec_operation: VideoCodecOperationFlagsKHR,
48663 pub chroma_subsampling: VideoChromaSubsamplingFlagsKHR,
48664 pub luma_bit_depth: VideoComponentBitDepthFlagsKHR,
48665 pub chroma_bit_depth: VideoComponentBitDepthFlagsKHR,
48666}
48667impl ::std::default::Default for VideoProfileKHR {
48668 fn default() -> Self {
48669 Self {
48670 s_type: StructureType::VIDEO_PROFILE_KHR,
48671 p_next: ::std::ptr::null_mut(),
48672 video_codec_operation: VideoCodecOperationFlagsKHR::default(),
48673 chroma_subsampling: VideoChromaSubsamplingFlagsKHR::default(),
48674 luma_bit_depth: VideoComponentBitDepthFlagsKHR::default(),
48675 chroma_bit_depth: VideoComponentBitDepthFlagsKHR::default(),
48676 }
48677 }
48678}
48679impl VideoProfileKHR {
48680 pub fn builder<'a>() -> VideoProfileKHRBuilder<'a> {
48681 VideoProfileKHRBuilder {
48682 inner: Self::default(),
48683 marker: ::std::marker::PhantomData,
48684 }
48685 }
48686}
48687#[repr(transparent)]
48688pub struct VideoProfileKHRBuilder<'a> {
48689 inner: VideoProfileKHR,
48690 marker: ::std::marker::PhantomData<&'a ()>,
48691}
48692unsafe impl ExtendsQueryPoolCreateInfo for VideoProfileKHRBuilder<'_> {}
48693unsafe impl ExtendsQueryPoolCreateInfo for VideoProfileKHR {}
48694unsafe impl ExtendsFormatProperties2 for VideoProfileKHRBuilder<'_> {}
48695unsafe impl ExtendsFormatProperties2 for VideoProfileKHR {}
48696unsafe impl ExtendsImageCreateInfo for VideoProfileKHRBuilder<'_> {}
48697unsafe impl ExtendsImageCreateInfo for VideoProfileKHR {}
48698unsafe impl ExtendsImageViewCreateInfo for VideoProfileKHRBuilder<'_> {}
48699unsafe impl ExtendsImageViewCreateInfo for VideoProfileKHR {}
48700unsafe impl ExtendsBufferCreateInfo for VideoProfileKHRBuilder<'_> {}
48701unsafe impl ExtendsBufferCreateInfo for VideoProfileKHR {}
48702pub unsafe trait ExtendsVideoProfileKHR {}
48703impl<'a> ::std::ops::Deref for VideoProfileKHRBuilder<'a> {
48704 type Target = VideoProfileKHR;
48705 fn deref(&self) -> &Self::Target {
48706 &self.inner
48707 }
48708}
48709impl<'a> ::std::ops::DerefMut for VideoProfileKHRBuilder<'a> {
48710 fn deref_mut(&mut self) -> &mut Self::Target {
48711 &mut self.inner
48712 }
48713}
48714impl<'a> VideoProfileKHRBuilder<'a> {
48715 pub fn video_codec_operation(
48716 mut self,
48717 video_codec_operation: VideoCodecOperationFlagsKHR,
48718 ) -> Self {
48719 self.inner.video_codec_operation = video_codec_operation;
48720 self
48721 }
48722 pub fn chroma_subsampling(
48723 mut self,
48724 chroma_subsampling: VideoChromaSubsamplingFlagsKHR,
48725 ) -> Self {
48726 self.inner.chroma_subsampling = chroma_subsampling;
48727 self
48728 }
48729 pub fn luma_bit_depth(mut self, luma_bit_depth: VideoComponentBitDepthFlagsKHR) -> Self {
48730 self.inner.luma_bit_depth = luma_bit_depth;
48731 self
48732 }
48733 pub fn chroma_bit_depth(mut self, chroma_bit_depth: VideoComponentBitDepthFlagsKHR) -> Self {
48734 self.inner.chroma_bit_depth = chroma_bit_depth;
48735 self
48736 }
48737 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
48738 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
48739 #[doc = r" valid extension structs can be pushed into the chain."]
48740 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
48741 #[doc = r" chain will look like `A -> D -> B -> C`."]
48742 pub fn push_next<T: ExtendsVideoProfileKHR>(mut self, next: &'a mut T) -> Self {
48743 unsafe {
48744 let next_ptr = <*mut T>::cast(next);
48745 let last_next = ptr_chain_iter(next).last().unwrap();
48746 (*last_next).p_next = self.inner.p_next as _;
48747 self.inner.p_next = next_ptr;
48748 }
48749 self
48750 }
48751 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48752 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48753 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
48754 pub fn build(self) -> VideoProfileKHR {
48755 self.inner
48756 }
48757}
48758#[repr(C)]
48759#[cfg_attr(feature = "debug", derive(Debug))]
48760#[derive(Copy, Clone)]
48761#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCapabilitiesKHR.html>"]
48762pub struct VideoCapabilitiesKHR {
48763 pub s_type: StructureType,
48764 pub p_next: *mut c_void,
48765 pub capability_flags: VideoCapabilityFlagsKHR,
48766 pub min_bitstream_buffer_offset_alignment: DeviceSize,
48767 pub min_bitstream_buffer_size_alignment: DeviceSize,
48768 pub video_picture_extent_granularity: Extent2D,
48769 pub min_extent: Extent2D,
48770 pub max_extent: Extent2D,
48771 pub max_reference_pictures_slots_count: u32,
48772 pub max_reference_pictures_active_count: u32,
48773 pub std_header_version: ExtensionProperties,
48774}
48775impl ::std::default::Default for VideoCapabilitiesKHR {
48776 fn default() -> Self {
48777 Self {
48778 s_type: StructureType::VIDEO_CAPABILITIES_KHR,
48779 p_next: ::std::ptr::null_mut(),
48780 capability_flags: VideoCapabilityFlagsKHR::default(),
48781 min_bitstream_buffer_offset_alignment: DeviceSize::default(),
48782 min_bitstream_buffer_size_alignment: DeviceSize::default(),
48783 video_picture_extent_granularity: Extent2D::default(),
48784 min_extent: Extent2D::default(),
48785 max_extent: Extent2D::default(),
48786 max_reference_pictures_slots_count: u32::default(),
48787 max_reference_pictures_active_count: u32::default(),
48788 std_header_version: ExtensionProperties::default(),
48789 }
48790 }
48791}
48792impl VideoCapabilitiesKHR {
48793 pub fn builder<'a>() -> VideoCapabilitiesKHRBuilder<'a> {
48794 VideoCapabilitiesKHRBuilder {
48795 inner: Self::default(),
48796 marker: ::std::marker::PhantomData,
48797 }
48798 }
48799}
48800#[repr(transparent)]
48801pub struct VideoCapabilitiesKHRBuilder<'a> {
48802 inner: VideoCapabilitiesKHR,
48803 marker: ::std::marker::PhantomData<&'a ()>,
48804}
48805pub unsafe trait ExtendsVideoCapabilitiesKHR {}
48806impl<'a> ::std::ops::Deref for VideoCapabilitiesKHRBuilder<'a> {
48807 type Target = VideoCapabilitiesKHR;
48808 fn deref(&self) -> &Self::Target {
48809 &self.inner
48810 }
48811}
48812impl<'a> ::std::ops::DerefMut for VideoCapabilitiesKHRBuilder<'a> {
48813 fn deref_mut(&mut self) -> &mut Self::Target {
48814 &mut self.inner
48815 }
48816}
48817impl<'a> VideoCapabilitiesKHRBuilder<'a> {
48818 pub fn capability_flags(mut self, capability_flags: VideoCapabilityFlagsKHR) -> Self {
48819 self.inner.capability_flags = capability_flags;
48820 self
48821 }
48822 pub fn min_bitstream_buffer_offset_alignment(
48823 mut self,
48824 min_bitstream_buffer_offset_alignment: DeviceSize,
48825 ) -> Self {
48826 self.inner.min_bitstream_buffer_offset_alignment = min_bitstream_buffer_offset_alignment;
48827 self
48828 }
48829 pub fn min_bitstream_buffer_size_alignment(
48830 mut self,
48831 min_bitstream_buffer_size_alignment: DeviceSize,
48832 ) -> Self {
48833 self.inner.min_bitstream_buffer_size_alignment = min_bitstream_buffer_size_alignment;
48834 self
48835 }
48836 pub fn video_picture_extent_granularity(
48837 mut self,
48838 video_picture_extent_granularity: Extent2D,
48839 ) -> Self {
48840 self.inner.video_picture_extent_granularity = video_picture_extent_granularity;
48841 self
48842 }
48843 pub fn min_extent(mut self, min_extent: Extent2D) -> Self {
48844 self.inner.min_extent = min_extent;
48845 self
48846 }
48847 pub fn max_extent(mut self, max_extent: Extent2D) -> Self {
48848 self.inner.max_extent = max_extent;
48849 self
48850 }
48851 pub fn max_reference_pictures_slots_count(
48852 mut self,
48853 max_reference_pictures_slots_count: u32,
48854 ) -> Self {
48855 self.inner.max_reference_pictures_slots_count = max_reference_pictures_slots_count;
48856 self
48857 }
48858 pub fn max_reference_pictures_active_count(
48859 mut self,
48860 max_reference_pictures_active_count: u32,
48861 ) -> Self {
48862 self.inner.max_reference_pictures_active_count = max_reference_pictures_active_count;
48863 self
48864 }
48865 pub fn std_header_version(mut self, std_header_version: ExtensionProperties) -> Self {
48866 self.inner.std_header_version = std_header_version;
48867 self
48868 }
48869 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
48870 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
48871 #[doc = r" valid extension structs can be pushed into the chain."]
48872 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
48873 #[doc = r" chain will look like `A -> D -> B -> C`."]
48874 pub fn push_next<T: ExtendsVideoCapabilitiesKHR>(mut self, next: &'a mut T) -> Self {
48875 unsafe {
48876 let next_ptr = <*mut T>::cast(next);
48877 let last_next = ptr_chain_iter(next).last().unwrap();
48878 (*last_next).p_next = self.inner.p_next as _;
48879 self.inner.p_next = next_ptr;
48880 }
48881 self
48882 }
48883 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48884 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48885 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
48886 pub fn build(self) -> VideoCapabilitiesKHR {
48887 self.inner
48888 }
48889}
48890#[repr(C)]
48891#[cfg_attr(feature = "debug", derive(Debug))]
48892#[derive(Copy, Clone)]
48893#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoGetMemoryPropertiesKHR.html>"]
48894pub struct VideoGetMemoryPropertiesKHR {
48895 pub s_type: StructureType,
48896 pub p_next: *const c_void,
48897 pub memory_bind_index: u32,
48898 pub p_memory_requirements: *mut MemoryRequirements2,
48899}
48900impl ::std::default::Default for VideoGetMemoryPropertiesKHR {
48901 fn default() -> Self {
48902 Self {
48903 s_type: StructureType::VIDEO_GET_MEMORY_PROPERTIES_KHR,
48904 p_next: ::std::ptr::null(),
48905 memory_bind_index: u32::default(),
48906 p_memory_requirements: ::std::ptr::null_mut(),
48907 }
48908 }
48909}
48910impl VideoGetMemoryPropertiesKHR {
48911 pub fn builder<'a>() -> VideoGetMemoryPropertiesKHRBuilder<'a> {
48912 VideoGetMemoryPropertiesKHRBuilder {
48913 inner: Self::default(),
48914 marker: ::std::marker::PhantomData,
48915 }
48916 }
48917}
48918#[repr(transparent)]
48919pub struct VideoGetMemoryPropertiesKHRBuilder<'a> {
48920 inner: VideoGetMemoryPropertiesKHR,
48921 marker: ::std::marker::PhantomData<&'a ()>,
48922}
48923impl<'a> ::std::ops::Deref for VideoGetMemoryPropertiesKHRBuilder<'a> {
48924 type Target = VideoGetMemoryPropertiesKHR;
48925 fn deref(&self) -> &Self::Target {
48926 &self.inner
48927 }
48928}
48929impl<'a> ::std::ops::DerefMut for VideoGetMemoryPropertiesKHRBuilder<'a> {
48930 fn deref_mut(&mut self) -> &mut Self::Target {
48931 &mut self.inner
48932 }
48933}
48934impl<'a> VideoGetMemoryPropertiesKHRBuilder<'a> {
48935 pub fn memory_bind_index(mut self, memory_bind_index: u32) -> Self {
48936 self.inner.memory_bind_index = memory_bind_index;
48937 self
48938 }
48939 pub fn memory_requirements(mut self, memory_requirements: &'a mut MemoryRequirements2) -> Self {
48940 self.inner.p_memory_requirements = memory_requirements;
48941 self
48942 }
48943 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48944 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48945 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
48946 pub fn build(self) -> VideoGetMemoryPropertiesKHR {
48947 self.inner
48948 }
48949}
48950#[repr(C)]
48951#[cfg_attr(feature = "debug", derive(Debug))]
48952#[derive(Copy, Clone)]
48953#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoBindMemoryKHR.html>"]
48954pub struct VideoBindMemoryKHR {
48955 pub s_type: StructureType,
48956 pub p_next: *const c_void,
48957 pub memory_bind_index: u32,
48958 pub memory: DeviceMemory,
48959 pub memory_offset: DeviceSize,
48960 pub memory_size: DeviceSize,
48961}
48962impl ::std::default::Default for VideoBindMemoryKHR {
48963 fn default() -> Self {
48964 Self {
48965 s_type: StructureType::VIDEO_BIND_MEMORY_KHR,
48966 p_next: ::std::ptr::null(),
48967 memory_bind_index: u32::default(),
48968 memory: DeviceMemory::default(),
48969 memory_offset: DeviceSize::default(),
48970 memory_size: DeviceSize::default(),
48971 }
48972 }
48973}
48974impl VideoBindMemoryKHR {
48975 pub fn builder<'a>() -> VideoBindMemoryKHRBuilder<'a> {
48976 VideoBindMemoryKHRBuilder {
48977 inner: Self::default(),
48978 marker: ::std::marker::PhantomData,
48979 }
48980 }
48981}
48982#[repr(transparent)]
48983pub struct VideoBindMemoryKHRBuilder<'a> {
48984 inner: VideoBindMemoryKHR,
48985 marker: ::std::marker::PhantomData<&'a ()>,
48986}
48987impl<'a> ::std::ops::Deref for VideoBindMemoryKHRBuilder<'a> {
48988 type Target = VideoBindMemoryKHR;
48989 fn deref(&self) -> &Self::Target {
48990 &self.inner
48991 }
48992}
48993impl<'a> ::std::ops::DerefMut for VideoBindMemoryKHRBuilder<'a> {
48994 fn deref_mut(&mut self) -> &mut Self::Target {
48995 &mut self.inner
48996 }
48997}
48998impl<'a> VideoBindMemoryKHRBuilder<'a> {
48999 pub fn memory_bind_index(mut self, memory_bind_index: u32) -> Self {
49000 self.inner.memory_bind_index = memory_bind_index;
49001 self
49002 }
49003 pub fn memory(mut self, memory: DeviceMemory) -> Self {
49004 self.inner.memory = memory;
49005 self
49006 }
49007 pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self {
49008 self.inner.memory_offset = memory_offset;
49009 self
49010 }
49011 pub fn memory_size(mut self, memory_size: DeviceSize) -> Self {
49012 self.inner.memory_size = memory_size;
49013 self
49014 }
49015 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49016 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49017 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
49018 pub fn build(self) -> VideoBindMemoryKHR {
49019 self.inner
49020 }
49021}
49022#[repr(C)]
49023#[cfg_attr(feature = "debug", derive(Debug))]
49024#[derive(Copy, Clone)]
49025#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoPictureResourceKHR.html>"]
49026pub struct VideoPictureResourceKHR {
49027 pub s_type: StructureType,
49028 pub p_next: *const c_void,
49029 pub coded_offset: Offset2D,
49030 pub coded_extent: Extent2D,
49031 pub base_array_layer: u32,
49032 pub image_view_binding: ImageView,
49033}
49034impl ::std::default::Default for VideoPictureResourceKHR {
49035 fn default() -> Self {
49036 Self {
49037 s_type: StructureType::VIDEO_PICTURE_RESOURCE_KHR,
49038 p_next: ::std::ptr::null(),
49039 coded_offset: Offset2D::default(),
49040 coded_extent: Extent2D::default(),
49041 base_array_layer: u32::default(),
49042 image_view_binding: ImageView::default(),
49043 }
49044 }
49045}
49046impl VideoPictureResourceKHR {
49047 pub fn builder<'a>() -> VideoPictureResourceKHRBuilder<'a> {
49048 VideoPictureResourceKHRBuilder {
49049 inner: Self::default(),
49050 marker: ::std::marker::PhantomData,
49051 }
49052 }
49053}
49054#[repr(transparent)]
49055pub struct VideoPictureResourceKHRBuilder<'a> {
49056 inner: VideoPictureResourceKHR,
49057 marker: ::std::marker::PhantomData<&'a ()>,
49058}
49059impl<'a> ::std::ops::Deref for VideoPictureResourceKHRBuilder<'a> {
49060 type Target = VideoPictureResourceKHR;
49061 fn deref(&self) -> &Self::Target {
49062 &self.inner
49063 }
49064}
49065impl<'a> ::std::ops::DerefMut for VideoPictureResourceKHRBuilder<'a> {
49066 fn deref_mut(&mut self) -> &mut Self::Target {
49067 &mut self.inner
49068 }
49069}
49070impl<'a> VideoPictureResourceKHRBuilder<'a> {
49071 pub fn coded_offset(mut self, coded_offset: Offset2D) -> Self {
49072 self.inner.coded_offset = coded_offset;
49073 self
49074 }
49075 pub fn coded_extent(mut self, coded_extent: Extent2D) -> Self {
49076 self.inner.coded_extent = coded_extent;
49077 self
49078 }
49079 pub fn base_array_layer(mut self, base_array_layer: u32) -> Self {
49080 self.inner.base_array_layer = base_array_layer;
49081 self
49082 }
49083 pub fn image_view_binding(mut self, image_view_binding: ImageView) -> Self {
49084 self.inner.image_view_binding = image_view_binding;
49085 self
49086 }
49087 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49088 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49089 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
49090 pub fn build(self) -> VideoPictureResourceKHR {
49091 self.inner
49092 }
49093}
49094#[repr(C)]
49095#[cfg_attr(feature = "debug", derive(Debug))]
49096#[derive(Copy, Clone)]
49097#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoReferenceSlotKHR.html>"]
49098pub struct VideoReferenceSlotKHR {
49099 pub s_type: StructureType,
49100 pub p_next: *const c_void,
49101 pub slot_index: i8,
49102 pub p_picture_resource: *const VideoPictureResourceKHR,
49103}
49104impl ::std::default::Default for VideoReferenceSlotKHR {
49105 fn default() -> Self {
49106 Self {
49107 s_type: StructureType::VIDEO_REFERENCE_SLOT_KHR,
49108 p_next: ::std::ptr::null(),
49109 slot_index: i8::default(),
49110 p_picture_resource: ::std::ptr::null(),
49111 }
49112 }
49113}
49114impl VideoReferenceSlotKHR {
49115 pub fn builder<'a>() -> VideoReferenceSlotKHRBuilder<'a> {
49116 VideoReferenceSlotKHRBuilder {
49117 inner: Self::default(),
49118 marker: ::std::marker::PhantomData,
49119 }
49120 }
49121}
49122#[repr(transparent)]
49123pub struct VideoReferenceSlotKHRBuilder<'a> {
49124 inner: VideoReferenceSlotKHR,
49125 marker: ::std::marker::PhantomData<&'a ()>,
49126}
49127pub unsafe trait ExtendsVideoReferenceSlotKHR {}
49128impl<'a> ::std::ops::Deref for VideoReferenceSlotKHRBuilder<'a> {
49129 type Target = VideoReferenceSlotKHR;
49130 fn deref(&self) -> &Self::Target {
49131 &self.inner
49132 }
49133}
49134impl<'a> ::std::ops::DerefMut for VideoReferenceSlotKHRBuilder<'a> {
49135 fn deref_mut(&mut self) -> &mut Self::Target {
49136 &mut self.inner
49137 }
49138}
49139impl<'a> VideoReferenceSlotKHRBuilder<'a> {
49140 pub fn slot_index(mut self, slot_index: i8) -> Self {
49141 self.inner.slot_index = slot_index;
49142 self
49143 }
49144 pub fn picture_resource(mut self, picture_resource: &'a VideoPictureResourceKHR) -> Self {
49145 self.inner.p_picture_resource = picture_resource;
49146 self
49147 }
49148 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
49149 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
49150 #[doc = r" valid extension structs can be pushed into the chain."]
49151 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
49152 #[doc = r" chain will look like `A -> D -> B -> C`."]
49153 pub fn push_next<T: ExtendsVideoReferenceSlotKHR>(mut self, next: &'a mut T) -> Self {
49154 unsafe {
49155 let next_ptr = <*const T>::cast(next);
49156 let last_next = ptr_chain_iter(next).last().unwrap();
49157 (*last_next).p_next = self.inner.p_next as _;
49158 self.inner.p_next = next_ptr;
49159 }
49160 self
49161 }
49162 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49163 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49164 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
49165 pub fn build(self) -> VideoReferenceSlotKHR {
49166 self.inner
49167 }
49168}
49169#[repr(C)]
49170#[cfg_attr(feature = "debug", derive(Debug))]
49171#[derive(Copy, Clone)]
49172#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeCapabilitiesKHR.html>"]
49173pub struct VideoDecodeCapabilitiesKHR {
49174 pub s_type: StructureType,
49175 pub p_next: *mut c_void,
49176 pub flags: VideoDecodeCapabilityFlagsKHR,
49177}
49178impl ::std::default::Default for VideoDecodeCapabilitiesKHR {
49179 fn default() -> Self {
49180 Self {
49181 s_type: StructureType::VIDEO_DECODE_CAPABILITIES_KHR,
49182 p_next: ::std::ptr::null_mut(),
49183 flags: VideoDecodeCapabilityFlagsKHR::default(),
49184 }
49185 }
49186}
49187impl VideoDecodeCapabilitiesKHR {
49188 pub fn builder<'a>() -> VideoDecodeCapabilitiesKHRBuilder<'a> {
49189 VideoDecodeCapabilitiesKHRBuilder {
49190 inner: Self::default(),
49191 marker: ::std::marker::PhantomData,
49192 }
49193 }
49194}
49195#[repr(transparent)]
49196pub struct VideoDecodeCapabilitiesKHRBuilder<'a> {
49197 inner: VideoDecodeCapabilitiesKHR,
49198 marker: ::std::marker::PhantomData<&'a ()>,
49199}
49200unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeCapabilitiesKHRBuilder<'_> {}
49201unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeCapabilitiesKHR {}
49202pub unsafe trait ExtendsVideoDecodeCapabilitiesKHR {}
49203impl<'a> ::std::ops::Deref for VideoDecodeCapabilitiesKHRBuilder<'a> {
49204 type Target = VideoDecodeCapabilitiesKHR;
49205 fn deref(&self) -> &Self::Target {
49206 &self.inner
49207 }
49208}
49209impl<'a> ::std::ops::DerefMut for VideoDecodeCapabilitiesKHRBuilder<'a> {
49210 fn deref_mut(&mut self) -> &mut Self::Target {
49211 &mut self.inner
49212 }
49213}
49214impl<'a> VideoDecodeCapabilitiesKHRBuilder<'a> {
49215 pub fn flags(mut self, flags: VideoDecodeCapabilityFlagsKHR) -> Self {
49216 self.inner.flags = flags;
49217 self
49218 }
49219 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
49220 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
49221 #[doc = r" valid extension structs can be pushed into the chain."]
49222 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
49223 #[doc = r" chain will look like `A -> D -> B -> C`."]
49224 pub fn push_next<T: ExtendsVideoDecodeCapabilitiesKHR>(mut self, next: &'a mut T) -> Self {
49225 unsafe {
49226 let next_ptr = <*mut T>::cast(next);
49227 let last_next = ptr_chain_iter(next).last().unwrap();
49228 (*last_next).p_next = self.inner.p_next as _;
49229 self.inner.p_next = next_ptr;
49230 }
49231 self
49232 }
49233 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49234 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49235 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
49236 pub fn build(self) -> VideoDecodeCapabilitiesKHR {
49237 self.inner
49238 }
49239}
49240#[repr(C)]
49241#[cfg_attr(feature = "debug", derive(Debug))]
49242#[derive(Copy, Clone)]
49243#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeInfoKHR.html>"]
49244pub struct VideoDecodeInfoKHR {
49245 pub s_type: StructureType,
49246 pub p_next: *const c_void,
49247 pub flags: VideoDecodeFlagsKHR,
49248 pub coded_offset: Offset2D,
49249 pub coded_extent: Extent2D,
49250 pub src_buffer: Buffer,
49251 pub src_buffer_offset: DeviceSize,
49252 pub src_buffer_range: DeviceSize,
49253 pub dst_picture_resource: VideoPictureResourceKHR,
49254 pub p_setup_reference_slot: *const VideoReferenceSlotKHR,
49255 pub reference_slot_count: u32,
49256 pub p_reference_slots: *const VideoReferenceSlotKHR,
49257}
49258impl ::std::default::Default for VideoDecodeInfoKHR {
49259 fn default() -> Self {
49260 Self {
49261 s_type: StructureType::VIDEO_DECODE_INFO_KHR,
49262 p_next: ::std::ptr::null(),
49263 flags: VideoDecodeFlagsKHR::default(),
49264 coded_offset: Offset2D::default(),
49265 coded_extent: Extent2D::default(),
49266 src_buffer: Buffer::default(),
49267 src_buffer_offset: DeviceSize::default(),
49268 src_buffer_range: DeviceSize::default(),
49269 dst_picture_resource: VideoPictureResourceKHR::default(),
49270 p_setup_reference_slot: ::std::ptr::null(),
49271 reference_slot_count: u32::default(),
49272 p_reference_slots: ::std::ptr::null(),
49273 }
49274 }
49275}
49276impl VideoDecodeInfoKHR {
49277 pub fn builder<'a>() -> VideoDecodeInfoKHRBuilder<'a> {
49278 VideoDecodeInfoKHRBuilder {
49279 inner: Self::default(),
49280 marker: ::std::marker::PhantomData,
49281 }
49282 }
49283}
49284#[repr(transparent)]
49285pub struct VideoDecodeInfoKHRBuilder<'a> {
49286 inner: VideoDecodeInfoKHR,
49287 marker: ::std::marker::PhantomData<&'a ()>,
49288}
49289pub unsafe trait ExtendsVideoDecodeInfoKHR {}
49290impl<'a> ::std::ops::Deref for VideoDecodeInfoKHRBuilder<'a> {
49291 type Target = VideoDecodeInfoKHR;
49292 fn deref(&self) -> &Self::Target {
49293 &self.inner
49294 }
49295}
49296impl<'a> ::std::ops::DerefMut for VideoDecodeInfoKHRBuilder<'a> {
49297 fn deref_mut(&mut self) -> &mut Self::Target {
49298 &mut self.inner
49299 }
49300}
49301impl<'a> VideoDecodeInfoKHRBuilder<'a> {
49302 pub fn flags(mut self, flags: VideoDecodeFlagsKHR) -> Self {
49303 self.inner.flags = flags;
49304 self
49305 }
49306 pub fn coded_offset(mut self, coded_offset: Offset2D) -> Self {
49307 self.inner.coded_offset = coded_offset;
49308 self
49309 }
49310 pub fn coded_extent(mut self, coded_extent: Extent2D) -> Self {
49311 self.inner.coded_extent = coded_extent;
49312 self
49313 }
49314 pub fn src_buffer(mut self, src_buffer: Buffer) -> Self {
49315 self.inner.src_buffer = src_buffer;
49316 self
49317 }
49318 pub fn src_buffer_offset(mut self, src_buffer_offset: DeviceSize) -> Self {
49319 self.inner.src_buffer_offset = src_buffer_offset;
49320 self
49321 }
49322 pub fn src_buffer_range(mut self, src_buffer_range: DeviceSize) -> Self {
49323 self.inner.src_buffer_range = src_buffer_range;
49324 self
49325 }
49326 pub fn dst_picture_resource(mut self, dst_picture_resource: VideoPictureResourceKHR) -> Self {
49327 self.inner.dst_picture_resource = dst_picture_resource;
49328 self
49329 }
49330 pub fn setup_reference_slot(mut self, setup_reference_slot: &'a VideoReferenceSlotKHR) -> Self {
49331 self.inner.p_setup_reference_slot = setup_reference_slot;
49332 self
49333 }
49334 pub fn reference_slots(mut self, reference_slots: &'a [VideoReferenceSlotKHR]) -> Self {
49335 self.inner.reference_slot_count = reference_slots.len() as _;
49336 self.inner.p_reference_slots = reference_slots.as_ptr();
49337 self
49338 }
49339 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
49340 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
49341 #[doc = r" valid extension structs can be pushed into the chain."]
49342 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
49343 #[doc = r" chain will look like `A -> D -> B -> C`."]
49344 pub fn push_next<T: ExtendsVideoDecodeInfoKHR>(mut self, next: &'a mut T) -> Self {
49345 unsafe {
49346 let next_ptr = <*const T>::cast(next);
49347 let last_next = ptr_chain_iter(next).last().unwrap();
49348 (*last_next).p_next = self.inner.p_next as _;
49349 self.inner.p_next = next_ptr;
49350 }
49351 self
49352 }
49353 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49354 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49355 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
49356 pub fn build(self) -> VideoDecodeInfoKHR {
49357 self.inner
49358 }
49359}
49360#[repr(C)]
49361#[cfg_attr(feature = "debug", derive(Debug))]
49362#[derive(Copy, Clone)]
49363#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264ProfileEXT.html>"]
49364pub struct VideoDecodeH264ProfileEXT {
49365 pub s_type: StructureType,
49366 pub p_next: *const c_void,
49367 pub std_profile_idc: StdVideoH264ProfileIdc,
49368 pub picture_layout: VideoDecodeH264PictureLayoutFlagsEXT,
49369}
49370impl ::std::default::Default for VideoDecodeH264ProfileEXT {
49371 fn default() -> Self {
49372 Self {
49373 s_type: StructureType::VIDEO_DECODE_H264_PROFILE_EXT,
49374 p_next: ::std::ptr::null(),
49375 std_profile_idc: StdVideoH264ProfileIdc::default(),
49376 picture_layout: VideoDecodeH264PictureLayoutFlagsEXT::default(),
49377 }
49378 }
49379}
49380impl VideoDecodeH264ProfileEXT {
49381 pub fn builder<'a>() -> VideoDecodeH264ProfileEXTBuilder<'a> {
49382 VideoDecodeH264ProfileEXTBuilder {
49383 inner: Self::default(),
49384 marker: ::std::marker::PhantomData,
49385 }
49386 }
49387}
49388#[repr(transparent)]
49389pub struct VideoDecodeH264ProfileEXTBuilder<'a> {
49390 inner: VideoDecodeH264ProfileEXT,
49391 marker: ::std::marker::PhantomData<&'a ()>,
49392}
49393unsafe impl ExtendsVideoProfileKHR for VideoDecodeH264ProfileEXTBuilder<'_> {}
49394unsafe impl ExtendsVideoProfileKHR for VideoDecodeH264ProfileEXT {}
49395unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH264ProfileEXTBuilder<'_> {}
49396unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH264ProfileEXT {}
49397unsafe impl ExtendsFormatProperties2 for VideoDecodeH264ProfileEXTBuilder<'_> {}
49398unsafe impl ExtendsFormatProperties2 for VideoDecodeH264ProfileEXT {}
49399unsafe impl ExtendsImageCreateInfo for VideoDecodeH264ProfileEXTBuilder<'_> {}
49400unsafe impl ExtendsImageCreateInfo for VideoDecodeH264ProfileEXT {}
49401unsafe impl ExtendsImageViewCreateInfo for VideoDecodeH264ProfileEXTBuilder<'_> {}
49402unsafe impl ExtendsImageViewCreateInfo for VideoDecodeH264ProfileEXT {}
49403unsafe impl ExtendsBufferCreateInfo for VideoDecodeH264ProfileEXTBuilder<'_> {}
49404unsafe impl ExtendsBufferCreateInfo for VideoDecodeH264ProfileEXT {}
49405impl<'a> ::std::ops::Deref for VideoDecodeH264ProfileEXTBuilder<'a> {
49406 type Target = VideoDecodeH264ProfileEXT;
49407 fn deref(&self) -> &Self::Target {
49408 &self.inner
49409 }
49410}
49411impl<'a> ::std::ops::DerefMut for VideoDecodeH264ProfileEXTBuilder<'a> {
49412 fn deref_mut(&mut self) -> &mut Self::Target {
49413 &mut self.inner
49414 }
49415}
49416impl<'a> VideoDecodeH264ProfileEXTBuilder<'a> {
49417 pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH264ProfileIdc) -> Self {
49418 self.inner.std_profile_idc = std_profile_idc;
49419 self
49420 }
49421 pub fn picture_layout(mut self, picture_layout: VideoDecodeH264PictureLayoutFlagsEXT) -> Self {
49422 self.inner.picture_layout = picture_layout;
49423 self
49424 }
49425 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49426 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49427 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
49428 pub fn build(self) -> VideoDecodeH264ProfileEXT {
49429 self.inner
49430 }
49431}
49432#[repr(C)]
49433#[cfg_attr(feature = "debug", derive(Debug))]
49434#[derive(Copy, Clone)]
49435#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264CapabilitiesEXT.html>"]
49436pub struct VideoDecodeH264CapabilitiesEXT {
49437 pub s_type: StructureType,
49438 pub p_next: *mut c_void,
49439 pub max_level: u32,
49440 pub field_offset_granularity: Offset2D,
49441}
49442impl ::std::default::Default for VideoDecodeH264CapabilitiesEXT {
49443 fn default() -> Self {
49444 Self {
49445 s_type: StructureType::VIDEO_DECODE_H264_CAPABILITIES_EXT,
49446 p_next: ::std::ptr::null_mut(),
49447 max_level: u32::default(),
49448 field_offset_granularity: Offset2D::default(),
49449 }
49450 }
49451}
49452impl VideoDecodeH264CapabilitiesEXT {
49453 pub fn builder<'a>() -> VideoDecodeH264CapabilitiesEXTBuilder<'a> {
49454 VideoDecodeH264CapabilitiesEXTBuilder {
49455 inner: Self::default(),
49456 marker: ::std::marker::PhantomData,
49457 }
49458 }
49459}
49460#[repr(transparent)]
49461pub struct VideoDecodeH264CapabilitiesEXTBuilder<'a> {
49462 inner: VideoDecodeH264CapabilitiesEXT,
49463 marker: ::std::marker::PhantomData<&'a ()>,
49464}
49465unsafe impl ExtendsVideoDecodeCapabilitiesKHR for VideoDecodeH264CapabilitiesEXTBuilder<'_> {}
49466unsafe impl ExtendsVideoDecodeCapabilitiesKHR for VideoDecodeH264CapabilitiesEXT {}
49467impl<'a> ::std::ops::Deref for VideoDecodeH264CapabilitiesEXTBuilder<'a> {
49468 type Target = VideoDecodeH264CapabilitiesEXT;
49469 fn deref(&self) -> &Self::Target {
49470 &self.inner
49471 }
49472}
49473impl<'a> ::std::ops::DerefMut for VideoDecodeH264CapabilitiesEXTBuilder<'a> {
49474 fn deref_mut(&mut self) -> &mut Self::Target {
49475 &mut self.inner
49476 }
49477}
49478impl<'a> VideoDecodeH264CapabilitiesEXTBuilder<'a> {
49479 pub fn max_level(mut self, max_level: u32) -> Self {
49480 self.inner.max_level = max_level;
49481 self
49482 }
49483 pub fn field_offset_granularity(mut self, field_offset_granularity: Offset2D) -> Self {
49484 self.inner.field_offset_granularity = field_offset_granularity;
49485 self
49486 }
49487 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49488 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49489 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
49490 pub fn build(self) -> VideoDecodeH264CapabilitiesEXT {
49491 self.inner
49492 }
49493}
49494#[repr(C)]
49495#[cfg_attr(feature = "debug", derive(Debug))]
49496#[derive(Copy, Clone)]
49497#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264SessionParametersAddInfoEXT.html>"]
49498pub struct VideoDecodeH264SessionParametersAddInfoEXT {
49499 pub s_type: StructureType,
49500 pub p_next: *const c_void,
49501 pub sps_std_count: u32,
49502 pub p_sps_std: *const StdVideoH264SequenceParameterSet,
49503 pub pps_std_count: u32,
49504 pub p_pps_std: *const StdVideoH264PictureParameterSet,
49505}
49506impl ::std::default::Default for VideoDecodeH264SessionParametersAddInfoEXT {
49507 fn default() -> Self {
49508 Self {
49509 s_type: StructureType::VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT,
49510 p_next: ::std::ptr::null(),
49511 sps_std_count: u32::default(),
49512 p_sps_std: ::std::ptr::null(),
49513 pps_std_count: u32::default(),
49514 p_pps_std: ::std::ptr::null(),
49515 }
49516 }
49517}
49518impl VideoDecodeH264SessionParametersAddInfoEXT {
49519 pub fn builder<'a>() -> VideoDecodeH264SessionParametersAddInfoEXTBuilder<'a> {
49520 VideoDecodeH264SessionParametersAddInfoEXTBuilder {
49521 inner: Self::default(),
49522 marker: ::std::marker::PhantomData,
49523 }
49524 }
49525}
49526#[repr(transparent)]
49527pub struct VideoDecodeH264SessionParametersAddInfoEXTBuilder<'a> {
49528 inner: VideoDecodeH264SessionParametersAddInfoEXT,
49529 marker: ::std::marker::PhantomData<&'a ()>,
49530}
49531unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
49532 for VideoDecodeH264SessionParametersAddInfoEXTBuilder<'_>
49533{
49534}
49535unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
49536 for VideoDecodeH264SessionParametersAddInfoEXT
49537{
49538}
49539impl<'a> ::std::ops::Deref for VideoDecodeH264SessionParametersAddInfoEXTBuilder<'a> {
49540 type Target = VideoDecodeH264SessionParametersAddInfoEXT;
49541 fn deref(&self) -> &Self::Target {
49542 &self.inner
49543 }
49544}
49545impl<'a> ::std::ops::DerefMut for VideoDecodeH264SessionParametersAddInfoEXTBuilder<'a> {
49546 fn deref_mut(&mut self) -> &mut Self::Target {
49547 &mut self.inner
49548 }
49549}
49550impl<'a> VideoDecodeH264SessionParametersAddInfoEXTBuilder<'a> {
49551 pub fn sps_std(mut self, sps_std: &'a [StdVideoH264SequenceParameterSet]) -> Self {
49552 self.inner.sps_std_count = sps_std.len() as _;
49553 self.inner.p_sps_std = sps_std.as_ptr();
49554 self
49555 }
49556 pub fn pps_std(mut self, pps_std: &'a [StdVideoH264PictureParameterSet]) -> Self {
49557 self.inner.pps_std_count = pps_std.len() as _;
49558 self.inner.p_pps_std = pps_std.as_ptr();
49559 self
49560 }
49561 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49562 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49563 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
49564 pub fn build(self) -> VideoDecodeH264SessionParametersAddInfoEXT {
49565 self.inner
49566 }
49567}
49568#[repr(C)]
49569#[cfg_attr(feature = "debug", derive(Debug))]
49570#[derive(Copy, Clone)]
49571#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264SessionParametersCreateInfoEXT.html>"]
49572pub struct VideoDecodeH264SessionParametersCreateInfoEXT {
49573 pub s_type: StructureType,
49574 pub p_next: *const c_void,
49575 pub max_sps_std_count: u32,
49576 pub max_pps_std_count: u32,
49577 pub p_parameters_add_info: *const VideoDecodeH264SessionParametersAddInfoEXT,
49578}
49579impl ::std::default::Default for VideoDecodeH264SessionParametersCreateInfoEXT {
49580 fn default() -> Self {
49581 Self {
49582 s_type: StructureType::VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT,
49583 p_next: ::std::ptr::null(),
49584 max_sps_std_count: u32::default(),
49585 max_pps_std_count: u32::default(),
49586 p_parameters_add_info: ::std::ptr::null(),
49587 }
49588 }
49589}
49590impl VideoDecodeH264SessionParametersCreateInfoEXT {
49591 pub fn builder<'a>() -> VideoDecodeH264SessionParametersCreateInfoEXTBuilder<'a> {
49592 VideoDecodeH264SessionParametersCreateInfoEXTBuilder {
49593 inner: Self::default(),
49594 marker: ::std::marker::PhantomData,
49595 }
49596 }
49597}
49598#[repr(transparent)]
49599pub struct VideoDecodeH264SessionParametersCreateInfoEXTBuilder<'a> {
49600 inner: VideoDecodeH264SessionParametersCreateInfoEXT,
49601 marker: ::std::marker::PhantomData<&'a ()>,
49602}
49603unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
49604 for VideoDecodeH264SessionParametersCreateInfoEXTBuilder<'_>
49605{
49606}
49607unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
49608 for VideoDecodeH264SessionParametersCreateInfoEXT
49609{
49610}
49611impl<'a> ::std::ops::Deref for VideoDecodeH264SessionParametersCreateInfoEXTBuilder<'a> {
49612 type Target = VideoDecodeH264SessionParametersCreateInfoEXT;
49613 fn deref(&self) -> &Self::Target {
49614 &self.inner
49615 }
49616}
49617impl<'a> ::std::ops::DerefMut for VideoDecodeH264SessionParametersCreateInfoEXTBuilder<'a> {
49618 fn deref_mut(&mut self) -> &mut Self::Target {
49619 &mut self.inner
49620 }
49621}
49622impl<'a> VideoDecodeH264SessionParametersCreateInfoEXTBuilder<'a> {
49623 pub fn max_sps_std_count(mut self, max_sps_std_count: u32) -> Self {
49624 self.inner.max_sps_std_count = max_sps_std_count;
49625 self
49626 }
49627 pub fn max_pps_std_count(mut self, max_pps_std_count: u32) -> Self {
49628 self.inner.max_pps_std_count = max_pps_std_count;
49629 self
49630 }
49631 pub fn parameters_add_info(
49632 mut self,
49633 parameters_add_info: &'a VideoDecodeH264SessionParametersAddInfoEXT,
49634 ) -> Self {
49635 self.inner.p_parameters_add_info = parameters_add_info;
49636 self
49637 }
49638 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49639 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49640 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
49641 pub fn build(self) -> VideoDecodeH264SessionParametersCreateInfoEXT {
49642 self.inner
49643 }
49644}
49645#[repr(C)]
49646#[cfg_attr(feature = "debug", derive(Debug))]
49647#[derive(Copy, Clone)]
49648#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264PictureInfoEXT.html>"]
49649pub struct VideoDecodeH264PictureInfoEXT {
49650 pub s_type: StructureType,
49651 pub p_next: *const c_void,
49652 pub p_std_picture_info: *const StdVideoDecodeH264PictureInfo,
49653 pub slices_count: u32,
49654 pub p_slices_data_offsets: *const u32,
49655}
49656impl ::std::default::Default for VideoDecodeH264PictureInfoEXT {
49657 fn default() -> Self {
49658 Self {
49659 s_type: StructureType::VIDEO_DECODE_H264_PICTURE_INFO_EXT,
49660 p_next: ::std::ptr::null(),
49661 p_std_picture_info: ::std::ptr::null(),
49662 slices_count: u32::default(),
49663 p_slices_data_offsets: ::std::ptr::null(),
49664 }
49665 }
49666}
49667impl VideoDecodeH264PictureInfoEXT {
49668 pub fn builder<'a>() -> VideoDecodeH264PictureInfoEXTBuilder<'a> {
49669 VideoDecodeH264PictureInfoEXTBuilder {
49670 inner: Self::default(),
49671 marker: ::std::marker::PhantomData,
49672 }
49673 }
49674}
49675#[repr(transparent)]
49676pub struct VideoDecodeH264PictureInfoEXTBuilder<'a> {
49677 inner: VideoDecodeH264PictureInfoEXT,
49678 marker: ::std::marker::PhantomData<&'a ()>,
49679}
49680unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH264PictureInfoEXTBuilder<'_> {}
49681unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH264PictureInfoEXT {}
49682pub unsafe trait ExtendsVideoDecodeH264PictureInfoEXT {}
49683impl<'a> ::std::ops::Deref for VideoDecodeH264PictureInfoEXTBuilder<'a> {
49684 type Target = VideoDecodeH264PictureInfoEXT;
49685 fn deref(&self) -> &Self::Target {
49686 &self.inner
49687 }
49688}
49689impl<'a> ::std::ops::DerefMut for VideoDecodeH264PictureInfoEXTBuilder<'a> {
49690 fn deref_mut(&mut self) -> &mut Self::Target {
49691 &mut self.inner
49692 }
49693}
49694impl<'a> VideoDecodeH264PictureInfoEXTBuilder<'a> {
49695 pub fn std_picture_info(mut self, std_picture_info: &'a StdVideoDecodeH264PictureInfo) -> Self {
49696 self.inner.p_std_picture_info = std_picture_info;
49697 self
49698 }
49699 pub fn slices_data_offsets(mut self, slices_data_offsets: &'a [u32]) -> Self {
49700 self.inner.slices_count = slices_data_offsets.len() as _;
49701 self.inner.p_slices_data_offsets = slices_data_offsets.as_ptr();
49702 self
49703 }
49704 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
49705 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
49706 #[doc = r" valid extension structs can be pushed into the chain."]
49707 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
49708 #[doc = r" chain will look like `A -> D -> B -> C`."]
49709 pub fn push_next<T: ExtendsVideoDecodeH264PictureInfoEXT>(mut self, next: &'a mut T) -> Self {
49710 unsafe {
49711 let next_ptr = <*const T>::cast(next);
49712 let last_next = ptr_chain_iter(next).last().unwrap();
49713 (*last_next).p_next = self.inner.p_next as _;
49714 self.inner.p_next = next_ptr;
49715 }
49716 self
49717 }
49718 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49719 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49720 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
49721 pub fn build(self) -> VideoDecodeH264PictureInfoEXT {
49722 self.inner
49723 }
49724}
49725#[repr(C)]
49726#[cfg_attr(feature = "debug", derive(Debug))]
49727#[derive(Copy, Clone)]
49728#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264DpbSlotInfoEXT.html>"]
49729pub struct VideoDecodeH264DpbSlotInfoEXT {
49730 pub s_type: StructureType,
49731 pub p_next: *const c_void,
49732 pub p_std_reference_info: *const StdVideoDecodeH264ReferenceInfo,
49733}
49734impl ::std::default::Default for VideoDecodeH264DpbSlotInfoEXT {
49735 fn default() -> Self {
49736 Self {
49737 s_type: StructureType::VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT,
49738 p_next: ::std::ptr::null(),
49739 p_std_reference_info: ::std::ptr::null(),
49740 }
49741 }
49742}
49743impl VideoDecodeH264DpbSlotInfoEXT {
49744 pub fn builder<'a>() -> VideoDecodeH264DpbSlotInfoEXTBuilder<'a> {
49745 VideoDecodeH264DpbSlotInfoEXTBuilder {
49746 inner: Self::default(),
49747 marker: ::std::marker::PhantomData,
49748 }
49749 }
49750}
49751#[repr(transparent)]
49752pub struct VideoDecodeH264DpbSlotInfoEXTBuilder<'a> {
49753 inner: VideoDecodeH264DpbSlotInfoEXT,
49754 marker: ::std::marker::PhantomData<&'a ()>,
49755}
49756unsafe impl ExtendsVideoReferenceSlotKHR for VideoDecodeH264DpbSlotInfoEXTBuilder<'_> {}
49757unsafe impl ExtendsVideoReferenceSlotKHR for VideoDecodeH264DpbSlotInfoEXT {}
49758impl<'a> ::std::ops::Deref for VideoDecodeH264DpbSlotInfoEXTBuilder<'a> {
49759 type Target = VideoDecodeH264DpbSlotInfoEXT;
49760 fn deref(&self) -> &Self::Target {
49761 &self.inner
49762 }
49763}
49764impl<'a> ::std::ops::DerefMut for VideoDecodeH264DpbSlotInfoEXTBuilder<'a> {
49765 fn deref_mut(&mut self) -> &mut Self::Target {
49766 &mut self.inner
49767 }
49768}
49769impl<'a> VideoDecodeH264DpbSlotInfoEXTBuilder<'a> {
49770 pub fn std_reference_info(
49771 mut self,
49772 std_reference_info: &'a StdVideoDecodeH264ReferenceInfo,
49773 ) -> Self {
49774 self.inner.p_std_reference_info = std_reference_info;
49775 self
49776 }
49777 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49778 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49779 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
49780 pub fn build(self) -> VideoDecodeH264DpbSlotInfoEXT {
49781 self.inner
49782 }
49783}
49784#[repr(C)]
49785#[cfg_attr(feature = "debug", derive(Debug))]
49786#[derive(Copy, Clone)]
49787#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264MvcEXT.html>"]
49788pub struct VideoDecodeH264MvcEXT {
49789 pub s_type: StructureType,
49790 pub p_next: *const c_void,
49791 pub p_std_mvc: *const StdVideoDecodeH264Mvc,
49792}
49793impl ::std::default::Default for VideoDecodeH264MvcEXT {
49794 fn default() -> Self {
49795 Self {
49796 s_type: StructureType::VIDEO_DECODE_H264_MVC_EXT,
49797 p_next: ::std::ptr::null(),
49798 p_std_mvc: ::std::ptr::null(),
49799 }
49800 }
49801}
49802impl VideoDecodeH264MvcEXT {
49803 pub fn builder<'a>() -> VideoDecodeH264MvcEXTBuilder<'a> {
49804 VideoDecodeH264MvcEXTBuilder {
49805 inner: Self::default(),
49806 marker: ::std::marker::PhantomData,
49807 }
49808 }
49809}
49810#[repr(transparent)]
49811pub struct VideoDecodeH264MvcEXTBuilder<'a> {
49812 inner: VideoDecodeH264MvcEXT,
49813 marker: ::std::marker::PhantomData<&'a ()>,
49814}
49815unsafe impl ExtendsVideoDecodeH264PictureInfoEXT for VideoDecodeH264MvcEXTBuilder<'_> {}
49816unsafe impl ExtendsVideoDecodeH264PictureInfoEXT for VideoDecodeH264MvcEXT {}
49817impl<'a> ::std::ops::Deref for VideoDecodeH264MvcEXTBuilder<'a> {
49818 type Target = VideoDecodeH264MvcEXT;
49819 fn deref(&self) -> &Self::Target {
49820 &self.inner
49821 }
49822}
49823impl<'a> ::std::ops::DerefMut for VideoDecodeH264MvcEXTBuilder<'a> {
49824 fn deref_mut(&mut self) -> &mut Self::Target {
49825 &mut self.inner
49826 }
49827}
49828impl<'a> VideoDecodeH264MvcEXTBuilder<'a> {
49829 pub fn std_mvc(mut self, std_mvc: &'a StdVideoDecodeH264Mvc) -> Self {
49830 self.inner.p_std_mvc = std_mvc;
49831 self
49832 }
49833 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49834 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49835 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
49836 pub fn build(self) -> VideoDecodeH264MvcEXT {
49837 self.inner
49838 }
49839}
49840#[repr(C)]
49841#[cfg_attr(feature = "debug", derive(Debug))]
49842#[derive(Copy, Clone)]
49843#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265ProfileEXT.html>"]
49844pub struct VideoDecodeH265ProfileEXT {
49845 pub s_type: StructureType,
49846 pub p_next: *const c_void,
49847 pub std_profile_idc: StdVideoH265ProfileIdc,
49848}
49849impl ::std::default::Default for VideoDecodeH265ProfileEXT {
49850 fn default() -> Self {
49851 Self {
49852 s_type: StructureType::VIDEO_DECODE_H265_PROFILE_EXT,
49853 p_next: ::std::ptr::null(),
49854 std_profile_idc: StdVideoH265ProfileIdc::default(),
49855 }
49856 }
49857}
49858impl VideoDecodeH265ProfileEXT {
49859 pub fn builder<'a>() -> VideoDecodeH265ProfileEXTBuilder<'a> {
49860 VideoDecodeH265ProfileEXTBuilder {
49861 inner: Self::default(),
49862 marker: ::std::marker::PhantomData,
49863 }
49864 }
49865}
49866#[repr(transparent)]
49867pub struct VideoDecodeH265ProfileEXTBuilder<'a> {
49868 inner: VideoDecodeH265ProfileEXT,
49869 marker: ::std::marker::PhantomData<&'a ()>,
49870}
49871unsafe impl ExtendsVideoProfileKHR for VideoDecodeH265ProfileEXTBuilder<'_> {}
49872unsafe impl ExtendsVideoProfileKHR for VideoDecodeH265ProfileEXT {}
49873unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH265ProfileEXTBuilder<'_> {}
49874unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH265ProfileEXT {}
49875unsafe impl ExtendsFormatProperties2 for VideoDecodeH265ProfileEXTBuilder<'_> {}
49876unsafe impl ExtendsFormatProperties2 for VideoDecodeH265ProfileEXT {}
49877unsafe impl ExtendsImageCreateInfo for VideoDecodeH265ProfileEXTBuilder<'_> {}
49878unsafe impl ExtendsImageCreateInfo for VideoDecodeH265ProfileEXT {}
49879unsafe impl ExtendsImageViewCreateInfo for VideoDecodeH265ProfileEXTBuilder<'_> {}
49880unsafe impl ExtendsImageViewCreateInfo for VideoDecodeH265ProfileEXT {}
49881unsafe impl ExtendsBufferCreateInfo for VideoDecodeH265ProfileEXTBuilder<'_> {}
49882unsafe impl ExtendsBufferCreateInfo for VideoDecodeH265ProfileEXT {}
49883impl<'a> ::std::ops::Deref for VideoDecodeH265ProfileEXTBuilder<'a> {
49884 type Target = VideoDecodeH265ProfileEXT;
49885 fn deref(&self) -> &Self::Target {
49886 &self.inner
49887 }
49888}
49889impl<'a> ::std::ops::DerefMut for VideoDecodeH265ProfileEXTBuilder<'a> {
49890 fn deref_mut(&mut self) -> &mut Self::Target {
49891 &mut self.inner
49892 }
49893}
49894impl<'a> VideoDecodeH265ProfileEXTBuilder<'a> {
49895 pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH265ProfileIdc) -> Self {
49896 self.inner.std_profile_idc = std_profile_idc;
49897 self
49898 }
49899 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49900 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49901 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
49902 pub fn build(self) -> VideoDecodeH265ProfileEXT {
49903 self.inner
49904 }
49905}
49906#[repr(C)]
49907#[cfg_attr(feature = "debug", derive(Debug))]
49908#[derive(Copy, Clone)]
49909#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265CapabilitiesEXT.html>"]
49910pub struct VideoDecodeH265CapabilitiesEXT {
49911 pub s_type: StructureType,
49912 pub p_next: *mut c_void,
49913 pub max_level: u32,
49914}
49915impl ::std::default::Default for VideoDecodeH265CapabilitiesEXT {
49916 fn default() -> Self {
49917 Self {
49918 s_type: StructureType::VIDEO_DECODE_H265_CAPABILITIES_EXT,
49919 p_next: ::std::ptr::null_mut(),
49920 max_level: u32::default(),
49921 }
49922 }
49923}
49924impl VideoDecodeH265CapabilitiesEXT {
49925 pub fn builder<'a>() -> VideoDecodeH265CapabilitiesEXTBuilder<'a> {
49926 VideoDecodeH265CapabilitiesEXTBuilder {
49927 inner: Self::default(),
49928 marker: ::std::marker::PhantomData,
49929 }
49930 }
49931}
49932#[repr(transparent)]
49933pub struct VideoDecodeH265CapabilitiesEXTBuilder<'a> {
49934 inner: VideoDecodeH265CapabilitiesEXT,
49935 marker: ::std::marker::PhantomData<&'a ()>,
49936}
49937unsafe impl ExtendsVideoDecodeCapabilitiesKHR for VideoDecodeH265CapabilitiesEXTBuilder<'_> {}
49938unsafe impl ExtendsVideoDecodeCapabilitiesKHR for VideoDecodeH265CapabilitiesEXT {}
49939impl<'a> ::std::ops::Deref for VideoDecodeH265CapabilitiesEXTBuilder<'a> {
49940 type Target = VideoDecodeH265CapabilitiesEXT;
49941 fn deref(&self) -> &Self::Target {
49942 &self.inner
49943 }
49944}
49945impl<'a> ::std::ops::DerefMut for VideoDecodeH265CapabilitiesEXTBuilder<'a> {
49946 fn deref_mut(&mut self) -> &mut Self::Target {
49947 &mut self.inner
49948 }
49949}
49950impl<'a> VideoDecodeH265CapabilitiesEXTBuilder<'a> {
49951 pub fn max_level(mut self, max_level: u32) -> Self {
49952 self.inner.max_level = max_level;
49953 self
49954 }
49955 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49956 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49957 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
49958 pub fn build(self) -> VideoDecodeH265CapabilitiesEXT {
49959 self.inner
49960 }
49961}
49962#[repr(C)]
49963#[cfg_attr(feature = "debug", derive(Debug))]
49964#[derive(Copy, Clone)]
49965#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265SessionParametersAddInfoEXT.html>"]
49966pub struct VideoDecodeH265SessionParametersAddInfoEXT {
49967 pub s_type: StructureType,
49968 pub p_next: *const c_void,
49969 pub vps_std_count: u32,
49970 pub p_vps_std: *const StdVideoH265VideoParameterSet,
49971 pub sps_std_count: u32,
49972 pub p_sps_std: *const StdVideoH265SequenceParameterSet,
49973 pub pps_std_count: u32,
49974 pub p_pps_std: *const StdVideoH265PictureParameterSet,
49975}
49976impl ::std::default::Default for VideoDecodeH265SessionParametersAddInfoEXT {
49977 fn default() -> Self {
49978 Self {
49979 s_type: StructureType::VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT,
49980 p_next: ::std::ptr::null(),
49981 vps_std_count: u32::default(),
49982 p_vps_std: ::std::ptr::null(),
49983 sps_std_count: u32::default(),
49984 p_sps_std: ::std::ptr::null(),
49985 pps_std_count: u32::default(),
49986 p_pps_std: ::std::ptr::null(),
49987 }
49988 }
49989}
49990impl VideoDecodeH265SessionParametersAddInfoEXT {
49991 pub fn builder<'a>() -> VideoDecodeH265SessionParametersAddInfoEXTBuilder<'a> {
49992 VideoDecodeH265SessionParametersAddInfoEXTBuilder {
49993 inner: Self::default(),
49994 marker: ::std::marker::PhantomData,
49995 }
49996 }
49997}
49998#[repr(transparent)]
49999pub struct VideoDecodeH265SessionParametersAddInfoEXTBuilder<'a> {
50000 inner: VideoDecodeH265SessionParametersAddInfoEXT,
50001 marker: ::std::marker::PhantomData<&'a ()>,
50002}
50003unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
50004 for VideoDecodeH265SessionParametersAddInfoEXTBuilder<'_>
50005{
50006}
50007unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
50008 for VideoDecodeH265SessionParametersAddInfoEXT
50009{
50010}
50011impl<'a> ::std::ops::Deref for VideoDecodeH265SessionParametersAddInfoEXTBuilder<'a> {
50012 type Target = VideoDecodeH265SessionParametersAddInfoEXT;
50013 fn deref(&self) -> &Self::Target {
50014 &self.inner
50015 }
50016}
50017impl<'a> ::std::ops::DerefMut for VideoDecodeH265SessionParametersAddInfoEXTBuilder<'a> {
50018 fn deref_mut(&mut self) -> &mut Self::Target {
50019 &mut self.inner
50020 }
50021}
50022impl<'a> VideoDecodeH265SessionParametersAddInfoEXTBuilder<'a> {
50023 pub fn vps_std(mut self, vps_std: &'a [StdVideoH265VideoParameterSet]) -> Self {
50024 self.inner.vps_std_count = vps_std.len() as _;
50025 self.inner.p_vps_std = vps_std.as_ptr();
50026 self
50027 }
50028 pub fn sps_std(mut self, sps_std: &'a [StdVideoH265SequenceParameterSet]) -> Self {
50029 self.inner.sps_std_count = sps_std.len() as _;
50030 self.inner.p_sps_std = sps_std.as_ptr();
50031 self
50032 }
50033 pub fn pps_std(mut self, pps_std: &'a [StdVideoH265PictureParameterSet]) -> Self {
50034 self.inner.pps_std_count = pps_std.len() as _;
50035 self.inner.p_pps_std = pps_std.as_ptr();
50036 self
50037 }
50038 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50039 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50040 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
50041 pub fn build(self) -> VideoDecodeH265SessionParametersAddInfoEXT {
50042 self.inner
50043 }
50044}
50045#[repr(C)]
50046#[cfg_attr(feature = "debug", derive(Debug))]
50047#[derive(Copy, Clone)]
50048#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265SessionParametersCreateInfoEXT.html>"]
50049pub struct VideoDecodeH265SessionParametersCreateInfoEXT {
50050 pub s_type: StructureType,
50051 pub p_next: *const c_void,
50052 pub max_vps_std_count: u32,
50053 pub max_sps_std_count: u32,
50054 pub max_pps_std_count: u32,
50055 pub p_parameters_add_info: *const VideoDecodeH265SessionParametersAddInfoEXT,
50056}
50057impl ::std::default::Default for VideoDecodeH265SessionParametersCreateInfoEXT {
50058 fn default() -> Self {
50059 Self {
50060 s_type: StructureType::VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT,
50061 p_next: ::std::ptr::null(),
50062 max_vps_std_count: u32::default(),
50063 max_sps_std_count: u32::default(),
50064 max_pps_std_count: u32::default(),
50065 p_parameters_add_info: ::std::ptr::null(),
50066 }
50067 }
50068}
50069impl VideoDecodeH265SessionParametersCreateInfoEXT {
50070 pub fn builder<'a>() -> VideoDecodeH265SessionParametersCreateInfoEXTBuilder<'a> {
50071 VideoDecodeH265SessionParametersCreateInfoEXTBuilder {
50072 inner: Self::default(),
50073 marker: ::std::marker::PhantomData,
50074 }
50075 }
50076}
50077#[repr(transparent)]
50078pub struct VideoDecodeH265SessionParametersCreateInfoEXTBuilder<'a> {
50079 inner: VideoDecodeH265SessionParametersCreateInfoEXT,
50080 marker: ::std::marker::PhantomData<&'a ()>,
50081}
50082unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
50083 for VideoDecodeH265SessionParametersCreateInfoEXTBuilder<'_>
50084{
50085}
50086unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
50087 for VideoDecodeH265SessionParametersCreateInfoEXT
50088{
50089}
50090impl<'a> ::std::ops::Deref for VideoDecodeH265SessionParametersCreateInfoEXTBuilder<'a> {
50091 type Target = VideoDecodeH265SessionParametersCreateInfoEXT;
50092 fn deref(&self) -> &Self::Target {
50093 &self.inner
50094 }
50095}
50096impl<'a> ::std::ops::DerefMut for VideoDecodeH265SessionParametersCreateInfoEXTBuilder<'a> {
50097 fn deref_mut(&mut self) -> &mut Self::Target {
50098 &mut self.inner
50099 }
50100}
50101impl<'a> VideoDecodeH265SessionParametersCreateInfoEXTBuilder<'a> {
50102 pub fn max_vps_std_count(mut self, max_vps_std_count: u32) -> Self {
50103 self.inner.max_vps_std_count = max_vps_std_count;
50104 self
50105 }
50106 pub fn max_sps_std_count(mut self, max_sps_std_count: u32) -> Self {
50107 self.inner.max_sps_std_count = max_sps_std_count;
50108 self
50109 }
50110 pub fn max_pps_std_count(mut self, max_pps_std_count: u32) -> Self {
50111 self.inner.max_pps_std_count = max_pps_std_count;
50112 self
50113 }
50114 pub fn parameters_add_info(
50115 mut self,
50116 parameters_add_info: &'a VideoDecodeH265SessionParametersAddInfoEXT,
50117 ) -> Self {
50118 self.inner.p_parameters_add_info = parameters_add_info;
50119 self
50120 }
50121 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50122 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50123 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
50124 pub fn build(self) -> VideoDecodeH265SessionParametersCreateInfoEXT {
50125 self.inner
50126 }
50127}
50128#[repr(C)]
50129#[cfg_attr(feature = "debug", derive(Debug))]
50130#[derive(Copy, Clone)]
50131#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265PictureInfoEXT.html>"]
50132pub struct VideoDecodeH265PictureInfoEXT {
50133 pub s_type: StructureType,
50134 pub p_next: *const c_void,
50135 pub p_std_picture_info: *mut StdVideoDecodeH265PictureInfo,
50136 pub slices_count: u32,
50137 pub p_slices_data_offsets: *const u32,
50138}
50139impl ::std::default::Default for VideoDecodeH265PictureInfoEXT {
50140 fn default() -> Self {
50141 Self {
50142 s_type: StructureType::VIDEO_DECODE_H265_PICTURE_INFO_EXT,
50143 p_next: ::std::ptr::null(),
50144 p_std_picture_info: ::std::ptr::null_mut(),
50145 slices_count: u32::default(),
50146 p_slices_data_offsets: ::std::ptr::null(),
50147 }
50148 }
50149}
50150impl VideoDecodeH265PictureInfoEXT {
50151 pub fn builder<'a>() -> VideoDecodeH265PictureInfoEXTBuilder<'a> {
50152 VideoDecodeH265PictureInfoEXTBuilder {
50153 inner: Self::default(),
50154 marker: ::std::marker::PhantomData,
50155 }
50156 }
50157}
50158#[repr(transparent)]
50159pub struct VideoDecodeH265PictureInfoEXTBuilder<'a> {
50160 inner: VideoDecodeH265PictureInfoEXT,
50161 marker: ::std::marker::PhantomData<&'a ()>,
50162}
50163unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH265PictureInfoEXTBuilder<'_> {}
50164unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH265PictureInfoEXT {}
50165impl<'a> ::std::ops::Deref for VideoDecodeH265PictureInfoEXTBuilder<'a> {
50166 type Target = VideoDecodeH265PictureInfoEXT;
50167 fn deref(&self) -> &Self::Target {
50168 &self.inner
50169 }
50170}
50171impl<'a> ::std::ops::DerefMut for VideoDecodeH265PictureInfoEXTBuilder<'a> {
50172 fn deref_mut(&mut self) -> &mut Self::Target {
50173 &mut self.inner
50174 }
50175}
50176impl<'a> VideoDecodeH265PictureInfoEXTBuilder<'a> {
50177 pub fn std_picture_info(
50178 mut self,
50179 std_picture_info: &'a mut StdVideoDecodeH265PictureInfo,
50180 ) -> Self {
50181 self.inner.p_std_picture_info = std_picture_info;
50182 self
50183 }
50184 pub fn slices_data_offsets(mut self, slices_data_offsets: &'a [u32]) -> Self {
50185 self.inner.slices_count = slices_data_offsets.len() as _;
50186 self.inner.p_slices_data_offsets = slices_data_offsets.as_ptr();
50187 self
50188 }
50189 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50190 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50191 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
50192 pub fn build(self) -> VideoDecodeH265PictureInfoEXT {
50193 self.inner
50194 }
50195}
50196#[repr(C)]
50197#[cfg_attr(feature = "debug", derive(Debug))]
50198#[derive(Copy, Clone)]
50199#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265DpbSlotInfoEXT.html>"]
50200pub struct VideoDecodeH265DpbSlotInfoEXT {
50201 pub s_type: StructureType,
50202 pub p_next: *const c_void,
50203 pub p_std_reference_info: *const StdVideoDecodeH265ReferenceInfo,
50204}
50205impl ::std::default::Default for VideoDecodeH265DpbSlotInfoEXT {
50206 fn default() -> Self {
50207 Self {
50208 s_type: StructureType::VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT,
50209 p_next: ::std::ptr::null(),
50210 p_std_reference_info: ::std::ptr::null(),
50211 }
50212 }
50213}
50214impl VideoDecodeH265DpbSlotInfoEXT {
50215 pub fn builder<'a>() -> VideoDecodeH265DpbSlotInfoEXTBuilder<'a> {
50216 VideoDecodeH265DpbSlotInfoEXTBuilder {
50217 inner: Self::default(),
50218 marker: ::std::marker::PhantomData,
50219 }
50220 }
50221}
50222#[repr(transparent)]
50223pub struct VideoDecodeH265DpbSlotInfoEXTBuilder<'a> {
50224 inner: VideoDecodeH265DpbSlotInfoEXT,
50225 marker: ::std::marker::PhantomData<&'a ()>,
50226}
50227unsafe impl ExtendsVideoReferenceSlotKHR for VideoDecodeH265DpbSlotInfoEXTBuilder<'_> {}
50228unsafe impl ExtendsVideoReferenceSlotKHR for VideoDecodeH265DpbSlotInfoEXT {}
50229impl<'a> ::std::ops::Deref for VideoDecodeH265DpbSlotInfoEXTBuilder<'a> {
50230 type Target = VideoDecodeH265DpbSlotInfoEXT;
50231 fn deref(&self) -> &Self::Target {
50232 &self.inner
50233 }
50234}
50235impl<'a> ::std::ops::DerefMut for VideoDecodeH265DpbSlotInfoEXTBuilder<'a> {
50236 fn deref_mut(&mut self) -> &mut Self::Target {
50237 &mut self.inner
50238 }
50239}
50240impl<'a> VideoDecodeH265DpbSlotInfoEXTBuilder<'a> {
50241 pub fn std_reference_info(
50242 mut self,
50243 std_reference_info: &'a StdVideoDecodeH265ReferenceInfo,
50244 ) -> Self {
50245 self.inner.p_std_reference_info = std_reference_info;
50246 self
50247 }
50248 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50249 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50250 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
50251 pub fn build(self) -> VideoDecodeH265DpbSlotInfoEXT {
50252 self.inner
50253 }
50254}
50255#[repr(C)]
50256#[cfg_attr(feature = "debug", derive(Debug))]
50257#[derive(Copy, Clone)]
50258#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionCreateInfoKHR.html>"]
50259pub struct VideoSessionCreateInfoKHR {
50260 pub s_type: StructureType,
50261 pub p_next: *const c_void,
50262 pub queue_family_index: u32,
50263 pub flags: VideoSessionCreateFlagsKHR,
50264 pub p_video_profile: *const VideoProfileKHR,
50265 pub picture_format: Format,
50266 pub max_coded_extent: Extent2D,
50267 pub reference_pictures_format: Format,
50268 pub max_reference_pictures_slots_count: u32,
50269 pub max_reference_pictures_active_count: u32,
50270 pub p_std_header_version: *const ExtensionProperties,
50271}
50272impl ::std::default::Default for VideoSessionCreateInfoKHR {
50273 fn default() -> Self {
50274 Self {
50275 s_type: StructureType::VIDEO_SESSION_CREATE_INFO_KHR,
50276 p_next: ::std::ptr::null(),
50277 queue_family_index: u32::default(),
50278 flags: VideoSessionCreateFlagsKHR::default(),
50279 p_video_profile: ::std::ptr::null(),
50280 picture_format: Format::default(),
50281 max_coded_extent: Extent2D::default(),
50282 reference_pictures_format: Format::default(),
50283 max_reference_pictures_slots_count: u32::default(),
50284 max_reference_pictures_active_count: u32::default(),
50285 p_std_header_version: ::std::ptr::null(),
50286 }
50287 }
50288}
50289impl VideoSessionCreateInfoKHR {
50290 pub fn builder<'a>() -> VideoSessionCreateInfoKHRBuilder<'a> {
50291 VideoSessionCreateInfoKHRBuilder {
50292 inner: Self::default(),
50293 marker: ::std::marker::PhantomData,
50294 }
50295 }
50296}
50297#[repr(transparent)]
50298pub struct VideoSessionCreateInfoKHRBuilder<'a> {
50299 inner: VideoSessionCreateInfoKHR,
50300 marker: ::std::marker::PhantomData<&'a ()>,
50301}
50302impl<'a> ::std::ops::Deref for VideoSessionCreateInfoKHRBuilder<'a> {
50303 type Target = VideoSessionCreateInfoKHR;
50304 fn deref(&self) -> &Self::Target {
50305 &self.inner
50306 }
50307}
50308impl<'a> ::std::ops::DerefMut for VideoSessionCreateInfoKHRBuilder<'a> {
50309 fn deref_mut(&mut self) -> &mut Self::Target {
50310 &mut self.inner
50311 }
50312}
50313impl<'a> VideoSessionCreateInfoKHRBuilder<'a> {
50314 pub fn queue_family_index(mut self, queue_family_index: u32) -> Self {
50315 self.inner.queue_family_index = queue_family_index;
50316 self
50317 }
50318 pub fn flags(mut self, flags: VideoSessionCreateFlagsKHR) -> Self {
50319 self.inner.flags = flags;
50320 self
50321 }
50322 pub fn video_profile(mut self, video_profile: &'a VideoProfileKHR) -> Self {
50323 self.inner.p_video_profile = video_profile;
50324 self
50325 }
50326 pub fn picture_format(mut self, picture_format: Format) -> Self {
50327 self.inner.picture_format = picture_format;
50328 self
50329 }
50330 pub fn max_coded_extent(mut self, max_coded_extent: Extent2D) -> Self {
50331 self.inner.max_coded_extent = max_coded_extent;
50332 self
50333 }
50334 pub fn reference_pictures_format(mut self, reference_pictures_format: Format) -> Self {
50335 self.inner.reference_pictures_format = reference_pictures_format;
50336 self
50337 }
50338 pub fn max_reference_pictures_slots_count(
50339 mut self,
50340 max_reference_pictures_slots_count: u32,
50341 ) -> Self {
50342 self.inner.max_reference_pictures_slots_count = max_reference_pictures_slots_count;
50343 self
50344 }
50345 pub fn max_reference_pictures_active_count(
50346 mut self,
50347 max_reference_pictures_active_count: u32,
50348 ) -> Self {
50349 self.inner.max_reference_pictures_active_count = max_reference_pictures_active_count;
50350 self
50351 }
50352 pub fn std_header_version(mut self, std_header_version: &'a ExtensionProperties) -> Self {
50353 self.inner.p_std_header_version = std_header_version;
50354 self
50355 }
50356 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50357 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50358 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
50359 pub fn build(self) -> VideoSessionCreateInfoKHR {
50360 self.inner
50361 }
50362}
50363#[repr(C)]
50364#[cfg_attr(feature = "debug", derive(Debug))]
50365#[derive(Copy, Clone)]
50366#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionParametersCreateInfoKHR.html>"]
50367pub struct VideoSessionParametersCreateInfoKHR {
50368 pub s_type: StructureType,
50369 pub p_next: *const c_void,
50370 pub video_session_parameters_template: VideoSessionParametersKHR,
50371 pub video_session: VideoSessionKHR,
50372}
50373impl ::std::default::Default for VideoSessionParametersCreateInfoKHR {
50374 fn default() -> Self {
50375 Self {
50376 s_type: StructureType::VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR,
50377 p_next: ::std::ptr::null(),
50378 video_session_parameters_template: VideoSessionParametersKHR::default(),
50379 video_session: VideoSessionKHR::default(),
50380 }
50381 }
50382}
50383impl VideoSessionParametersCreateInfoKHR {
50384 pub fn builder<'a>() -> VideoSessionParametersCreateInfoKHRBuilder<'a> {
50385 VideoSessionParametersCreateInfoKHRBuilder {
50386 inner: Self::default(),
50387 marker: ::std::marker::PhantomData,
50388 }
50389 }
50390}
50391#[repr(transparent)]
50392pub struct VideoSessionParametersCreateInfoKHRBuilder<'a> {
50393 inner: VideoSessionParametersCreateInfoKHR,
50394 marker: ::std::marker::PhantomData<&'a ()>,
50395}
50396pub unsafe trait ExtendsVideoSessionParametersCreateInfoKHR {}
50397impl<'a> ::std::ops::Deref for VideoSessionParametersCreateInfoKHRBuilder<'a> {
50398 type Target = VideoSessionParametersCreateInfoKHR;
50399 fn deref(&self) -> &Self::Target {
50400 &self.inner
50401 }
50402}
50403impl<'a> ::std::ops::DerefMut for VideoSessionParametersCreateInfoKHRBuilder<'a> {
50404 fn deref_mut(&mut self) -> &mut Self::Target {
50405 &mut self.inner
50406 }
50407}
50408impl<'a> VideoSessionParametersCreateInfoKHRBuilder<'a> {
50409 pub fn video_session_parameters_template(
50410 mut self,
50411 video_session_parameters_template: VideoSessionParametersKHR,
50412 ) -> Self {
50413 self.inner.video_session_parameters_template = video_session_parameters_template;
50414 self
50415 }
50416 pub fn video_session(mut self, video_session: VideoSessionKHR) -> Self {
50417 self.inner.video_session = video_session;
50418 self
50419 }
50420 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
50421 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
50422 #[doc = r" valid extension structs can be pushed into the chain."]
50423 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
50424 #[doc = r" chain will look like `A -> D -> B -> C`."]
50425 pub fn push_next<T: ExtendsVideoSessionParametersCreateInfoKHR>(
50426 mut self,
50427 next: &'a mut T,
50428 ) -> Self {
50429 unsafe {
50430 let next_ptr = <*const T>::cast(next);
50431 let last_next = ptr_chain_iter(next).last().unwrap();
50432 (*last_next).p_next = self.inner.p_next as _;
50433 self.inner.p_next = next_ptr;
50434 }
50435 self
50436 }
50437 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50438 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50439 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
50440 pub fn build(self) -> VideoSessionParametersCreateInfoKHR {
50441 self.inner
50442 }
50443}
50444#[repr(C)]
50445#[cfg_attr(feature = "debug", derive(Debug))]
50446#[derive(Copy, Clone)]
50447#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionParametersUpdateInfoKHR.html>"]
50448pub struct VideoSessionParametersUpdateInfoKHR {
50449 pub s_type: StructureType,
50450 pub p_next: *const c_void,
50451 pub update_sequence_count: u32,
50452}
50453impl ::std::default::Default for VideoSessionParametersUpdateInfoKHR {
50454 fn default() -> Self {
50455 Self {
50456 s_type: StructureType::VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR,
50457 p_next: ::std::ptr::null(),
50458 update_sequence_count: u32::default(),
50459 }
50460 }
50461}
50462impl VideoSessionParametersUpdateInfoKHR {
50463 pub fn builder<'a>() -> VideoSessionParametersUpdateInfoKHRBuilder<'a> {
50464 VideoSessionParametersUpdateInfoKHRBuilder {
50465 inner: Self::default(),
50466 marker: ::std::marker::PhantomData,
50467 }
50468 }
50469}
50470#[repr(transparent)]
50471pub struct VideoSessionParametersUpdateInfoKHRBuilder<'a> {
50472 inner: VideoSessionParametersUpdateInfoKHR,
50473 marker: ::std::marker::PhantomData<&'a ()>,
50474}
50475pub unsafe trait ExtendsVideoSessionParametersUpdateInfoKHR {}
50476impl<'a> ::std::ops::Deref for VideoSessionParametersUpdateInfoKHRBuilder<'a> {
50477 type Target = VideoSessionParametersUpdateInfoKHR;
50478 fn deref(&self) -> &Self::Target {
50479 &self.inner
50480 }
50481}
50482impl<'a> ::std::ops::DerefMut for VideoSessionParametersUpdateInfoKHRBuilder<'a> {
50483 fn deref_mut(&mut self) -> &mut Self::Target {
50484 &mut self.inner
50485 }
50486}
50487impl<'a> VideoSessionParametersUpdateInfoKHRBuilder<'a> {
50488 pub fn update_sequence_count(mut self, update_sequence_count: u32) -> Self {
50489 self.inner.update_sequence_count = update_sequence_count;
50490 self
50491 }
50492 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
50493 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
50494 #[doc = r" valid extension structs can be pushed into the chain."]
50495 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
50496 #[doc = r" chain will look like `A -> D -> B -> C`."]
50497 pub fn push_next<T: ExtendsVideoSessionParametersUpdateInfoKHR>(
50498 mut self,
50499 next: &'a mut T,
50500 ) -> Self {
50501 unsafe {
50502 let next_ptr = <*const T>::cast(next);
50503 let last_next = ptr_chain_iter(next).last().unwrap();
50504 (*last_next).p_next = self.inner.p_next as _;
50505 self.inner.p_next = next_ptr;
50506 }
50507 self
50508 }
50509 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50510 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50511 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
50512 pub fn build(self) -> VideoSessionParametersUpdateInfoKHR {
50513 self.inner
50514 }
50515}
50516#[repr(C)]
50517#[cfg_attr(feature = "debug", derive(Debug))]
50518#[derive(Copy, Clone)]
50519#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoBeginCodingInfoKHR.html>"]
50520pub struct VideoBeginCodingInfoKHR {
50521 pub s_type: StructureType,
50522 pub p_next: *const c_void,
50523 pub flags: VideoBeginCodingFlagsKHR,
50524 pub codec_quality_preset: VideoCodingQualityPresetFlagsKHR,
50525 pub video_session: VideoSessionKHR,
50526 pub video_session_parameters: VideoSessionParametersKHR,
50527 pub reference_slot_count: u32,
50528 pub p_reference_slots: *const VideoReferenceSlotKHR,
50529}
50530impl ::std::default::Default for VideoBeginCodingInfoKHR {
50531 fn default() -> Self {
50532 Self {
50533 s_type: StructureType::VIDEO_BEGIN_CODING_INFO_KHR,
50534 p_next: ::std::ptr::null(),
50535 flags: VideoBeginCodingFlagsKHR::default(),
50536 codec_quality_preset: VideoCodingQualityPresetFlagsKHR::default(),
50537 video_session: VideoSessionKHR::default(),
50538 video_session_parameters: VideoSessionParametersKHR::default(),
50539 reference_slot_count: u32::default(),
50540 p_reference_slots: ::std::ptr::null(),
50541 }
50542 }
50543}
50544impl VideoBeginCodingInfoKHR {
50545 pub fn builder<'a>() -> VideoBeginCodingInfoKHRBuilder<'a> {
50546 VideoBeginCodingInfoKHRBuilder {
50547 inner: Self::default(),
50548 marker: ::std::marker::PhantomData,
50549 }
50550 }
50551}
50552#[repr(transparent)]
50553pub struct VideoBeginCodingInfoKHRBuilder<'a> {
50554 inner: VideoBeginCodingInfoKHR,
50555 marker: ::std::marker::PhantomData<&'a ()>,
50556}
50557impl<'a> ::std::ops::Deref for VideoBeginCodingInfoKHRBuilder<'a> {
50558 type Target = VideoBeginCodingInfoKHR;
50559 fn deref(&self) -> &Self::Target {
50560 &self.inner
50561 }
50562}
50563impl<'a> ::std::ops::DerefMut for VideoBeginCodingInfoKHRBuilder<'a> {
50564 fn deref_mut(&mut self) -> &mut Self::Target {
50565 &mut self.inner
50566 }
50567}
50568impl<'a> VideoBeginCodingInfoKHRBuilder<'a> {
50569 pub fn flags(mut self, flags: VideoBeginCodingFlagsKHR) -> Self {
50570 self.inner.flags = flags;
50571 self
50572 }
50573 pub fn codec_quality_preset(
50574 mut self,
50575 codec_quality_preset: VideoCodingQualityPresetFlagsKHR,
50576 ) -> Self {
50577 self.inner.codec_quality_preset = codec_quality_preset;
50578 self
50579 }
50580 pub fn video_session(mut self, video_session: VideoSessionKHR) -> Self {
50581 self.inner.video_session = video_session;
50582 self
50583 }
50584 pub fn video_session_parameters(
50585 mut self,
50586 video_session_parameters: VideoSessionParametersKHR,
50587 ) -> Self {
50588 self.inner.video_session_parameters = video_session_parameters;
50589 self
50590 }
50591 pub fn reference_slots(mut self, reference_slots: &'a [VideoReferenceSlotKHR]) -> Self {
50592 self.inner.reference_slot_count = reference_slots.len() as _;
50593 self.inner.p_reference_slots = reference_slots.as_ptr();
50594 self
50595 }
50596 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50597 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50598 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
50599 pub fn build(self) -> VideoBeginCodingInfoKHR {
50600 self.inner
50601 }
50602}
50603#[repr(C)]
50604#[cfg_attr(feature = "debug", derive(Debug))]
50605#[derive(Copy, Clone)]
50606#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEndCodingInfoKHR.html>"]
50607pub struct VideoEndCodingInfoKHR {
50608 pub s_type: StructureType,
50609 pub p_next: *const c_void,
50610 pub flags: VideoEndCodingFlagsKHR,
50611}
50612impl ::std::default::Default for VideoEndCodingInfoKHR {
50613 fn default() -> Self {
50614 Self {
50615 s_type: StructureType::VIDEO_END_CODING_INFO_KHR,
50616 p_next: ::std::ptr::null(),
50617 flags: VideoEndCodingFlagsKHR::default(),
50618 }
50619 }
50620}
50621impl VideoEndCodingInfoKHR {
50622 pub fn builder<'a>() -> VideoEndCodingInfoKHRBuilder<'a> {
50623 VideoEndCodingInfoKHRBuilder {
50624 inner: Self::default(),
50625 marker: ::std::marker::PhantomData,
50626 }
50627 }
50628}
50629#[repr(transparent)]
50630pub struct VideoEndCodingInfoKHRBuilder<'a> {
50631 inner: VideoEndCodingInfoKHR,
50632 marker: ::std::marker::PhantomData<&'a ()>,
50633}
50634impl<'a> ::std::ops::Deref for VideoEndCodingInfoKHRBuilder<'a> {
50635 type Target = VideoEndCodingInfoKHR;
50636 fn deref(&self) -> &Self::Target {
50637 &self.inner
50638 }
50639}
50640impl<'a> ::std::ops::DerefMut for VideoEndCodingInfoKHRBuilder<'a> {
50641 fn deref_mut(&mut self) -> &mut Self::Target {
50642 &mut self.inner
50643 }
50644}
50645impl<'a> VideoEndCodingInfoKHRBuilder<'a> {
50646 pub fn flags(mut self, flags: VideoEndCodingFlagsKHR) -> Self {
50647 self.inner.flags = flags;
50648 self
50649 }
50650 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50651 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50652 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
50653 pub fn build(self) -> VideoEndCodingInfoKHR {
50654 self.inner
50655 }
50656}
50657#[repr(C)]
50658#[cfg_attr(feature = "debug", derive(Debug))]
50659#[derive(Copy, Clone)]
50660#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCodingControlInfoKHR.html>"]
50661pub struct VideoCodingControlInfoKHR {
50662 pub s_type: StructureType,
50663 pub p_next: *const c_void,
50664 pub flags: VideoCodingControlFlagsKHR,
50665}
50666impl ::std::default::Default for VideoCodingControlInfoKHR {
50667 fn default() -> Self {
50668 Self {
50669 s_type: StructureType::VIDEO_CODING_CONTROL_INFO_KHR,
50670 p_next: ::std::ptr::null(),
50671 flags: VideoCodingControlFlagsKHR::default(),
50672 }
50673 }
50674}
50675impl VideoCodingControlInfoKHR {
50676 pub fn builder<'a>() -> VideoCodingControlInfoKHRBuilder<'a> {
50677 VideoCodingControlInfoKHRBuilder {
50678 inner: Self::default(),
50679 marker: ::std::marker::PhantomData,
50680 }
50681 }
50682}
50683#[repr(transparent)]
50684pub struct VideoCodingControlInfoKHRBuilder<'a> {
50685 inner: VideoCodingControlInfoKHR,
50686 marker: ::std::marker::PhantomData<&'a ()>,
50687}
50688pub unsafe trait ExtendsVideoCodingControlInfoKHR {}
50689impl<'a> ::std::ops::Deref for VideoCodingControlInfoKHRBuilder<'a> {
50690 type Target = VideoCodingControlInfoKHR;
50691 fn deref(&self) -> &Self::Target {
50692 &self.inner
50693 }
50694}
50695impl<'a> ::std::ops::DerefMut for VideoCodingControlInfoKHRBuilder<'a> {
50696 fn deref_mut(&mut self) -> &mut Self::Target {
50697 &mut self.inner
50698 }
50699}
50700impl<'a> VideoCodingControlInfoKHRBuilder<'a> {
50701 pub fn flags(mut self, flags: VideoCodingControlFlagsKHR) -> Self {
50702 self.inner.flags = flags;
50703 self
50704 }
50705 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
50706 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
50707 #[doc = r" valid extension structs can be pushed into the chain."]
50708 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
50709 #[doc = r" chain will look like `A -> D -> B -> C`."]
50710 pub fn push_next<T: ExtendsVideoCodingControlInfoKHR>(mut self, next: &'a mut T) -> Self {
50711 unsafe {
50712 let next_ptr = <*const T>::cast(next);
50713 let last_next = ptr_chain_iter(next).last().unwrap();
50714 (*last_next).p_next = self.inner.p_next as _;
50715 self.inner.p_next = next_ptr;
50716 }
50717 self
50718 }
50719 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50720 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50721 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
50722 pub fn build(self) -> VideoCodingControlInfoKHR {
50723 self.inner
50724 }
50725}
50726#[repr(C)]
50727#[cfg_attr(feature = "debug", derive(Debug))]
50728#[derive(Copy, Clone)]
50729#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeInfoKHR.html>"]
50730pub struct VideoEncodeInfoKHR {
50731 pub s_type: StructureType,
50732 pub p_next: *const c_void,
50733 pub flags: VideoEncodeFlagsKHR,
50734 pub quality_level: u32,
50735 pub coded_extent: Extent2D,
50736 pub dst_bitstream_buffer: Buffer,
50737 pub dst_bitstream_buffer_offset: DeviceSize,
50738 pub dst_bitstream_buffer_max_range: DeviceSize,
50739 pub src_picture_resource: VideoPictureResourceKHR,
50740 pub p_setup_reference_slot: *const VideoReferenceSlotKHR,
50741 pub reference_slot_count: u32,
50742 pub p_reference_slots: *const VideoReferenceSlotKHR,
50743 pub preceding_externally_encoded_bytes: u32,
50744}
50745impl ::std::default::Default for VideoEncodeInfoKHR {
50746 fn default() -> Self {
50747 Self {
50748 s_type: StructureType::VIDEO_ENCODE_INFO_KHR,
50749 p_next: ::std::ptr::null(),
50750 flags: VideoEncodeFlagsKHR::default(),
50751 quality_level: u32::default(),
50752 coded_extent: Extent2D::default(),
50753 dst_bitstream_buffer: Buffer::default(),
50754 dst_bitstream_buffer_offset: DeviceSize::default(),
50755 dst_bitstream_buffer_max_range: DeviceSize::default(),
50756 src_picture_resource: VideoPictureResourceKHR::default(),
50757 p_setup_reference_slot: ::std::ptr::null(),
50758 reference_slot_count: u32::default(),
50759 p_reference_slots: ::std::ptr::null(),
50760 preceding_externally_encoded_bytes: u32::default(),
50761 }
50762 }
50763}
50764impl VideoEncodeInfoKHR {
50765 pub fn builder<'a>() -> VideoEncodeInfoKHRBuilder<'a> {
50766 VideoEncodeInfoKHRBuilder {
50767 inner: Self::default(),
50768 marker: ::std::marker::PhantomData,
50769 }
50770 }
50771}
50772#[repr(transparent)]
50773pub struct VideoEncodeInfoKHRBuilder<'a> {
50774 inner: VideoEncodeInfoKHR,
50775 marker: ::std::marker::PhantomData<&'a ()>,
50776}
50777pub unsafe trait ExtendsVideoEncodeInfoKHR {}
50778impl<'a> ::std::ops::Deref for VideoEncodeInfoKHRBuilder<'a> {
50779 type Target = VideoEncodeInfoKHR;
50780 fn deref(&self) -> &Self::Target {
50781 &self.inner
50782 }
50783}
50784impl<'a> ::std::ops::DerefMut for VideoEncodeInfoKHRBuilder<'a> {
50785 fn deref_mut(&mut self) -> &mut Self::Target {
50786 &mut self.inner
50787 }
50788}
50789impl<'a> VideoEncodeInfoKHRBuilder<'a> {
50790 pub fn flags(mut self, flags: VideoEncodeFlagsKHR) -> Self {
50791 self.inner.flags = flags;
50792 self
50793 }
50794 pub fn quality_level(mut self, quality_level: u32) -> Self {
50795 self.inner.quality_level = quality_level;
50796 self
50797 }
50798 pub fn coded_extent(mut self, coded_extent: Extent2D) -> Self {
50799 self.inner.coded_extent = coded_extent;
50800 self
50801 }
50802 pub fn dst_bitstream_buffer(mut self, dst_bitstream_buffer: Buffer) -> Self {
50803 self.inner.dst_bitstream_buffer = dst_bitstream_buffer;
50804 self
50805 }
50806 pub fn dst_bitstream_buffer_offset(mut self, dst_bitstream_buffer_offset: DeviceSize) -> Self {
50807 self.inner.dst_bitstream_buffer_offset = dst_bitstream_buffer_offset;
50808 self
50809 }
50810 pub fn dst_bitstream_buffer_max_range(
50811 mut self,
50812 dst_bitstream_buffer_max_range: DeviceSize,
50813 ) -> Self {
50814 self.inner.dst_bitstream_buffer_max_range = dst_bitstream_buffer_max_range;
50815 self
50816 }
50817 pub fn src_picture_resource(mut self, src_picture_resource: VideoPictureResourceKHR) -> Self {
50818 self.inner.src_picture_resource = src_picture_resource;
50819 self
50820 }
50821 pub fn setup_reference_slot(mut self, setup_reference_slot: &'a VideoReferenceSlotKHR) -> Self {
50822 self.inner.p_setup_reference_slot = setup_reference_slot;
50823 self
50824 }
50825 pub fn reference_slots(mut self, reference_slots: &'a [VideoReferenceSlotKHR]) -> Self {
50826 self.inner.reference_slot_count = reference_slots.len() as _;
50827 self.inner.p_reference_slots = reference_slots.as_ptr();
50828 self
50829 }
50830 pub fn preceding_externally_encoded_bytes(
50831 mut self,
50832 preceding_externally_encoded_bytes: u32,
50833 ) -> Self {
50834 self.inner.preceding_externally_encoded_bytes = preceding_externally_encoded_bytes;
50835 self
50836 }
50837 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
50838 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
50839 #[doc = r" valid extension structs can be pushed into the chain."]
50840 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
50841 #[doc = r" chain will look like `A -> D -> B -> C`."]
50842 pub fn push_next<T: ExtendsVideoEncodeInfoKHR>(mut self, next: &'a mut T) -> Self {
50843 unsafe {
50844 let next_ptr = <*const T>::cast(next);
50845 let last_next = ptr_chain_iter(next).last().unwrap();
50846 (*last_next).p_next = self.inner.p_next as _;
50847 self.inner.p_next = next_ptr;
50848 }
50849 self
50850 }
50851 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50852 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50853 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
50854 pub fn build(self) -> VideoEncodeInfoKHR {
50855 self.inner
50856 }
50857}
50858#[repr(C)]
50859#[cfg_attr(feature = "debug", derive(Debug))]
50860#[derive(Copy, Clone)]
50861#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeRateControlInfoKHR.html>"]
50862pub struct VideoEncodeRateControlInfoKHR {
50863 pub s_type: StructureType,
50864 pub p_next: *const c_void,
50865 pub flags: VideoEncodeRateControlFlagsKHR,
50866 pub rate_control_mode: VideoEncodeRateControlModeFlagsKHR,
50867 pub layer_count: u8,
50868 pub p_layer_configs: *const VideoEncodeRateControlLayerInfoKHR,
50869}
50870impl ::std::default::Default for VideoEncodeRateControlInfoKHR {
50871 fn default() -> Self {
50872 Self {
50873 s_type: StructureType::VIDEO_ENCODE_RATE_CONTROL_INFO_KHR,
50874 p_next: ::std::ptr::null(),
50875 flags: VideoEncodeRateControlFlagsKHR::default(),
50876 rate_control_mode: VideoEncodeRateControlModeFlagsKHR::default(),
50877 layer_count: u8::default(),
50878 p_layer_configs: ::std::ptr::null(),
50879 }
50880 }
50881}
50882impl VideoEncodeRateControlInfoKHR {
50883 pub fn builder<'a>() -> VideoEncodeRateControlInfoKHRBuilder<'a> {
50884 VideoEncodeRateControlInfoKHRBuilder {
50885 inner: Self::default(),
50886 marker: ::std::marker::PhantomData,
50887 }
50888 }
50889}
50890#[repr(transparent)]
50891pub struct VideoEncodeRateControlInfoKHRBuilder<'a> {
50892 inner: VideoEncodeRateControlInfoKHR,
50893 marker: ::std::marker::PhantomData<&'a ()>,
50894}
50895unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlInfoKHRBuilder<'_> {}
50896unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlInfoKHR {}
50897pub unsafe trait ExtendsVideoEncodeRateControlInfoKHR {}
50898impl<'a> ::std::ops::Deref for VideoEncodeRateControlInfoKHRBuilder<'a> {
50899 type Target = VideoEncodeRateControlInfoKHR;
50900 fn deref(&self) -> &Self::Target {
50901 &self.inner
50902 }
50903}
50904impl<'a> ::std::ops::DerefMut for VideoEncodeRateControlInfoKHRBuilder<'a> {
50905 fn deref_mut(&mut self) -> &mut Self::Target {
50906 &mut self.inner
50907 }
50908}
50909impl<'a> VideoEncodeRateControlInfoKHRBuilder<'a> {
50910 pub fn flags(mut self, flags: VideoEncodeRateControlFlagsKHR) -> Self {
50911 self.inner.flags = flags;
50912 self
50913 }
50914 pub fn rate_control_mode(
50915 mut self,
50916 rate_control_mode: VideoEncodeRateControlModeFlagsKHR,
50917 ) -> Self {
50918 self.inner.rate_control_mode = rate_control_mode;
50919 self
50920 }
50921 pub fn layer_configs(
50922 mut self,
50923 layer_configs: &'a [VideoEncodeRateControlLayerInfoKHR],
50924 ) -> Self {
50925 self.inner.layer_count = layer_configs.len() as _;
50926 self.inner.p_layer_configs = layer_configs.as_ptr();
50927 self
50928 }
50929 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
50930 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
50931 #[doc = r" valid extension structs can be pushed into the chain."]
50932 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
50933 #[doc = r" chain will look like `A -> D -> B -> C`."]
50934 pub fn push_next<T: ExtendsVideoEncodeRateControlInfoKHR>(mut self, next: &'a mut T) -> Self {
50935 unsafe {
50936 let next_ptr = <*const T>::cast(next);
50937 let last_next = ptr_chain_iter(next).last().unwrap();
50938 (*last_next).p_next = self.inner.p_next as _;
50939 self.inner.p_next = next_ptr;
50940 }
50941 self
50942 }
50943 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50944 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50945 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
50946 pub fn build(self) -> VideoEncodeRateControlInfoKHR {
50947 self.inner
50948 }
50949}
50950#[repr(C)]
50951#[cfg_attr(feature = "debug", derive(Debug))]
50952#[derive(Copy, Clone)]
50953#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeRateControlLayerInfoKHR.html>"]
50954pub struct VideoEncodeRateControlLayerInfoKHR {
50955 pub s_type: StructureType,
50956 pub p_next: *const c_void,
50957 pub average_bitrate: u32,
50958 pub max_bitrate: u32,
50959 pub frame_rate_numerator: u32,
50960 pub frame_rate_denominator: u32,
50961 pub virtual_buffer_size_in_ms: u32,
50962 pub initial_virtual_buffer_size_in_ms: u32,
50963}
50964impl ::std::default::Default for VideoEncodeRateControlLayerInfoKHR {
50965 fn default() -> Self {
50966 Self {
50967 s_type: StructureType::VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR,
50968 p_next: ::std::ptr::null(),
50969 average_bitrate: u32::default(),
50970 max_bitrate: u32::default(),
50971 frame_rate_numerator: u32::default(),
50972 frame_rate_denominator: u32::default(),
50973 virtual_buffer_size_in_ms: u32::default(),
50974 initial_virtual_buffer_size_in_ms: u32::default(),
50975 }
50976 }
50977}
50978impl VideoEncodeRateControlLayerInfoKHR {
50979 pub fn builder<'a>() -> VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
50980 VideoEncodeRateControlLayerInfoKHRBuilder {
50981 inner: Self::default(),
50982 marker: ::std::marker::PhantomData,
50983 }
50984 }
50985}
50986#[repr(transparent)]
50987pub struct VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
50988 inner: VideoEncodeRateControlLayerInfoKHR,
50989 marker: ::std::marker::PhantomData<&'a ()>,
50990}
50991unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlLayerInfoKHRBuilder<'_> {}
50992unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlLayerInfoKHR {}
50993pub unsafe trait ExtendsVideoEncodeRateControlLayerInfoKHR {}
50994impl<'a> ::std::ops::Deref for VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
50995 type Target = VideoEncodeRateControlLayerInfoKHR;
50996 fn deref(&self) -> &Self::Target {
50997 &self.inner
50998 }
50999}
51000impl<'a> ::std::ops::DerefMut for VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
51001 fn deref_mut(&mut self) -> &mut Self::Target {
51002 &mut self.inner
51003 }
51004}
51005impl<'a> VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
51006 pub fn average_bitrate(mut self, average_bitrate: u32) -> Self {
51007 self.inner.average_bitrate = average_bitrate;
51008 self
51009 }
51010 pub fn max_bitrate(mut self, max_bitrate: u32) -> Self {
51011 self.inner.max_bitrate = max_bitrate;
51012 self
51013 }
51014 pub fn frame_rate_numerator(mut self, frame_rate_numerator: u32) -> Self {
51015 self.inner.frame_rate_numerator = frame_rate_numerator;
51016 self
51017 }
51018 pub fn frame_rate_denominator(mut self, frame_rate_denominator: u32) -> Self {
51019 self.inner.frame_rate_denominator = frame_rate_denominator;
51020 self
51021 }
51022 pub fn virtual_buffer_size_in_ms(mut self, virtual_buffer_size_in_ms: u32) -> Self {
51023 self.inner.virtual_buffer_size_in_ms = virtual_buffer_size_in_ms;
51024 self
51025 }
51026 pub fn initial_virtual_buffer_size_in_ms(
51027 mut self,
51028 initial_virtual_buffer_size_in_ms: u32,
51029 ) -> Self {
51030 self.inner.initial_virtual_buffer_size_in_ms = initial_virtual_buffer_size_in_ms;
51031 self
51032 }
51033 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
51034 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
51035 #[doc = r" valid extension structs can be pushed into the chain."]
51036 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
51037 #[doc = r" chain will look like `A -> D -> B -> C`."]
51038 pub fn push_next<T: ExtendsVideoEncodeRateControlLayerInfoKHR>(
51039 mut self,
51040 next: &'a mut T,
51041 ) -> Self {
51042 unsafe {
51043 let next_ptr = <*const T>::cast(next);
51044 let last_next = ptr_chain_iter(next).last().unwrap();
51045 (*last_next).p_next = self.inner.p_next as _;
51046 self.inner.p_next = next_ptr;
51047 }
51048 self
51049 }
51050 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51051 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51052 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
51053 pub fn build(self) -> VideoEncodeRateControlLayerInfoKHR {
51054 self.inner
51055 }
51056}
51057#[repr(C)]
51058#[cfg_attr(feature = "debug", derive(Debug))]
51059#[derive(Copy, Clone)]
51060#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeCapabilitiesKHR.html>"]
51061pub struct VideoEncodeCapabilitiesKHR {
51062 pub s_type: StructureType,
51063 pub p_next: *const c_void,
51064 pub flags: VideoEncodeCapabilityFlagsKHR,
51065 pub rate_control_modes: VideoEncodeRateControlModeFlagsKHR,
51066 pub rate_control_layer_count: u8,
51067 pub quality_level_count: u8,
51068 pub input_image_data_fill_alignment: Extent2D,
51069}
51070impl ::std::default::Default for VideoEncodeCapabilitiesKHR {
51071 fn default() -> Self {
51072 Self {
51073 s_type: StructureType::VIDEO_ENCODE_CAPABILITIES_KHR,
51074 p_next: ::std::ptr::null(),
51075 flags: VideoEncodeCapabilityFlagsKHR::default(),
51076 rate_control_modes: VideoEncodeRateControlModeFlagsKHR::default(),
51077 rate_control_layer_count: u8::default(),
51078 quality_level_count: u8::default(),
51079 input_image_data_fill_alignment: Extent2D::default(),
51080 }
51081 }
51082}
51083impl VideoEncodeCapabilitiesKHR {
51084 pub fn builder<'a>() -> VideoEncodeCapabilitiesKHRBuilder<'a> {
51085 VideoEncodeCapabilitiesKHRBuilder {
51086 inner: Self::default(),
51087 marker: ::std::marker::PhantomData,
51088 }
51089 }
51090}
51091#[repr(transparent)]
51092pub struct VideoEncodeCapabilitiesKHRBuilder<'a> {
51093 inner: VideoEncodeCapabilitiesKHR,
51094 marker: ::std::marker::PhantomData<&'a ()>,
51095}
51096unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeCapabilitiesKHRBuilder<'_> {}
51097unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeCapabilitiesKHR {}
51098pub unsafe trait ExtendsVideoEncodeCapabilitiesKHR {}
51099impl<'a> ::std::ops::Deref for VideoEncodeCapabilitiesKHRBuilder<'a> {
51100 type Target = VideoEncodeCapabilitiesKHR;
51101 fn deref(&self) -> &Self::Target {
51102 &self.inner
51103 }
51104}
51105impl<'a> ::std::ops::DerefMut for VideoEncodeCapabilitiesKHRBuilder<'a> {
51106 fn deref_mut(&mut self) -> &mut Self::Target {
51107 &mut self.inner
51108 }
51109}
51110impl<'a> VideoEncodeCapabilitiesKHRBuilder<'a> {
51111 pub fn flags(mut self, flags: VideoEncodeCapabilityFlagsKHR) -> Self {
51112 self.inner.flags = flags;
51113 self
51114 }
51115 pub fn rate_control_modes(
51116 mut self,
51117 rate_control_modes: VideoEncodeRateControlModeFlagsKHR,
51118 ) -> Self {
51119 self.inner.rate_control_modes = rate_control_modes;
51120 self
51121 }
51122 pub fn rate_control_layer_count(mut self, rate_control_layer_count: u8) -> Self {
51123 self.inner.rate_control_layer_count = rate_control_layer_count;
51124 self
51125 }
51126 pub fn quality_level_count(mut self, quality_level_count: u8) -> Self {
51127 self.inner.quality_level_count = quality_level_count;
51128 self
51129 }
51130 pub fn input_image_data_fill_alignment(
51131 mut self,
51132 input_image_data_fill_alignment: Extent2D,
51133 ) -> Self {
51134 self.inner.input_image_data_fill_alignment = input_image_data_fill_alignment;
51135 self
51136 }
51137 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
51138 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
51139 #[doc = r" valid extension structs can be pushed into the chain."]
51140 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
51141 #[doc = r" chain will look like `A -> D -> B -> C`."]
51142 pub fn push_next<T: ExtendsVideoEncodeCapabilitiesKHR>(mut self, next: &'a mut T) -> Self {
51143 unsafe {
51144 let next_ptr = <*const T>::cast(next);
51145 let last_next = ptr_chain_iter(next).last().unwrap();
51146 (*last_next).p_next = self.inner.p_next as _;
51147 self.inner.p_next = next_ptr;
51148 }
51149 self
51150 }
51151 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51152 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51153 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
51154 pub fn build(self) -> VideoEncodeCapabilitiesKHR {
51155 self.inner
51156 }
51157}
51158#[repr(C)]
51159#[cfg_attr(feature = "debug", derive(Debug))]
51160#[derive(Copy, Clone)]
51161#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264CapabilitiesEXT.html>"]
51162pub struct VideoEncodeH264CapabilitiesEXT {
51163 pub s_type: StructureType,
51164 pub p_next: *const c_void,
51165 pub flags: VideoEncodeH264CapabilityFlagsEXT,
51166 pub input_mode_flags: VideoEncodeH264InputModeFlagsEXT,
51167 pub output_mode_flags: VideoEncodeH264OutputModeFlagsEXT,
51168 pub max_p_picture_l0_reference_count: u8,
51169 pub max_b_picture_l0_reference_count: u8,
51170 pub max_l1_reference_count: u8,
51171 pub motion_vectors_over_pic_boundaries_flag: Bool32,
51172 pub max_bytes_per_pic_denom: u32,
51173 pub max_bits_per_mb_denom: u32,
51174 pub log2_max_mv_length_horizontal: u32,
51175 pub log2_max_mv_length_vertical: u32,
51176}
51177impl ::std::default::Default for VideoEncodeH264CapabilitiesEXT {
51178 fn default() -> Self {
51179 Self {
51180 s_type: StructureType::VIDEO_ENCODE_H264_CAPABILITIES_EXT,
51181 p_next: ::std::ptr::null(),
51182 flags: VideoEncodeH264CapabilityFlagsEXT::default(),
51183 input_mode_flags: VideoEncodeH264InputModeFlagsEXT::default(),
51184 output_mode_flags: VideoEncodeH264OutputModeFlagsEXT::default(),
51185 max_p_picture_l0_reference_count: u8::default(),
51186 max_b_picture_l0_reference_count: u8::default(),
51187 max_l1_reference_count: u8::default(),
51188 motion_vectors_over_pic_boundaries_flag: Bool32::default(),
51189 max_bytes_per_pic_denom: u32::default(),
51190 max_bits_per_mb_denom: u32::default(),
51191 log2_max_mv_length_horizontal: u32::default(),
51192 log2_max_mv_length_vertical: u32::default(),
51193 }
51194 }
51195}
51196impl VideoEncodeH264CapabilitiesEXT {
51197 pub fn builder<'a>() -> VideoEncodeH264CapabilitiesEXTBuilder<'a> {
51198 VideoEncodeH264CapabilitiesEXTBuilder {
51199 inner: Self::default(),
51200 marker: ::std::marker::PhantomData,
51201 }
51202 }
51203}
51204#[repr(transparent)]
51205pub struct VideoEncodeH264CapabilitiesEXTBuilder<'a> {
51206 inner: VideoEncodeH264CapabilitiesEXT,
51207 marker: ::std::marker::PhantomData<&'a ()>,
51208}
51209unsafe impl ExtendsVideoEncodeCapabilitiesKHR for VideoEncodeH264CapabilitiesEXTBuilder<'_> {}
51210unsafe impl ExtendsVideoEncodeCapabilitiesKHR for VideoEncodeH264CapabilitiesEXT {}
51211impl<'a> ::std::ops::Deref for VideoEncodeH264CapabilitiesEXTBuilder<'a> {
51212 type Target = VideoEncodeH264CapabilitiesEXT;
51213 fn deref(&self) -> &Self::Target {
51214 &self.inner
51215 }
51216}
51217impl<'a> ::std::ops::DerefMut for VideoEncodeH264CapabilitiesEXTBuilder<'a> {
51218 fn deref_mut(&mut self) -> &mut Self::Target {
51219 &mut self.inner
51220 }
51221}
51222impl<'a> VideoEncodeH264CapabilitiesEXTBuilder<'a> {
51223 pub fn flags(mut self, flags: VideoEncodeH264CapabilityFlagsEXT) -> Self {
51224 self.inner.flags = flags;
51225 self
51226 }
51227 pub fn input_mode_flags(mut self, input_mode_flags: VideoEncodeH264InputModeFlagsEXT) -> Self {
51228 self.inner.input_mode_flags = input_mode_flags;
51229 self
51230 }
51231 pub fn output_mode_flags(
51232 mut self,
51233 output_mode_flags: VideoEncodeH264OutputModeFlagsEXT,
51234 ) -> Self {
51235 self.inner.output_mode_flags = output_mode_flags;
51236 self
51237 }
51238 pub fn max_p_picture_l0_reference_count(
51239 mut self,
51240 max_p_picture_l0_reference_count: u8,
51241 ) -> Self {
51242 self.inner.max_p_picture_l0_reference_count = max_p_picture_l0_reference_count;
51243 self
51244 }
51245 pub fn max_b_picture_l0_reference_count(
51246 mut self,
51247 max_b_picture_l0_reference_count: u8,
51248 ) -> Self {
51249 self.inner.max_b_picture_l0_reference_count = max_b_picture_l0_reference_count;
51250 self
51251 }
51252 pub fn max_l1_reference_count(mut self, max_l1_reference_count: u8) -> Self {
51253 self.inner.max_l1_reference_count = max_l1_reference_count;
51254 self
51255 }
51256 pub fn motion_vectors_over_pic_boundaries_flag(
51257 mut self,
51258 motion_vectors_over_pic_boundaries_flag: bool,
51259 ) -> Self {
51260 self.inner.motion_vectors_over_pic_boundaries_flag =
51261 motion_vectors_over_pic_boundaries_flag.into();
51262 self
51263 }
51264 pub fn max_bytes_per_pic_denom(mut self, max_bytes_per_pic_denom: u32) -> Self {
51265 self.inner.max_bytes_per_pic_denom = max_bytes_per_pic_denom;
51266 self
51267 }
51268 pub fn max_bits_per_mb_denom(mut self, max_bits_per_mb_denom: u32) -> Self {
51269 self.inner.max_bits_per_mb_denom = max_bits_per_mb_denom;
51270 self
51271 }
51272 pub fn log2_max_mv_length_horizontal(mut self, log2_max_mv_length_horizontal: u32) -> Self {
51273 self.inner.log2_max_mv_length_horizontal = log2_max_mv_length_horizontal;
51274 self
51275 }
51276 pub fn log2_max_mv_length_vertical(mut self, log2_max_mv_length_vertical: u32) -> Self {
51277 self.inner.log2_max_mv_length_vertical = log2_max_mv_length_vertical;
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."]
51283 pub fn build(self) -> VideoEncodeH264CapabilitiesEXT {
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/VkVideoEncodeH264SessionParametersAddInfoEXT.html>"]
51291pub struct VideoEncodeH264SessionParametersAddInfoEXT {
51292 pub s_type: StructureType,
51293 pub p_next: *const c_void,
51294 pub sps_std_count: u32,
51295 pub p_sps_std: *const StdVideoH264SequenceParameterSet,
51296 pub pps_std_count: u32,
51297 pub p_pps_std: *const StdVideoH264PictureParameterSet,
51298}
51299impl ::std::default::Default for VideoEncodeH264SessionParametersAddInfoEXT {
51300 fn default() -> Self {
51301 Self {
51302 s_type: StructureType::VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT,
51303 p_next: ::std::ptr::null(),
51304 sps_std_count: u32::default(),
51305 p_sps_std: ::std::ptr::null(),
51306 pps_std_count: u32::default(),
51307 p_pps_std: ::std::ptr::null(),
51308 }
51309 }
51310}
51311impl VideoEncodeH264SessionParametersAddInfoEXT {
51312 pub fn builder<'a>() -> VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> {
51313 VideoEncodeH264SessionParametersAddInfoEXTBuilder {
51314 inner: Self::default(),
51315 marker: ::std::marker::PhantomData,
51316 }
51317 }
51318}
51319#[repr(transparent)]
51320pub struct VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> {
51321 inner: VideoEncodeH264SessionParametersAddInfoEXT,
51322 marker: ::std::marker::PhantomData<&'a ()>,
51323}
51324unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
51325 for VideoEncodeH264SessionParametersAddInfoEXTBuilder<'_>
51326{
51327}
51328unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
51329 for VideoEncodeH264SessionParametersAddInfoEXT
51330{
51331}
51332impl<'a> ::std::ops::Deref for VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> {
51333 type Target = VideoEncodeH264SessionParametersAddInfoEXT;
51334 fn deref(&self) -> &Self::Target {
51335 &self.inner
51336 }
51337}
51338impl<'a> ::std::ops::DerefMut for VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> {
51339 fn deref_mut(&mut self) -> &mut Self::Target {
51340 &mut self.inner
51341 }
51342}
51343impl<'a> VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> {
51344 pub fn sps_std(mut self, sps_std: &'a [StdVideoH264SequenceParameterSet]) -> Self {
51345 self.inner.sps_std_count = sps_std.len() as _;
51346 self.inner.p_sps_std = sps_std.as_ptr();
51347 self
51348 }
51349 pub fn pps_std(mut self, pps_std: &'a [StdVideoH264PictureParameterSet]) -> Self {
51350 self.inner.pps_std_count = pps_std.len() as _;
51351 self.inner.p_pps_std = pps_std.as_ptr();
51352 self
51353 }
51354 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51355 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51356 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
51357 pub fn build(self) -> VideoEncodeH264SessionParametersAddInfoEXT {
51358 self.inner
51359 }
51360}
51361#[repr(C)]
51362#[cfg_attr(feature = "debug", derive(Debug))]
51363#[derive(Copy, Clone)]
51364#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264SessionParametersCreateInfoEXT.html>"]
51365pub struct VideoEncodeH264SessionParametersCreateInfoEXT {
51366 pub s_type: StructureType,
51367 pub p_next: *const c_void,
51368 pub max_sps_std_count: u32,
51369 pub max_pps_std_count: u32,
51370 pub p_parameters_add_info: *const VideoEncodeH264SessionParametersAddInfoEXT,
51371}
51372impl ::std::default::Default for VideoEncodeH264SessionParametersCreateInfoEXT {
51373 fn default() -> Self {
51374 Self {
51375 s_type: StructureType::VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT,
51376 p_next: ::std::ptr::null(),
51377 max_sps_std_count: u32::default(),
51378 max_pps_std_count: u32::default(),
51379 p_parameters_add_info: ::std::ptr::null(),
51380 }
51381 }
51382}
51383impl VideoEncodeH264SessionParametersCreateInfoEXT {
51384 pub fn builder<'a>() -> VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> {
51385 VideoEncodeH264SessionParametersCreateInfoEXTBuilder {
51386 inner: Self::default(),
51387 marker: ::std::marker::PhantomData,
51388 }
51389 }
51390}
51391#[repr(transparent)]
51392pub struct VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> {
51393 inner: VideoEncodeH264SessionParametersCreateInfoEXT,
51394 marker: ::std::marker::PhantomData<&'a ()>,
51395}
51396unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
51397 for VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'_>
51398{
51399}
51400unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
51401 for VideoEncodeH264SessionParametersCreateInfoEXT
51402{
51403}
51404impl<'a> ::std::ops::Deref for VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> {
51405 type Target = VideoEncodeH264SessionParametersCreateInfoEXT;
51406 fn deref(&self) -> &Self::Target {
51407 &self.inner
51408 }
51409}
51410impl<'a> ::std::ops::DerefMut for VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> {
51411 fn deref_mut(&mut self) -> &mut Self::Target {
51412 &mut self.inner
51413 }
51414}
51415impl<'a> VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> {
51416 pub fn max_sps_std_count(mut self, max_sps_std_count: u32) -> Self {
51417 self.inner.max_sps_std_count = max_sps_std_count;
51418 self
51419 }
51420 pub fn max_pps_std_count(mut self, max_pps_std_count: u32) -> Self {
51421 self.inner.max_pps_std_count = max_pps_std_count;
51422 self
51423 }
51424 pub fn parameters_add_info(
51425 mut self,
51426 parameters_add_info: &'a VideoEncodeH264SessionParametersAddInfoEXT,
51427 ) -> Self {
51428 self.inner.p_parameters_add_info = parameters_add_info;
51429 self
51430 }
51431 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51432 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51433 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
51434 pub fn build(self) -> VideoEncodeH264SessionParametersCreateInfoEXT {
51435 self.inner
51436 }
51437}
51438#[repr(C)]
51439#[cfg_attr(feature = "debug", derive(Debug))]
51440#[derive(Copy, Clone)]
51441#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264DpbSlotInfoEXT.html>"]
51442pub struct VideoEncodeH264DpbSlotInfoEXT {
51443 pub s_type: StructureType,
51444 pub p_next: *const c_void,
51445 pub slot_index: i8,
51446 pub p_std_reference_info: *const StdVideoEncodeH264ReferenceInfo,
51447}
51448impl ::std::default::Default for VideoEncodeH264DpbSlotInfoEXT {
51449 fn default() -> Self {
51450 Self {
51451 s_type: StructureType::VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT,
51452 p_next: ::std::ptr::null(),
51453 slot_index: i8::default(),
51454 p_std_reference_info: ::std::ptr::null(),
51455 }
51456 }
51457}
51458impl VideoEncodeH264DpbSlotInfoEXT {
51459 pub fn builder<'a>() -> VideoEncodeH264DpbSlotInfoEXTBuilder<'a> {
51460 VideoEncodeH264DpbSlotInfoEXTBuilder {
51461 inner: Self::default(),
51462 marker: ::std::marker::PhantomData,
51463 }
51464 }
51465}
51466#[repr(transparent)]
51467pub struct VideoEncodeH264DpbSlotInfoEXTBuilder<'a> {
51468 inner: VideoEncodeH264DpbSlotInfoEXT,
51469 marker: ::std::marker::PhantomData<&'a ()>,
51470}
51471impl<'a> ::std::ops::Deref for VideoEncodeH264DpbSlotInfoEXTBuilder<'a> {
51472 type Target = VideoEncodeH264DpbSlotInfoEXT;
51473 fn deref(&self) -> &Self::Target {
51474 &self.inner
51475 }
51476}
51477impl<'a> ::std::ops::DerefMut for VideoEncodeH264DpbSlotInfoEXTBuilder<'a> {
51478 fn deref_mut(&mut self) -> &mut Self::Target {
51479 &mut self.inner
51480 }
51481}
51482impl<'a> VideoEncodeH264DpbSlotInfoEXTBuilder<'a> {
51483 pub fn slot_index(mut self, slot_index: i8) -> Self {
51484 self.inner.slot_index = slot_index;
51485 self
51486 }
51487 pub fn std_reference_info(
51488 mut self,
51489 std_reference_info: &'a StdVideoEncodeH264ReferenceInfo,
51490 ) -> Self {
51491 self.inner.p_std_reference_info = std_reference_info;
51492 self
51493 }
51494 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51495 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51496 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
51497 pub fn build(self) -> VideoEncodeH264DpbSlotInfoEXT {
51498 self.inner
51499 }
51500}
51501#[repr(C)]
51502#[cfg_attr(feature = "debug", derive(Debug))]
51503#[derive(Copy, Clone)]
51504#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264VclFrameInfoEXT.html>"]
51505pub struct VideoEncodeH264VclFrameInfoEXT {
51506 pub s_type: StructureType,
51507 pub p_next: *const c_void,
51508 pub p_reference_final_lists: *const VideoEncodeH264ReferenceListsEXT,
51509 pub nalu_slice_entry_count: u32,
51510 pub p_nalu_slice_entries: *const VideoEncodeH264NaluSliceEXT,
51511 pub p_current_picture_info: *const StdVideoEncodeH264PictureInfo,
51512}
51513impl ::std::default::Default for VideoEncodeH264VclFrameInfoEXT {
51514 fn default() -> Self {
51515 Self {
51516 s_type: StructureType::VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT,
51517 p_next: ::std::ptr::null(),
51518 p_reference_final_lists: ::std::ptr::null(),
51519 nalu_slice_entry_count: u32::default(),
51520 p_nalu_slice_entries: ::std::ptr::null(),
51521 p_current_picture_info: ::std::ptr::null(),
51522 }
51523 }
51524}
51525impl VideoEncodeH264VclFrameInfoEXT {
51526 pub fn builder<'a>() -> VideoEncodeH264VclFrameInfoEXTBuilder<'a> {
51527 VideoEncodeH264VclFrameInfoEXTBuilder {
51528 inner: Self::default(),
51529 marker: ::std::marker::PhantomData,
51530 }
51531 }
51532}
51533#[repr(transparent)]
51534pub struct VideoEncodeH264VclFrameInfoEXTBuilder<'a> {
51535 inner: VideoEncodeH264VclFrameInfoEXT,
51536 marker: ::std::marker::PhantomData<&'a ()>,
51537}
51538unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264VclFrameInfoEXTBuilder<'_> {}
51539unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264VclFrameInfoEXT {}
51540impl<'a> ::std::ops::Deref for VideoEncodeH264VclFrameInfoEXTBuilder<'a> {
51541 type Target = VideoEncodeH264VclFrameInfoEXT;
51542 fn deref(&self) -> &Self::Target {
51543 &self.inner
51544 }
51545}
51546impl<'a> ::std::ops::DerefMut for VideoEncodeH264VclFrameInfoEXTBuilder<'a> {
51547 fn deref_mut(&mut self) -> &mut Self::Target {
51548 &mut self.inner
51549 }
51550}
51551impl<'a> VideoEncodeH264VclFrameInfoEXTBuilder<'a> {
51552 pub fn reference_final_lists(
51553 mut self,
51554 reference_final_lists: &'a VideoEncodeH264ReferenceListsEXT,
51555 ) -> Self {
51556 self.inner.p_reference_final_lists = reference_final_lists;
51557 self
51558 }
51559 pub fn nalu_slice_entries(
51560 mut self,
51561 nalu_slice_entries: &'a [VideoEncodeH264NaluSliceEXT],
51562 ) -> Self {
51563 self.inner.nalu_slice_entry_count = nalu_slice_entries.len() as _;
51564 self.inner.p_nalu_slice_entries = nalu_slice_entries.as_ptr();
51565 self
51566 }
51567 pub fn current_picture_info(
51568 mut self,
51569 current_picture_info: &'a StdVideoEncodeH264PictureInfo,
51570 ) -> Self {
51571 self.inner.p_current_picture_info = current_picture_info;
51572 self
51573 }
51574 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51575 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51576 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
51577 pub fn build(self) -> VideoEncodeH264VclFrameInfoEXT {
51578 self.inner
51579 }
51580}
51581#[repr(C)]
51582#[cfg_attr(feature = "debug", derive(Debug))]
51583#[derive(Copy, Clone)]
51584#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264ReferenceListsEXT.html>"]
51585pub struct VideoEncodeH264ReferenceListsEXT {
51586 pub s_type: StructureType,
51587 pub p_next: *const c_void,
51588 pub reference_list0_entry_count: u8,
51589 pub p_reference_list0_entries: *const VideoEncodeH264DpbSlotInfoEXT,
51590 pub reference_list1_entry_count: u8,
51591 pub p_reference_list1_entries: *const VideoEncodeH264DpbSlotInfoEXT,
51592 pub p_mem_mgmt_ctrl_operations: *const StdVideoEncodeH264RefMemMgmtCtrlOperations,
51593}
51594impl ::std::default::Default for VideoEncodeH264ReferenceListsEXT {
51595 fn default() -> Self {
51596 Self {
51597 s_type: StructureType::VIDEO_ENCODE_H264_REFERENCE_LISTS_EXT,
51598 p_next: ::std::ptr::null(),
51599 reference_list0_entry_count: u8::default(),
51600 p_reference_list0_entries: ::std::ptr::null(),
51601 reference_list1_entry_count: u8::default(),
51602 p_reference_list1_entries: ::std::ptr::null(),
51603 p_mem_mgmt_ctrl_operations: ::std::ptr::null(),
51604 }
51605 }
51606}
51607impl VideoEncodeH264ReferenceListsEXT {
51608 pub fn builder<'a>() -> VideoEncodeH264ReferenceListsEXTBuilder<'a> {
51609 VideoEncodeH264ReferenceListsEXTBuilder {
51610 inner: Self::default(),
51611 marker: ::std::marker::PhantomData,
51612 }
51613 }
51614}
51615#[repr(transparent)]
51616pub struct VideoEncodeH264ReferenceListsEXTBuilder<'a> {
51617 inner: VideoEncodeH264ReferenceListsEXT,
51618 marker: ::std::marker::PhantomData<&'a ()>,
51619}
51620impl<'a> ::std::ops::Deref for VideoEncodeH264ReferenceListsEXTBuilder<'a> {
51621 type Target = VideoEncodeH264ReferenceListsEXT;
51622 fn deref(&self) -> &Self::Target {
51623 &self.inner
51624 }
51625}
51626impl<'a> ::std::ops::DerefMut for VideoEncodeH264ReferenceListsEXTBuilder<'a> {
51627 fn deref_mut(&mut self) -> &mut Self::Target {
51628 &mut self.inner
51629 }
51630}
51631impl<'a> VideoEncodeH264ReferenceListsEXTBuilder<'a> {
51632 pub fn reference_list0_entries(
51633 mut self,
51634 reference_list0_entries: &'a [VideoEncodeH264DpbSlotInfoEXT],
51635 ) -> Self {
51636 self.inner.reference_list0_entry_count = reference_list0_entries.len() as _;
51637 self.inner.p_reference_list0_entries = reference_list0_entries.as_ptr();
51638 self
51639 }
51640 pub fn reference_list1_entries(
51641 mut self,
51642 reference_list1_entries: &'a [VideoEncodeH264DpbSlotInfoEXT],
51643 ) -> Self {
51644 self.inner.reference_list1_entry_count = reference_list1_entries.len() as _;
51645 self.inner.p_reference_list1_entries = reference_list1_entries.as_ptr();
51646 self
51647 }
51648 pub fn mem_mgmt_ctrl_operations(
51649 mut self,
51650 mem_mgmt_ctrl_operations: &'a StdVideoEncodeH264RefMemMgmtCtrlOperations,
51651 ) -> Self {
51652 self.inner.p_mem_mgmt_ctrl_operations = mem_mgmt_ctrl_operations;
51653 self
51654 }
51655 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51656 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51657 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
51658 pub fn build(self) -> VideoEncodeH264ReferenceListsEXT {
51659 self.inner
51660 }
51661}
51662#[repr(C)]
51663#[cfg_attr(feature = "debug", derive(Debug))]
51664#[derive(Copy, Clone)]
51665#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264EmitPictureParametersEXT.html>"]
51666pub struct VideoEncodeH264EmitPictureParametersEXT {
51667 pub s_type: StructureType,
51668 pub p_next: *const c_void,
51669 pub sps_id: u8,
51670 pub emit_sps_enable: Bool32,
51671 pub pps_id_entry_count: u32,
51672 pub pps_id_entries: *const u8,
51673}
51674impl ::std::default::Default for VideoEncodeH264EmitPictureParametersEXT {
51675 fn default() -> Self {
51676 Self {
51677 s_type: StructureType::VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT,
51678 p_next: ::std::ptr::null(),
51679 sps_id: u8::default(),
51680 emit_sps_enable: Bool32::default(),
51681 pps_id_entry_count: u32::default(),
51682 pps_id_entries: ::std::ptr::null(),
51683 }
51684 }
51685}
51686impl VideoEncodeH264EmitPictureParametersEXT {
51687 pub fn builder<'a>() -> VideoEncodeH264EmitPictureParametersEXTBuilder<'a> {
51688 VideoEncodeH264EmitPictureParametersEXTBuilder {
51689 inner: Self::default(),
51690 marker: ::std::marker::PhantomData,
51691 }
51692 }
51693}
51694#[repr(transparent)]
51695pub struct VideoEncodeH264EmitPictureParametersEXTBuilder<'a> {
51696 inner: VideoEncodeH264EmitPictureParametersEXT,
51697 marker: ::std::marker::PhantomData<&'a ()>,
51698}
51699unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264EmitPictureParametersEXTBuilder<'_> {}
51700unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264EmitPictureParametersEXT {}
51701impl<'a> ::std::ops::Deref for VideoEncodeH264EmitPictureParametersEXTBuilder<'a> {
51702 type Target = VideoEncodeH264EmitPictureParametersEXT;
51703 fn deref(&self) -> &Self::Target {
51704 &self.inner
51705 }
51706}
51707impl<'a> ::std::ops::DerefMut for VideoEncodeH264EmitPictureParametersEXTBuilder<'a> {
51708 fn deref_mut(&mut self) -> &mut Self::Target {
51709 &mut self.inner
51710 }
51711}
51712impl<'a> VideoEncodeH264EmitPictureParametersEXTBuilder<'a> {
51713 pub fn sps_id(mut self, sps_id: u8) -> Self {
51714 self.inner.sps_id = sps_id;
51715 self
51716 }
51717 pub fn emit_sps_enable(mut self, emit_sps_enable: bool) -> Self {
51718 self.inner.emit_sps_enable = emit_sps_enable.into();
51719 self
51720 }
51721 pub fn pps_id_entries(mut self, pps_id_entries: &'a [u8]) -> Self {
51722 self.inner.pps_id_entry_count = pps_id_entries.len() as _;
51723 self.inner.pps_id_entries = pps_id_entries.as_ptr();
51724 self
51725 }
51726 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51727 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51728 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
51729 pub fn build(self) -> VideoEncodeH264EmitPictureParametersEXT {
51730 self.inner
51731 }
51732}
51733#[repr(C)]
51734#[cfg_attr(feature = "debug", derive(Debug))]
51735#[derive(Copy, Clone)]
51736#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264ProfileEXT.html>"]
51737pub struct VideoEncodeH264ProfileEXT {
51738 pub s_type: StructureType,
51739 pub p_next: *const c_void,
51740 pub std_profile_idc: StdVideoH264ProfileIdc,
51741}
51742impl ::std::default::Default for VideoEncodeH264ProfileEXT {
51743 fn default() -> Self {
51744 Self {
51745 s_type: StructureType::VIDEO_ENCODE_H264_PROFILE_EXT,
51746 p_next: ::std::ptr::null(),
51747 std_profile_idc: StdVideoH264ProfileIdc::default(),
51748 }
51749 }
51750}
51751impl VideoEncodeH264ProfileEXT {
51752 pub fn builder<'a>() -> VideoEncodeH264ProfileEXTBuilder<'a> {
51753 VideoEncodeH264ProfileEXTBuilder {
51754 inner: Self::default(),
51755 marker: ::std::marker::PhantomData,
51756 }
51757 }
51758}
51759#[repr(transparent)]
51760pub struct VideoEncodeH264ProfileEXTBuilder<'a> {
51761 inner: VideoEncodeH264ProfileEXT,
51762 marker: ::std::marker::PhantomData<&'a ()>,
51763}
51764unsafe impl ExtendsVideoProfileKHR for VideoEncodeH264ProfileEXTBuilder<'_> {}
51765unsafe impl ExtendsVideoProfileKHR for VideoEncodeH264ProfileEXT {}
51766unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH264ProfileEXTBuilder<'_> {}
51767unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH264ProfileEXT {}
51768unsafe impl ExtendsFormatProperties2 for VideoEncodeH264ProfileEXTBuilder<'_> {}
51769unsafe impl ExtendsFormatProperties2 for VideoEncodeH264ProfileEXT {}
51770unsafe impl ExtendsImageCreateInfo for VideoEncodeH264ProfileEXTBuilder<'_> {}
51771unsafe impl ExtendsImageCreateInfo for VideoEncodeH264ProfileEXT {}
51772unsafe impl ExtendsImageViewCreateInfo for VideoEncodeH264ProfileEXTBuilder<'_> {}
51773unsafe impl ExtendsImageViewCreateInfo for VideoEncodeH264ProfileEXT {}
51774unsafe impl ExtendsBufferCreateInfo for VideoEncodeH264ProfileEXTBuilder<'_> {}
51775unsafe impl ExtendsBufferCreateInfo for VideoEncodeH264ProfileEXT {}
51776impl<'a> ::std::ops::Deref for VideoEncodeH264ProfileEXTBuilder<'a> {
51777 type Target = VideoEncodeH264ProfileEXT;
51778 fn deref(&self) -> &Self::Target {
51779 &self.inner
51780 }
51781}
51782impl<'a> ::std::ops::DerefMut for VideoEncodeH264ProfileEXTBuilder<'a> {
51783 fn deref_mut(&mut self) -> &mut Self::Target {
51784 &mut self.inner
51785 }
51786}
51787impl<'a> VideoEncodeH264ProfileEXTBuilder<'a> {
51788 pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH264ProfileIdc) -> Self {
51789 self.inner.std_profile_idc = std_profile_idc;
51790 self
51791 }
51792 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51793 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51794 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
51795 pub fn build(self) -> VideoEncodeH264ProfileEXT {
51796 self.inner
51797 }
51798}
51799#[repr(C)]
51800#[cfg_attr(feature = "debug", derive(Debug))]
51801#[derive(Copy, Clone)]
51802#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264NaluSliceEXT.html>"]
51803pub struct VideoEncodeH264NaluSliceEXT {
51804 pub s_type: StructureType,
51805 pub p_next: *const c_void,
51806 pub mb_count: u32,
51807 pub p_reference_final_lists: *const VideoEncodeH264ReferenceListsEXT,
51808 pub p_slice_header_std: *const StdVideoEncodeH264SliceHeader,
51809}
51810impl ::std::default::Default for VideoEncodeH264NaluSliceEXT {
51811 fn default() -> Self {
51812 Self {
51813 s_type: StructureType::VIDEO_ENCODE_H264_NALU_SLICE_EXT,
51814 p_next: ::std::ptr::null(),
51815 mb_count: u32::default(),
51816 p_reference_final_lists: ::std::ptr::null(),
51817 p_slice_header_std: ::std::ptr::null(),
51818 }
51819 }
51820}
51821impl VideoEncodeH264NaluSliceEXT {
51822 pub fn builder<'a>() -> VideoEncodeH264NaluSliceEXTBuilder<'a> {
51823 VideoEncodeH264NaluSliceEXTBuilder {
51824 inner: Self::default(),
51825 marker: ::std::marker::PhantomData,
51826 }
51827 }
51828}
51829#[repr(transparent)]
51830pub struct VideoEncodeH264NaluSliceEXTBuilder<'a> {
51831 inner: VideoEncodeH264NaluSliceEXT,
51832 marker: ::std::marker::PhantomData<&'a ()>,
51833}
51834impl<'a> ::std::ops::Deref for VideoEncodeH264NaluSliceEXTBuilder<'a> {
51835 type Target = VideoEncodeH264NaluSliceEXT;
51836 fn deref(&self) -> &Self::Target {
51837 &self.inner
51838 }
51839}
51840impl<'a> ::std::ops::DerefMut for VideoEncodeH264NaluSliceEXTBuilder<'a> {
51841 fn deref_mut(&mut self) -> &mut Self::Target {
51842 &mut self.inner
51843 }
51844}
51845impl<'a> VideoEncodeH264NaluSliceEXTBuilder<'a> {
51846 pub fn mb_count(mut self, mb_count: u32) -> Self {
51847 self.inner.mb_count = mb_count;
51848 self
51849 }
51850 pub fn reference_final_lists(
51851 mut self,
51852 reference_final_lists: &'a VideoEncodeH264ReferenceListsEXT,
51853 ) -> Self {
51854 self.inner.p_reference_final_lists = reference_final_lists;
51855 self
51856 }
51857 pub fn slice_header_std(mut self, slice_header_std: &'a StdVideoEncodeH264SliceHeader) -> Self {
51858 self.inner.p_slice_header_std = slice_header_std;
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."]
51864 pub fn build(self) -> VideoEncodeH264NaluSliceEXT {
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/VkVideoEncodeH264RateControlInfoEXT.html>"]
51872pub struct VideoEncodeH264RateControlInfoEXT {
51873 pub s_type: StructureType,
51874 pub p_next: *const c_void,
51875 pub gop_frame_count: u32,
51876 pub idr_period: u32,
51877 pub consecutive_b_frame_count: u32,
51878 pub rate_control_structure: VideoEncodeH264RateControlStructureFlagsEXT,
51879 pub temporal_layer_count: u8,
51880}
51881impl ::std::default::Default for VideoEncodeH264RateControlInfoEXT {
51882 fn default() -> Self {
51883 Self {
51884 s_type: StructureType::VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT,
51885 p_next: ::std::ptr::null(),
51886 gop_frame_count: u32::default(),
51887 idr_period: u32::default(),
51888 consecutive_b_frame_count: u32::default(),
51889 rate_control_structure: VideoEncodeH264RateControlStructureFlagsEXT::default(),
51890 temporal_layer_count: u8::default(),
51891 }
51892 }
51893}
51894impl VideoEncodeH264RateControlInfoEXT {
51895 pub fn builder<'a>() -> VideoEncodeH264RateControlInfoEXTBuilder<'a> {
51896 VideoEncodeH264RateControlInfoEXTBuilder {
51897 inner: Self::default(),
51898 marker: ::std::marker::PhantomData,
51899 }
51900 }
51901}
51902#[repr(transparent)]
51903pub struct VideoEncodeH264RateControlInfoEXTBuilder<'a> {
51904 inner: VideoEncodeH264RateControlInfoEXT,
51905 marker: ::std::marker::PhantomData<&'a ()>,
51906}
51907unsafe impl ExtendsVideoEncodeRateControlInfoKHR for VideoEncodeH264RateControlInfoEXTBuilder<'_> {}
51908unsafe impl ExtendsVideoEncodeRateControlInfoKHR for VideoEncodeH264RateControlInfoEXT {}
51909impl<'a> ::std::ops::Deref for VideoEncodeH264RateControlInfoEXTBuilder<'a> {
51910 type Target = VideoEncodeH264RateControlInfoEXT;
51911 fn deref(&self) -> &Self::Target {
51912 &self.inner
51913 }
51914}
51915impl<'a> ::std::ops::DerefMut for VideoEncodeH264RateControlInfoEXTBuilder<'a> {
51916 fn deref_mut(&mut self) -> &mut Self::Target {
51917 &mut self.inner
51918 }
51919}
51920impl<'a> VideoEncodeH264RateControlInfoEXTBuilder<'a> {
51921 pub fn gop_frame_count(mut self, gop_frame_count: u32) -> Self {
51922 self.inner.gop_frame_count = gop_frame_count;
51923 self
51924 }
51925 pub fn idr_period(mut self, idr_period: u32) -> Self {
51926 self.inner.idr_period = idr_period;
51927 self
51928 }
51929 pub fn consecutive_b_frame_count(mut self, consecutive_b_frame_count: u32) -> Self {
51930 self.inner.consecutive_b_frame_count = consecutive_b_frame_count;
51931 self
51932 }
51933 pub fn rate_control_structure(
51934 mut self,
51935 rate_control_structure: VideoEncodeH264RateControlStructureFlagsEXT,
51936 ) -> Self {
51937 self.inner.rate_control_structure = rate_control_structure;
51938 self
51939 }
51940 pub fn temporal_layer_count(mut self, temporal_layer_count: u8) -> Self {
51941 self.inner.temporal_layer_count = temporal_layer_count;
51942 self
51943 }
51944 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51945 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51946 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
51947 pub fn build(self) -> VideoEncodeH264RateControlInfoEXT {
51948 self.inner
51949 }
51950}
51951#[repr(C)]
51952#[cfg_attr(feature = "debug", derive(Debug))]
51953#[derive(Copy, Clone, Default)]
51954#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264QpEXT.html>"]
51955pub struct VideoEncodeH264QpEXT {
51956 pub qp_i: i32,
51957 pub qp_p: i32,
51958 pub qp_b: i32,
51959}
51960impl VideoEncodeH264QpEXT {
51961 pub fn builder<'a>() -> VideoEncodeH264QpEXTBuilder<'a> {
51962 VideoEncodeH264QpEXTBuilder {
51963 inner: Self::default(),
51964 marker: ::std::marker::PhantomData,
51965 }
51966 }
51967}
51968#[repr(transparent)]
51969pub struct VideoEncodeH264QpEXTBuilder<'a> {
51970 inner: VideoEncodeH264QpEXT,
51971 marker: ::std::marker::PhantomData<&'a ()>,
51972}
51973impl<'a> ::std::ops::Deref for VideoEncodeH264QpEXTBuilder<'a> {
51974 type Target = VideoEncodeH264QpEXT;
51975 fn deref(&self) -> &Self::Target {
51976 &self.inner
51977 }
51978}
51979impl<'a> ::std::ops::DerefMut for VideoEncodeH264QpEXTBuilder<'a> {
51980 fn deref_mut(&mut self) -> &mut Self::Target {
51981 &mut self.inner
51982 }
51983}
51984impl<'a> VideoEncodeH264QpEXTBuilder<'a> {
51985 pub fn qp_i(mut self, qp_i: i32) -> Self {
51986 self.inner.qp_i = qp_i;
51987 self
51988 }
51989 pub fn qp_p(mut self, qp_p: i32) -> Self {
51990 self.inner.qp_p = qp_p;
51991 self
51992 }
51993 pub fn qp_b(mut self, qp_b: i32) -> Self {
51994 self.inner.qp_b = qp_b;
51995 self
51996 }
51997 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51998 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51999 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
52000 pub fn build(self) -> VideoEncodeH264QpEXT {
52001 self.inner
52002 }
52003}
52004#[repr(C)]
52005#[cfg_attr(feature = "debug", derive(Debug))]
52006#[derive(Copy, Clone, Default)]
52007#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264FrameSizeEXT.html>"]
52008pub struct VideoEncodeH264FrameSizeEXT {
52009 pub frame_i_size: u32,
52010 pub frame_p_size: u32,
52011 pub frame_b_size: u32,
52012}
52013impl VideoEncodeH264FrameSizeEXT {
52014 pub fn builder<'a>() -> VideoEncodeH264FrameSizeEXTBuilder<'a> {
52015 VideoEncodeH264FrameSizeEXTBuilder {
52016 inner: Self::default(),
52017 marker: ::std::marker::PhantomData,
52018 }
52019 }
52020}
52021#[repr(transparent)]
52022pub struct VideoEncodeH264FrameSizeEXTBuilder<'a> {
52023 inner: VideoEncodeH264FrameSizeEXT,
52024 marker: ::std::marker::PhantomData<&'a ()>,
52025}
52026impl<'a> ::std::ops::Deref for VideoEncodeH264FrameSizeEXTBuilder<'a> {
52027 type Target = VideoEncodeH264FrameSizeEXT;
52028 fn deref(&self) -> &Self::Target {
52029 &self.inner
52030 }
52031}
52032impl<'a> ::std::ops::DerefMut for VideoEncodeH264FrameSizeEXTBuilder<'a> {
52033 fn deref_mut(&mut self) -> &mut Self::Target {
52034 &mut self.inner
52035 }
52036}
52037impl<'a> VideoEncodeH264FrameSizeEXTBuilder<'a> {
52038 pub fn frame_i_size(mut self, frame_i_size: u32) -> Self {
52039 self.inner.frame_i_size = frame_i_size;
52040 self
52041 }
52042 pub fn frame_p_size(mut self, frame_p_size: u32) -> Self {
52043 self.inner.frame_p_size = frame_p_size;
52044 self
52045 }
52046 pub fn frame_b_size(mut self, frame_b_size: u32) -> Self {
52047 self.inner.frame_b_size = frame_b_size;
52048 self
52049 }
52050 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52051 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52052 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
52053 pub fn build(self) -> VideoEncodeH264FrameSizeEXT {
52054 self.inner
52055 }
52056}
52057#[repr(C)]
52058#[cfg_attr(feature = "debug", derive(Debug))]
52059#[derive(Copy, Clone)]
52060#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264RateControlLayerInfoEXT.html>"]
52061pub struct VideoEncodeH264RateControlLayerInfoEXT {
52062 pub s_type: StructureType,
52063 pub p_next: *const c_void,
52064 pub temporal_layer_id: u8,
52065 pub use_initial_rc_qp: Bool32,
52066 pub initial_rc_qp: VideoEncodeH264QpEXT,
52067 pub use_min_qp: Bool32,
52068 pub min_qp: VideoEncodeH264QpEXT,
52069 pub use_max_qp: Bool32,
52070 pub max_qp: VideoEncodeH264QpEXT,
52071 pub use_max_frame_size: Bool32,
52072 pub max_frame_size: VideoEncodeH264FrameSizeEXT,
52073}
52074impl ::std::default::Default for VideoEncodeH264RateControlLayerInfoEXT {
52075 fn default() -> Self {
52076 Self {
52077 s_type: StructureType::VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT,
52078 p_next: ::std::ptr::null(),
52079 temporal_layer_id: u8::default(),
52080 use_initial_rc_qp: Bool32::default(),
52081 initial_rc_qp: VideoEncodeH264QpEXT::default(),
52082 use_min_qp: Bool32::default(),
52083 min_qp: VideoEncodeH264QpEXT::default(),
52084 use_max_qp: Bool32::default(),
52085 max_qp: VideoEncodeH264QpEXT::default(),
52086 use_max_frame_size: Bool32::default(),
52087 max_frame_size: VideoEncodeH264FrameSizeEXT::default(),
52088 }
52089 }
52090}
52091impl VideoEncodeH264RateControlLayerInfoEXT {
52092 pub fn builder<'a>() -> VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> {
52093 VideoEncodeH264RateControlLayerInfoEXTBuilder {
52094 inner: Self::default(),
52095 marker: ::std::marker::PhantomData,
52096 }
52097 }
52098}
52099#[repr(transparent)]
52100pub struct VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> {
52101 inner: VideoEncodeH264RateControlLayerInfoEXT,
52102 marker: ::std::marker::PhantomData<&'a ()>,
52103}
52104unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR
52105 for VideoEncodeH264RateControlLayerInfoEXTBuilder<'_>
52106{
52107}
52108unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR for VideoEncodeH264RateControlLayerInfoEXT {}
52109impl<'a> ::std::ops::Deref for VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> {
52110 type Target = VideoEncodeH264RateControlLayerInfoEXT;
52111 fn deref(&self) -> &Self::Target {
52112 &self.inner
52113 }
52114}
52115impl<'a> ::std::ops::DerefMut for VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> {
52116 fn deref_mut(&mut self) -> &mut Self::Target {
52117 &mut self.inner
52118 }
52119}
52120impl<'a> VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> {
52121 pub fn temporal_layer_id(mut self, temporal_layer_id: u8) -> Self {
52122 self.inner.temporal_layer_id = temporal_layer_id;
52123 self
52124 }
52125 pub fn use_initial_rc_qp(mut self, use_initial_rc_qp: bool) -> Self {
52126 self.inner.use_initial_rc_qp = use_initial_rc_qp.into();
52127 self
52128 }
52129 pub fn initial_rc_qp(mut self, initial_rc_qp: VideoEncodeH264QpEXT) -> Self {
52130 self.inner.initial_rc_qp = initial_rc_qp;
52131 self
52132 }
52133 pub fn use_min_qp(mut self, use_min_qp: bool) -> Self {
52134 self.inner.use_min_qp = use_min_qp.into();
52135 self
52136 }
52137 pub fn min_qp(mut self, min_qp: VideoEncodeH264QpEXT) -> Self {
52138 self.inner.min_qp = min_qp;
52139 self
52140 }
52141 pub fn use_max_qp(mut self, use_max_qp: bool) -> Self {
52142 self.inner.use_max_qp = use_max_qp.into();
52143 self
52144 }
52145 pub fn max_qp(mut self, max_qp: VideoEncodeH264QpEXT) -> Self {
52146 self.inner.max_qp = max_qp;
52147 self
52148 }
52149 pub fn use_max_frame_size(mut self, use_max_frame_size: bool) -> Self {
52150 self.inner.use_max_frame_size = use_max_frame_size.into();
52151 self
52152 }
52153 pub fn max_frame_size(mut self, max_frame_size: VideoEncodeH264FrameSizeEXT) -> Self {
52154 self.inner.max_frame_size = max_frame_size;
52155 self
52156 }
52157 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52158 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52159 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
52160 pub fn build(self) -> VideoEncodeH264RateControlLayerInfoEXT {
52161 self.inner
52162 }
52163}
52164#[repr(C)]
52165#[cfg_attr(feature = "debug", derive(Debug))]
52166#[derive(Copy, Clone)]
52167#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265CapabilitiesEXT.html>"]
52168pub struct VideoEncodeH265CapabilitiesEXT {
52169 pub s_type: StructureType,
52170 pub p_next: *const c_void,
52171 pub flags: VideoEncodeH265CapabilityFlagsEXT,
52172 pub input_mode_flags: VideoEncodeH265InputModeFlagsEXT,
52173 pub output_mode_flags: VideoEncodeH265OutputModeFlagsEXT,
52174 pub ctb_sizes: VideoEncodeH265CtbSizeFlagsEXT,
52175 pub transform_block_sizes: VideoEncodeH265TransformBlockSizeFlagsEXT,
52176 pub max_p_picture_l0_reference_count: u8,
52177 pub max_b_picture_l0_reference_count: u8,
52178 pub max_l1_reference_count: u8,
52179 pub max_sub_layers_count: u8,
52180 pub min_log2_min_luma_coding_block_size_minus3: u8,
52181 pub max_log2_min_luma_coding_block_size_minus3: u8,
52182 pub min_log2_min_luma_transform_block_size_minus2: u8,
52183 pub max_log2_min_luma_transform_block_size_minus2: u8,
52184 pub min_max_transform_hierarchy_depth_inter: u8,
52185 pub max_max_transform_hierarchy_depth_inter: u8,
52186 pub min_max_transform_hierarchy_depth_intra: u8,
52187 pub max_max_transform_hierarchy_depth_intra: u8,
52188 pub max_diff_cu_qp_delta_depth: u8,
52189 pub min_max_num_merge_cand: u8,
52190 pub max_max_num_merge_cand: u8,
52191}
52192impl ::std::default::Default for VideoEncodeH265CapabilitiesEXT {
52193 fn default() -> Self {
52194 Self {
52195 s_type: StructureType::VIDEO_ENCODE_H265_CAPABILITIES_EXT,
52196 p_next: ::std::ptr::null(),
52197 flags: VideoEncodeH265CapabilityFlagsEXT::default(),
52198 input_mode_flags: VideoEncodeH265InputModeFlagsEXT::default(),
52199 output_mode_flags: VideoEncodeH265OutputModeFlagsEXT::default(),
52200 ctb_sizes: VideoEncodeH265CtbSizeFlagsEXT::default(),
52201 transform_block_sizes: VideoEncodeH265TransformBlockSizeFlagsEXT::default(),
52202 max_p_picture_l0_reference_count: u8::default(),
52203 max_b_picture_l0_reference_count: u8::default(),
52204 max_l1_reference_count: u8::default(),
52205 max_sub_layers_count: u8::default(),
52206 min_log2_min_luma_coding_block_size_minus3: u8::default(),
52207 max_log2_min_luma_coding_block_size_minus3: u8::default(),
52208 min_log2_min_luma_transform_block_size_minus2: u8::default(),
52209 max_log2_min_luma_transform_block_size_minus2: u8::default(),
52210 min_max_transform_hierarchy_depth_inter: u8::default(),
52211 max_max_transform_hierarchy_depth_inter: u8::default(),
52212 min_max_transform_hierarchy_depth_intra: u8::default(),
52213 max_max_transform_hierarchy_depth_intra: u8::default(),
52214 max_diff_cu_qp_delta_depth: u8::default(),
52215 min_max_num_merge_cand: u8::default(),
52216 max_max_num_merge_cand: u8::default(),
52217 }
52218 }
52219}
52220impl VideoEncodeH265CapabilitiesEXT {
52221 pub fn builder<'a>() -> VideoEncodeH265CapabilitiesEXTBuilder<'a> {
52222 VideoEncodeH265CapabilitiesEXTBuilder {
52223 inner: Self::default(),
52224 marker: ::std::marker::PhantomData,
52225 }
52226 }
52227}
52228#[repr(transparent)]
52229pub struct VideoEncodeH265CapabilitiesEXTBuilder<'a> {
52230 inner: VideoEncodeH265CapabilitiesEXT,
52231 marker: ::std::marker::PhantomData<&'a ()>,
52232}
52233unsafe impl ExtendsVideoEncodeCapabilitiesKHR for VideoEncodeH265CapabilitiesEXTBuilder<'_> {}
52234unsafe impl ExtendsVideoEncodeCapabilitiesKHR for VideoEncodeH265CapabilitiesEXT {}
52235impl<'a> ::std::ops::Deref for VideoEncodeH265CapabilitiesEXTBuilder<'a> {
52236 type Target = VideoEncodeH265CapabilitiesEXT;
52237 fn deref(&self) -> &Self::Target {
52238 &self.inner
52239 }
52240}
52241impl<'a> ::std::ops::DerefMut for VideoEncodeH265CapabilitiesEXTBuilder<'a> {
52242 fn deref_mut(&mut self) -> &mut Self::Target {
52243 &mut self.inner
52244 }
52245}
52246impl<'a> VideoEncodeH265CapabilitiesEXTBuilder<'a> {
52247 pub fn flags(mut self, flags: VideoEncodeH265CapabilityFlagsEXT) -> Self {
52248 self.inner.flags = flags;
52249 self
52250 }
52251 pub fn input_mode_flags(mut self, input_mode_flags: VideoEncodeH265InputModeFlagsEXT) -> Self {
52252 self.inner.input_mode_flags = input_mode_flags;
52253 self
52254 }
52255 pub fn output_mode_flags(
52256 mut self,
52257 output_mode_flags: VideoEncodeH265OutputModeFlagsEXT,
52258 ) -> Self {
52259 self.inner.output_mode_flags = output_mode_flags;
52260 self
52261 }
52262 pub fn ctb_sizes(mut self, ctb_sizes: VideoEncodeH265CtbSizeFlagsEXT) -> Self {
52263 self.inner.ctb_sizes = ctb_sizes;
52264 self
52265 }
52266 pub fn transform_block_sizes(
52267 mut self,
52268 transform_block_sizes: VideoEncodeH265TransformBlockSizeFlagsEXT,
52269 ) -> Self {
52270 self.inner.transform_block_sizes = transform_block_sizes;
52271 self
52272 }
52273 pub fn max_p_picture_l0_reference_count(
52274 mut self,
52275 max_p_picture_l0_reference_count: u8,
52276 ) -> Self {
52277 self.inner.max_p_picture_l0_reference_count = max_p_picture_l0_reference_count;
52278 self
52279 }
52280 pub fn max_b_picture_l0_reference_count(
52281 mut self,
52282 max_b_picture_l0_reference_count: u8,
52283 ) -> Self {
52284 self.inner.max_b_picture_l0_reference_count = max_b_picture_l0_reference_count;
52285 self
52286 }
52287 pub fn max_l1_reference_count(mut self, max_l1_reference_count: u8) -> Self {
52288 self.inner.max_l1_reference_count = max_l1_reference_count;
52289 self
52290 }
52291 pub fn max_sub_layers_count(mut self, max_sub_layers_count: u8) -> Self {
52292 self.inner.max_sub_layers_count = max_sub_layers_count;
52293 self
52294 }
52295 pub fn min_log2_min_luma_coding_block_size_minus3(
52296 mut self,
52297 min_log2_min_luma_coding_block_size_minus3: u8,
52298 ) -> Self {
52299 self.inner.min_log2_min_luma_coding_block_size_minus3 =
52300 min_log2_min_luma_coding_block_size_minus3;
52301 self
52302 }
52303 pub fn max_log2_min_luma_coding_block_size_minus3(
52304 mut self,
52305 max_log2_min_luma_coding_block_size_minus3: u8,
52306 ) -> Self {
52307 self.inner.max_log2_min_luma_coding_block_size_minus3 =
52308 max_log2_min_luma_coding_block_size_minus3;
52309 self
52310 }
52311 pub fn min_log2_min_luma_transform_block_size_minus2(
52312 mut self,
52313 min_log2_min_luma_transform_block_size_minus2: u8,
52314 ) -> Self {
52315 self.inner.min_log2_min_luma_transform_block_size_minus2 =
52316 min_log2_min_luma_transform_block_size_minus2;
52317 self
52318 }
52319 pub fn max_log2_min_luma_transform_block_size_minus2(
52320 mut self,
52321 max_log2_min_luma_transform_block_size_minus2: u8,
52322 ) -> Self {
52323 self.inner.max_log2_min_luma_transform_block_size_minus2 =
52324 max_log2_min_luma_transform_block_size_minus2;
52325 self
52326 }
52327 pub fn min_max_transform_hierarchy_depth_inter(
52328 mut self,
52329 min_max_transform_hierarchy_depth_inter: u8,
52330 ) -> Self {
52331 self.inner.min_max_transform_hierarchy_depth_inter =
52332 min_max_transform_hierarchy_depth_inter;
52333 self
52334 }
52335 pub fn max_max_transform_hierarchy_depth_inter(
52336 mut self,
52337 max_max_transform_hierarchy_depth_inter: u8,
52338 ) -> Self {
52339 self.inner.max_max_transform_hierarchy_depth_inter =
52340 max_max_transform_hierarchy_depth_inter;
52341 self
52342 }
52343 pub fn min_max_transform_hierarchy_depth_intra(
52344 mut self,
52345 min_max_transform_hierarchy_depth_intra: u8,
52346 ) -> Self {
52347 self.inner.min_max_transform_hierarchy_depth_intra =
52348 min_max_transform_hierarchy_depth_intra;
52349 self
52350 }
52351 pub fn max_max_transform_hierarchy_depth_intra(
52352 mut self,
52353 max_max_transform_hierarchy_depth_intra: u8,
52354 ) -> Self {
52355 self.inner.max_max_transform_hierarchy_depth_intra =
52356 max_max_transform_hierarchy_depth_intra;
52357 self
52358 }
52359 pub fn max_diff_cu_qp_delta_depth(mut self, max_diff_cu_qp_delta_depth: u8) -> Self {
52360 self.inner.max_diff_cu_qp_delta_depth = max_diff_cu_qp_delta_depth;
52361 self
52362 }
52363 pub fn min_max_num_merge_cand(mut self, min_max_num_merge_cand: u8) -> Self {
52364 self.inner.min_max_num_merge_cand = min_max_num_merge_cand;
52365 self
52366 }
52367 pub fn max_max_num_merge_cand(mut self, max_max_num_merge_cand: u8) -> Self {
52368 self.inner.max_max_num_merge_cand = max_max_num_merge_cand;
52369 self
52370 }
52371 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52372 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52373 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
52374 pub fn build(self) -> VideoEncodeH265CapabilitiesEXT {
52375 self.inner
52376 }
52377}
52378#[repr(C)]
52379#[cfg_attr(feature = "debug", derive(Debug))]
52380#[derive(Copy, Clone)]
52381#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265SessionParametersAddInfoEXT.html>"]
52382pub struct VideoEncodeH265SessionParametersAddInfoEXT {
52383 pub s_type: StructureType,
52384 pub p_next: *const c_void,
52385 pub vps_std_count: u32,
52386 pub p_vps_std: *const StdVideoH265VideoParameterSet,
52387 pub sps_std_count: u32,
52388 pub p_sps_std: *const StdVideoH265SequenceParameterSet,
52389 pub pps_std_count: u32,
52390 pub p_pps_std: *const StdVideoH265PictureParameterSet,
52391}
52392impl ::std::default::Default for VideoEncodeH265SessionParametersAddInfoEXT {
52393 fn default() -> Self {
52394 Self {
52395 s_type: StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT,
52396 p_next: ::std::ptr::null(),
52397 vps_std_count: u32::default(),
52398 p_vps_std: ::std::ptr::null(),
52399 sps_std_count: u32::default(),
52400 p_sps_std: ::std::ptr::null(),
52401 pps_std_count: u32::default(),
52402 p_pps_std: ::std::ptr::null(),
52403 }
52404 }
52405}
52406impl VideoEncodeH265SessionParametersAddInfoEXT {
52407 pub fn builder<'a>() -> VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> {
52408 VideoEncodeH265SessionParametersAddInfoEXTBuilder {
52409 inner: Self::default(),
52410 marker: ::std::marker::PhantomData,
52411 }
52412 }
52413}
52414#[repr(transparent)]
52415pub struct VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> {
52416 inner: VideoEncodeH265SessionParametersAddInfoEXT,
52417 marker: ::std::marker::PhantomData<&'a ()>,
52418}
52419unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
52420 for VideoEncodeH265SessionParametersAddInfoEXTBuilder<'_>
52421{
52422}
52423unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
52424 for VideoEncodeH265SessionParametersAddInfoEXT
52425{
52426}
52427impl<'a> ::std::ops::Deref for VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> {
52428 type Target = VideoEncodeH265SessionParametersAddInfoEXT;
52429 fn deref(&self) -> &Self::Target {
52430 &self.inner
52431 }
52432}
52433impl<'a> ::std::ops::DerefMut for VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> {
52434 fn deref_mut(&mut self) -> &mut Self::Target {
52435 &mut self.inner
52436 }
52437}
52438impl<'a> VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> {
52439 pub fn vps_std(mut self, vps_std: &'a [StdVideoH265VideoParameterSet]) -> Self {
52440 self.inner.vps_std_count = vps_std.len() as _;
52441 self.inner.p_vps_std = vps_std.as_ptr();
52442 self
52443 }
52444 pub fn sps_std(mut self, sps_std: &'a [StdVideoH265SequenceParameterSet]) -> Self {
52445 self.inner.sps_std_count = sps_std.len() as _;
52446 self.inner.p_sps_std = sps_std.as_ptr();
52447 self
52448 }
52449 pub fn pps_std(mut self, pps_std: &'a [StdVideoH265PictureParameterSet]) -> Self {
52450 self.inner.pps_std_count = pps_std.len() as _;
52451 self.inner.p_pps_std = pps_std.as_ptr();
52452 self
52453 }
52454 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52455 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52456 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
52457 pub fn build(self) -> VideoEncodeH265SessionParametersAddInfoEXT {
52458 self.inner
52459 }
52460}
52461#[repr(C)]
52462#[cfg_attr(feature = "debug", derive(Debug))]
52463#[derive(Copy, Clone)]
52464#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265SessionParametersCreateInfoEXT.html>"]
52465pub struct VideoEncodeH265SessionParametersCreateInfoEXT {
52466 pub s_type: StructureType,
52467 pub p_next: *const c_void,
52468 pub max_vps_std_count: u32,
52469 pub max_sps_std_count: u32,
52470 pub max_pps_std_count: u32,
52471 pub p_parameters_add_info: *const VideoEncodeH265SessionParametersAddInfoEXT,
52472}
52473impl ::std::default::Default for VideoEncodeH265SessionParametersCreateInfoEXT {
52474 fn default() -> Self {
52475 Self {
52476 s_type: StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT,
52477 p_next: ::std::ptr::null(),
52478 max_vps_std_count: u32::default(),
52479 max_sps_std_count: u32::default(),
52480 max_pps_std_count: u32::default(),
52481 p_parameters_add_info: ::std::ptr::null(),
52482 }
52483 }
52484}
52485impl VideoEncodeH265SessionParametersCreateInfoEXT {
52486 pub fn builder<'a>() -> VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> {
52487 VideoEncodeH265SessionParametersCreateInfoEXTBuilder {
52488 inner: Self::default(),
52489 marker: ::std::marker::PhantomData,
52490 }
52491 }
52492}
52493#[repr(transparent)]
52494pub struct VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> {
52495 inner: VideoEncodeH265SessionParametersCreateInfoEXT,
52496 marker: ::std::marker::PhantomData<&'a ()>,
52497}
52498unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
52499 for VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'_>
52500{
52501}
52502unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
52503 for VideoEncodeH265SessionParametersCreateInfoEXT
52504{
52505}
52506impl<'a> ::std::ops::Deref for VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> {
52507 type Target = VideoEncodeH265SessionParametersCreateInfoEXT;
52508 fn deref(&self) -> &Self::Target {
52509 &self.inner
52510 }
52511}
52512impl<'a> ::std::ops::DerefMut for VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> {
52513 fn deref_mut(&mut self) -> &mut Self::Target {
52514 &mut self.inner
52515 }
52516}
52517impl<'a> VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> {
52518 pub fn max_vps_std_count(mut self, max_vps_std_count: u32) -> Self {
52519 self.inner.max_vps_std_count = max_vps_std_count;
52520 self
52521 }
52522 pub fn max_sps_std_count(mut self, max_sps_std_count: u32) -> Self {
52523 self.inner.max_sps_std_count = max_sps_std_count;
52524 self
52525 }
52526 pub fn max_pps_std_count(mut self, max_pps_std_count: u32) -> Self {
52527 self.inner.max_pps_std_count = max_pps_std_count;
52528 self
52529 }
52530 pub fn parameters_add_info(
52531 mut self,
52532 parameters_add_info: &'a VideoEncodeH265SessionParametersAddInfoEXT,
52533 ) -> Self {
52534 self.inner.p_parameters_add_info = parameters_add_info;
52535 self
52536 }
52537 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52538 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52539 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
52540 pub fn build(self) -> VideoEncodeH265SessionParametersCreateInfoEXT {
52541 self.inner
52542 }
52543}
52544#[repr(C)]
52545#[cfg_attr(feature = "debug", derive(Debug))]
52546#[derive(Copy, Clone)]
52547#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265VclFrameInfoEXT.html>"]
52548pub struct VideoEncodeH265VclFrameInfoEXT {
52549 pub s_type: StructureType,
52550 pub p_next: *const c_void,
52551 pub p_reference_final_lists: *const VideoEncodeH265ReferenceListsEXT,
52552 pub nalu_slice_segment_entry_count: u32,
52553 pub p_nalu_slice_segment_entries: *const VideoEncodeH265NaluSliceSegmentEXT,
52554 pub p_current_picture_info: *const StdVideoEncodeH265PictureInfo,
52555}
52556impl ::std::default::Default for VideoEncodeH265VclFrameInfoEXT {
52557 fn default() -> Self {
52558 Self {
52559 s_type: StructureType::VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT,
52560 p_next: ::std::ptr::null(),
52561 p_reference_final_lists: ::std::ptr::null(),
52562 nalu_slice_segment_entry_count: u32::default(),
52563 p_nalu_slice_segment_entries: ::std::ptr::null(),
52564 p_current_picture_info: ::std::ptr::null(),
52565 }
52566 }
52567}
52568impl VideoEncodeH265VclFrameInfoEXT {
52569 pub fn builder<'a>() -> VideoEncodeH265VclFrameInfoEXTBuilder<'a> {
52570 VideoEncodeH265VclFrameInfoEXTBuilder {
52571 inner: Self::default(),
52572 marker: ::std::marker::PhantomData,
52573 }
52574 }
52575}
52576#[repr(transparent)]
52577pub struct VideoEncodeH265VclFrameInfoEXTBuilder<'a> {
52578 inner: VideoEncodeH265VclFrameInfoEXT,
52579 marker: ::std::marker::PhantomData<&'a ()>,
52580}
52581unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265VclFrameInfoEXTBuilder<'_> {}
52582unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265VclFrameInfoEXT {}
52583impl<'a> ::std::ops::Deref for VideoEncodeH265VclFrameInfoEXTBuilder<'a> {
52584 type Target = VideoEncodeH265VclFrameInfoEXT;
52585 fn deref(&self) -> &Self::Target {
52586 &self.inner
52587 }
52588}
52589impl<'a> ::std::ops::DerefMut for VideoEncodeH265VclFrameInfoEXTBuilder<'a> {
52590 fn deref_mut(&mut self) -> &mut Self::Target {
52591 &mut self.inner
52592 }
52593}
52594impl<'a> VideoEncodeH265VclFrameInfoEXTBuilder<'a> {
52595 pub fn reference_final_lists(
52596 mut self,
52597 reference_final_lists: &'a VideoEncodeH265ReferenceListsEXT,
52598 ) -> Self {
52599 self.inner.p_reference_final_lists = reference_final_lists;
52600 self
52601 }
52602 pub fn nalu_slice_segment_entries(
52603 mut self,
52604 nalu_slice_segment_entries: &'a [VideoEncodeH265NaluSliceSegmentEXT],
52605 ) -> Self {
52606 self.inner.nalu_slice_segment_entry_count = nalu_slice_segment_entries.len() as _;
52607 self.inner.p_nalu_slice_segment_entries = nalu_slice_segment_entries.as_ptr();
52608 self
52609 }
52610 pub fn current_picture_info(
52611 mut self,
52612 current_picture_info: &'a StdVideoEncodeH265PictureInfo,
52613 ) -> Self {
52614 self.inner.p_current_picture_info = current_picture_info;
52615 self
52616 }
52617 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52618 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52619 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
52620 pub fn build(self) -> VideoEncodeH265VclFrameInfoEXT {
52621 self.inner
52622 }
52623}
52624#[repr(C)]
52625#[cfg_attr(feature = "debug", derive(Debug))]
52626#[derive(Copy, Clone)]
52627#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265EmitPictureParametersEXT.html>"]
52628pub struct VideoEncodeH265EmitPictureParametersEXT {
52629 pub s_type: StructureType,
52630 pub p_next: *const c_void,
52631 pub vps_id: u8,
52632 pub sps_id: u8,
52633 pub emit_vps_enable: Bool32,
52634 pub emit_sps_enable: Bool32,
52635 pub pps_id_entry_count: u32,
52636 pub pps_id_entries: *const u8,
52637}
52638impl ::std::default::Default for VideoEncodeH265EmitPictureParametersEXT {
52639 fn default() -> Self {
52640 Self {
52641 s_type: StructureType::VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT,
52642 p_next: ::std::ptr::null(),
52643 vps_id: u8::default(),
52644 sps_id: u8::default(),
52645 emit_vps_enable: Bool32::default(),
52646 emit_sps_enable: Bool32::default(),
52647 pps_id_entry_count: u32::default(),
52648 pps_id_entries: ::std::ptr::null(),
52649 }
52650 }
52651}
52652impl VideoEncodeH265EmitPictureParametersEXT {
52653 pub fn builder<'a>() -> VideoEncodeH265EmitPictureParametersEXTBuilder<'a> {
52654 VideoEncodeH265EmitPictureParametersEXTBuilder {
52655 inner: Self::default(),
52656 marker: ::std::marker::PhantomData,
52657 }
52658 }
52659}
52660#[repr(transparent)]
52661pub struct VideoEncodeH265EmitPictureParametersEXTBuilder<'a> {
52662 inner: VideoEncodeH265EmitPictureParametersEXT,
52663 marker: ::std::marker::PhantomData<&'a ()>,
52664}
52665unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265EmitPictureParametersEXTBuilder<'_> {}
52666unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265EmitPictureParametersEXT {}
52667impl<'a> ::std::ops::Deref for VideoEncodeH265EmitPictureParametersEXTBuilder<'a> {
52668 type Target = VideoEncodeH265EmitPictureParametersEXT;
52669 fn deref(&self) -> &Self::Target {
52670 &self.inner
52671 }
52672}
52673impl<'a> ::std::ops::DerefMut for VideoEncodeH265EmitPictureParametersEXTBuilder<'a> {
52674 fn deref_mut(&mut self) -> &mut Self::Target {
52675 &mut self.inner
52676 }
52677}
52678impl<'a> VideoEncodeH265EmitPictureParametersEXTBuilder<'a> {
52679 pub fn vps_id(mut self, vps_id: u8) -> Self {
52680 self.inner.vps_id = vps_id;
52681 self
52682 }
52683 pub fn sps_id(mut self, sps_id: u8) -> Self {
52684 self.inner.sps_id = sps_id;
52685 self
52686 }
52687 pub fn emit_vps_enable(mut self, emit_vps_enable: bool) -> Self {
52688 self.inner.emit_vps_enable = emit_vps_enable.into();
52689 self
52690 }
52691 pub fn emit_sps_enable(mut self, emit_sps_enable: bool) -> Self {
52692 self.inner.emit_sps_enable = emit_sps_enable.into();
52693 self
52694 }
52695 pub fn pps_id_entries(mut self, pps_id_entries: &'a [u8]) -> Self {
52696 self.inner.pps_id_entry_count = pps_id_entries.len() as _;
52697 self.inner.pps_id_entries = pps_id_entries.as_ptr();
52698 self
52699 }
52700 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52701 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52702 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
52703 pub fn build(self) -> VideoEncodeH265EmitPictureParametersEXT {
52704 self.inner
52705 }
52706}
52707#[repr(C)]
52708#[cfg_attr(feature = "debug", derive(Debug))]
52709#[derive(Copy, Clone)]
52710#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265NaluSliceSegmentEXT.html>"]
52711pub struct VideoEncodeH265NaluSliceSegmentEXT {
52712 pub s_type: StructureType,
52713 pub p_next: *const c_void,
52714 pub ctb_count: u32,
52715 pub p_reference_final_lists: *const VideoEncodeH265ReferenceListsEXT,
52716 pub p_slice_segment_header_std: *const StdVideoEncodeH265SliceSegmentHeader,
52717}
52718impl ::std::default::Default for VideoEncodeH265NaluSliceSegmentEXT {
52719 fn default() -> Self {
52720 Self {
52721 s_type: StructureType::VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_EXT,
52722 p_next: ::std::ptr::null(),
52723 ctb_count: u32::default(),
52724 p_reference_final_lists: ::std::ptr::null(),
52725 p_slice_segment_header_std: ::std::ptr::null(),
52726 }
52727 }
52728}
52729impl VideoEncodeH265NaluSliceSegmentEXT {
52730 pub fn builder<'a>() -> VideoEncodeH265NaluSliceSegmentEXTBuilder<'a> {
52731 VideoEncodeH265NaluSliceSegmentEXTBuilder {
52732 inner: Self::default(),
52733 marker: ::std::marker::PhantomData,
52734 }
52735 }
52736}
52737#[repr(transparent)]
52738pub struct VideoEncodeH265NaluSliceSegmentEXTBuilder<'a> {
52739 inner: VideoEncodeH265NaluSliceSegmentEXT,
52740 marker: ::std::marker::PhantomData<&'a ()>,
52741}
52742impl<'a> ::std::ops::Deref for VideoEncodeH265NaluSliceSegmentEXTBuilder<'a> {
52743 type Target = VideoEncodeH265NaluSliceSegmentEXT;
52744 fn deref(&self) -> &Self::Target {
52745 &self.inner
52746 }
52747}
52748impl<'a> ::std::ops::DerefMut for VideoEncodeH265NaluSliceSegmentEXTBuilder<'a> {
52749 fn deref_mut(&mut self) -> &mut Self::Target {
52750 &mut self.inner
52751 }
52752}
52753impl<'a> VideoEncodeH265NaluSliceSegmentEXTBuilder<'a> {
52754 pub fn ctb_count(mut self, ctb_count: u32) -> Self {
52755 self.inner.ctb_count = ctb_count;
52756 self
52757 }
52758 pub fn reference_final_lists(
52759 mut self,
52760 reference_final_lists: &'a VideoEncodeH265ReferenceListsEXT,
52761 ) -> Self {
52762 self.inner.p_reference_final_lists = reference_final_lists;
52763 self
52764 }
52765 pub fn slice_segment_header_std(
52766 mut self,
52767 slice_segment_header_std: &'a StdVideoEncodeH265SliceSegmentHeader,
52768 ) -> Self {
52769 self.inner.p_slice_segment_header_std = slice_segment_header_std;
52770 self
52771 }
52772 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52773 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52774 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
52775 pub fn build(self) -> VideoEncodeH265NaluSliceSegmentEXT {
52776 self.inner
52777 }
52778}
52779#[repr(C)]
52780#[cfg_attr(feature = "debug", derive(Debug))]
52781#[derive(Copy, Clone)]
52782#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265RateControlInfoEXT.html>"]
52783pub struct VideoEncodeH265RateControlInfoEXT {
52784 pub s_type: StructureType,
52785 pub p_next: *const c_void,
52786 pub gop_frame_count: u32,
52787 pub idr_period: u32,
52788 pub consecutive_b_frame_count: u32,
52789 pub rate_control_structure: VideoEncodeH265RateControlStructureFlagsEXT,
52790 pub sub_layer_count: u8,
52791}
52792impl ::std::default::Default for VideoEncodeH265RateControlInfoEXT {
52793 fn default() -> Self {
52794 Self {
52795 s_type: StructureType::VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT,
52796 p_next: ::std::ptr::null(),
52797 gop_frame_count: u32::default(),
52798 idr_period: u32::default(),
52799 consecutive_b_frame_count: u32::default(),
52800 rate_control_structure: VideoEncodeH265RateControlStructureFlagsEXT::default(),
52801 sub_layer_count: u8::default(),
52802 }
52803 }
52804}
52805impl VideoEncodeH265RateControlInfoEXT {
52806 pub fn builder<'a>() -> VideoEncodeH265RateControlInfoEXTBuilder<'a> {
52807 VideoEncodeH265RateControlInfoEXTBuilder {
52808 inner: Self::default(),
52809 marker: ::std::marker::PhantomData,
52810 }
52811 }
52812}
52813#[repr(transparent)]
52814pub struct VideoEncodeH265RateControlInfoEXTBuilder<'a> {
52815 inner: VideoEncodeH265RateControlInfoEXT,
52816 marker: ::std::marker::PhantomData<&'a ()>,
52817}
52818unsafe impl ExtendsVideoEncodeRateControlInfoKHR for VideoEncodeH265RateControlInfoEXTBuilder<'_> {}
52819unsafe impl ExtendsVideoEncodeRateControlInfoKHR for VideoEncodeH265RateControlInfoEXT {}
52820impl<'a> ::std::ops::Deref for VideoEncodeH265RateControlInfoEXTBuilder<'a> {
52821 type Target = VideoEncodeH265RateControlInfoEXT;
52822 fn deref(&self) -> &Self::Target {
52823 &self.inner
52824 }
52825}
52826impl<'a> ::std::ops::DerefMut for VideoEncodeH265RateControlInfoEXTBuilder<'a> {
52827 fn deref_mut(&mut self) -> &mut Self::Target {
52828 &mut self.inner
52829 }
52830}
52831impl<'a> VideoEncodeH265RateControlInfoEXTBuilder<'a> {
52832 pub fn gop_frame_count(mut self, gop_frame_count: u32) -> Self {
52833 self.inner.gop_frame_count = gop_frame_count;
52834 self
52835 }
52836 pub fn idr_period(mut self, idr_period: u32) -> Self {
52837 self.inner.idr_period = idr_period;
52838 self
52839 }
52840 pub fn consecutive_b_frame_count(mut self, consecutive_b_frame_count: u32) -> Self {
52841 self.inner.consecutive_b_frame_count = consecutive_b_frame_count;
52842 self
52843 }
52844 pub fn rate_control_structure(
52845 mut self,
52846 rate_control_structure: VideoEncodeH265RateControlStructureFlagsEXT,
52847 ) -> Self {
52848 self.inner.rate_control_structure = rate_control_structure;
52849 self
52850 }
52851 pub fn sub_layer_count(mut self, sub_layer_count: u8) -> Self {
52852 self.inner.sub_layer_count = sub_layer_count;
52853 self
52854 }
52855 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52856 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52857 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
52858 pub fn build(self) -> VideoEncodeH265RateControlInfoEXT {
52859 self.inner
52860 }
52861}
52862#[repr(C)]
52863#[cfg_attr(feature = "debug", derive(Debug))]
52864#[derive(Copy, Clone, Default)]
52865#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265QpEXT.html>"]
52866pub struct VideoEncodeH265QpEXT {
52867 pub qp_i: i32,
52868 pub qp_p: i32,
52869 pub qp_b: i32,
52870}
52871impl VideoEncodeH265QpEXT {
52872 pub fn builder<'a>() -> VideoEncodeH265QpEXTBuilder<'a> {
52873 VideoEncodeH265QpEXTBuilder {
52874 inner: Self::default(),
52875 marker: ::std::marker::PhantomData,
52876 }
52877 }
52878}
52879#[repr(transparent)]
52880pub struct VideoEncodeH265QpEXTBuilder<'a> {
52881 inner: VideoEncodeH265QpEXT,
52882 marker: ::std::marker::PhantomData<&'a ()>,
52883}
52884impl<'a> ::std::ops::Deref for VideoEncodeH265QpEXTBuilder<'a> {
52885 type Target = VideoEncodeH265QpEXT;
52886 fn deref(&self) -> &Self::Target {
52887 &self.inner
52888 }
52889}
52890impl<'a> ::std::ops::DerefMut for VideoEncodeH265QpEXTBuilder<'a> {
52891 fn deref_mut(&mut self) -> &mut Self::Target {
52892 &mut self.inner
52893 }
52894}
52895impl<'a> VideoEncodeH265QpEXTBuilder<'a> {
52896 pub fn qp_i(mut self, qp_i: i32) -> Self {
52897 self.inner.qp_i = qp_i;
52898 self
52899 }
52900 pub fn qp_p(mut self, qp_p: i32) -> Self {
52901 self.inner.qp_p = qp_p;
52902 self
52903 }
52904 pub fn qp_b(mut self, qp_b: i32) -> Self {
52905 self.inner.qp_b = qp_b;
52906 self
52907 }
52908 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52909 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52910 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
52911 pub fn build(self) -> VideoEncodeH265QpEXT {
52912 self.inner
52913 }
52914}
52915#[repr(C)]
52916#[cfg_attr(feature = "debug", derive(Debug))]
52917#[derive(Copy, Clone, Default)]
52918#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265FrameSizeEXT.html>"]
52919pub struct VideoEncodeH265FrameSizeEXT {
52920 pub frame_i_size: u32,
52921 pub frame_p_size: u32,
52922 pub frame_b_size: u32,
52923}
52924impl VideoEncodeH265FrameSizeEXT {
52925 pub fn builder<'a>() -> VideoEncodeH265FrameSizeEXTBuilder<'a> {
52926 VideoEncodeH265FrameSizeEXTBuilder {
52927 inner: Self::default(),
52928 marker: ::std::marker::PhantomData,
52929 }
52930 }
52931}
52932#[repr(transparent)]
52933pub struct VideoEncodeH265FrameSizeEXTBuilder<'a> {
52934 inner: VideoEncodeH265FrameSizeEXT,
52935 marker: ::std::marker::PhantomData<&'a ()>,
52936}
52937impl<'a> ::std::ops::Deref for VideoEncodeH265FrameSizeEXTBuilder<'a> {
52938 type Target = VideoEncodeH265FrameSizeEXT;
52939 fn deref(&self) -> &Self::Target {
52940 &self.inner
52941 }
52942}
52943impl<'a> ::std::ops::DerefMut for VideoEncodeH265FrameSizeEXTBuilder<'a> {
52944 fn deref_mut(&mut self) -> &mut Self::Target {
52945 &mut self.inner
52946 }
52947}
52948impl<'a> VideoEncodeH265FrameSizeEXTBuilder<'a> {
52949 pub fn frame_i_size(mut self, frame_i_size: u32) -> Self {
52950 self.inner.frame_i_size = frame_i_size;
52951 self
52952 }
52953 pub fn frame_p_size(mut self, frame_p_size: u32) -> Self {
52954 self.inner.frame_p_size = frame_p_size;
52955 self
52956 }
52957 pub fn frame_b_size(mut self, frame_b_size: u32) -> Self {
52958 self.inner.frame_b_size = frame_b_size;
52959 self
52960 }
52961 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52962 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52963 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
52964 pub fn build(self) -> VideoEncodeH265FrameSizeEXT {
52965 self.inner
52966 }
52967}
52968#[repr(C)]
52969#[cfg_attr(feature = "debug", derive(Debug))]
52970#[derive(Copy, Clone)]
52971#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265RateControlLayerInfoEXT.html>"]
52972pub struct VideoEncodeH265RateControlLayerInfoEXT {
52973 pub s_type: StructureType,
52974 pub p_next: *const c_void,
52975 pub temporal_id: u8,
52976 pub use_initial_rc_qp: Bool32,
52977 pub initial_rc_qp: VideoEncodeH265QpEXT,
52978 pub use_min_qp: Bool32,
52979 pub min_qp: VideoEncodeH265QpEXT,
52980 pub use_max_qp: Bool32,
52981 pub max_qp: VideoEncodeH265QpEXT,
52982 pub use_max_frame_size: Bool32,
52983 pub max_frame_size: VideoEncodeH265FrameSizeEXT,
52984}
52985impl ::std::default::Default for VideoEncodeH265RateControlLayerInfoEXT {
52986 fn default() -> Self {
52987 Self {
52988 s_type: StructureType::VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT,
52989 p_next: ::std::ptr::null(),
52990 temporal_id: u8::default(),
52991 use_initial_rc_qp: Bool32::default(),
52992 initial_rc_qp: VideoEncodeH265QpEXT::default(),
52993 use_min_qp: Bool32::default(),
52994 min_qp: VideoEncodeH265QpEXT::default(),
52995 use_max_qp: Bool32::default(),
52996 max_qp: VideoEncodeH265QpEXT::default(),
52997 use_max_frame_size: Bool32::default(),
52998 max_frame_size: VideoEncodeH265FrameSizeEXT::default(),
52999 }
53000 }
53001}
53002impl VideoEncodeH265RateControlLayerInfoEXT {
53003 pub fn builder<'a>() -> VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> {
53004 VideoEncodeH265RateControlLayerInfoEXTBuilder {
53005 inner: Self::default(),
53006 marker: ::std::marker::PhantomData,
53007 }
53008 }
53009}
53010#[repr(transparent)]
53011pub struct VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> {
53012 inner: VideoEncodeH265RateControlLayerInfoEXT,
53013 marker: ::std::marker::PhantomData<&'a ()>,
53014}
53015unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR
53016 for VideoEncodeH265RateControlLayerInfoEXTBuilder<'_>
53017{
53018}
53019unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR for VideoEncodeH265RateControlLayerInfoEXT {}
53020impl<'a> ::std::ops::Deref for VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> {
53021 type Target = VideoEncodeH265RateControlLayerInfoEXT;
53022 fn deref(&self) -> &Self::Target {
53023 &self.inner
53024 }
53025}
53026impl<'a> ::std::ops::DerefMut for VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> {
53027 fn deref_mut(&mut self) -> &mut Self::Target {
53028 &mut self.inner
53029 }
53030}
53031impl<'a> VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> {
53032 pub fn temporal_id(mut self, temporal_id: u8) -> Self {
53033 self.inner.temporal_id = temporal_id;
53034 self
53035 }
53036 pub fn use_initial_rc_qp(mut self, use_initial_rc_qp: bool) -> Self {
53037 self.inner.use_initial_rc_qp = use_initial_rc_qp.into();
53038 self
53039 }
53040 pub fn initial_rc_qp(mut self, initial_rc_qp: VideoEncodeH265QpEXT) -> Self {
53041 self.inner.initial_rc_qp = initial_rc_qp;
53042 self
53043 }
53044 pub fn use_min_qp(mut self, use_min_qp: bool) -> Self {
53045 self.inner.use_min_qp = use_min_qp.into();
53046 self
53047 }
53048 pub fn min_qp(mut self, min_qp: VideoEncodeH265QpEXT) -> Self {
53049 self.inner.min_qp = min_qp;
53050 self
53051 }
53052 pub fn use_max_qp(mut self, use_max_qp: bool) -> Self {
53053 self.inner.use_max_qp = use_max_qp.into();
53054 self
53055 }
53056 pub fn max_qp(mut self, max_qp: VideoEncodeH265QpEXT) -> Self {
53057 self.inner.max_qp = max_qp;
53058 self
53059 }
53060 pub fn use_max_frame_size(mut self, use_max_frame_size: bool) -> Self {
53061 self.inner.use_max_frame_size = use_max_frame_size.into();
53062 self
53063 }
53064 pub fn max_frame_size(mut self, max_frame_size: VideoEncodeH265FrameSizeEXT) -> Self {
53065 self.inner.max_frame_size = max_frame_size;
53066 self
53067 }
53068 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53069 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53070 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
53071 pub fn build(self) -> VideoEncodeH265RateControlLayerInfoEXT {
53072 self.inner
53073 }
53074}
53075#[repr(C)]
53076#[cfg_attr(feature = "debug", derive(Debug))]
53077#[derive(Copy, Clone)]
53078#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265ProfileEXT.html>"]
53079pub struct VideoEncodeH265ProfileEXT {
53080 pub s_type: StructureType,
53081 pub p_next: *const c_void,
53082 pub std_profile_idc: StdVideoH265ProfileIdc,
53083}
53084impl ::std::default::Default for VideoEncodeH265ProfileEXT {
53085 fn default() -> Self {
53086 Self {
53087 s_type: StructureType::VIDEO_ENCODE_H265_PROFILE_EXT,
53088 p_next: ::std::ptr::null(),
53089 std_profile_idc: StdVideoH265ProfileIdc::default(),
53090 }
53091 }
53092}
53093impl VideoEncodeH265ProfileEXT {
53094 pub fn builder<'a>() -> VideoEncodeH265ProfileEXTBuilder<'a> {
53095 VideoEncodeH265ProfileEXTBuilder {
53096 inner: Self::default(),
53097 marker: ::std::marker::PhantomData,
53098 }
53099 }
53100}
53101#[repr(transparent)]
53102pub struct VideoEncodeH265ProfileEXTBuilder<'a> {
53103 inner: VideoEncodeH265ProfileEXT,
53104 marker: ::std::marker::PhantomData<&'a ()>,
53105}
53106unsafe impl ExtendsVideoProfileKHR for VideoEncodeH265ProfileEXTBuilder<'_> {}
53107unsafe impl ExtendsVideoProfileKHR for VideoEncodeH265ProfileEXT {}
53108unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH265ProfileEXTBuilder<'_> {}
53109unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH265ProfileEXT {}
53110unsafe impl ExtendsFormatProperties2 for VideoEncodeH265ProfileEXTBuilder<'_> {}
53111unsafe impl ExtendsFormatProperties2 for VideoEncodeH265ProfileEXT {}
53112unsafe impl ExtendsImageCreateInfo for VideoEncodeH265ProfileEXTBuilder<'_> {}
53113unsafe impl ExtendsImageCreateInfo for VideoEncodeH265ProfileEXT {}
53114unsafe impl ExtendsImageViewCreateInfo for VideoEncodeH265ProfileEXTBuilder<'_> {}
53115unsafe impl ExtendsImageViewCreateInfo for VideoEncodeH265ProfileEXT {}
53116unsafe impl ExtendsBufferCreateInfo for VideoEncodeH265ProfileEXTBuilder<'_> {}
53117unsafe impl ExtendsBufferCreateInfo for VideoEncodeH265ProfileEXT {}
53118impl<'a> ::std::ops::Deref for VideoEncodeH265ProfileEXTBuilder<'a> {
53119 type Target = VideoEncodeH265ProfileEXT;
53120 fn deref(&self) -> &Self::Target {
53121 &self.inner
53122 }
53123}
53124impl<'a> ::std::ops::DerefMut for VideoEncodeH265ProfileEXTBuilder<'a> {
53125 fn deref_mut(&mut self) -> &mut Self::Target {
53126 &mut self.inner
53127 }
53128}
53129impl<'a> VideoEncodeH265ProfileEXTBuilder<'a> {
53130 pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH265ProfileIdc) -> Self {
53131 self.inner.std_profile_idc = std_profile_idc;
53132 self
53133 }
53134 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53135 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53136 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
53137 pub fn build(self) -> VideoEncodeH265ProfileEXT {
53138 self.inner
53139 }
53140}
53141#[repr(C)]
53142#[cfg_attr(feature = "debug", derive(Debug))]
53143#[derive(Copy, Clone)]
53144#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265DpbSlotInfoEXT.html>"]
53145pub struct VideoEncodeH265DpbSlotInfoEXT {
53146 pub s_type: StructureType,
53147 pub p_next: *const c_void,
53148 pub slot_index: i8,
53149 pub p_std_reference_info: *const StdVideoEncodeH265ReferenceInfo,
53150}
53151impl ::std::default::Default for VideoEncodeH265DpbSlotInfoEXT {
53152 fn default() -> Self {
53153 Self {
53154 s_type: StructureType::VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT,
53155 p_next: ::std::ptr::null(),
53156 slot_index: i8::default(),
53157 p_std_reference_info: ::std::ptr::null(),
53158 }
53159 }
53160}
53161impl VideoEncodeH265DpbSlotInfoEXT {
53162 pub fn builder<'a>() -> VideoEncodeH265DpbSlotInfoEXTBuilder<'a> {
53163 VideoEncodeH265DpbSlotInfoEXTBuilder {
53164 inner: Self::default(),
53165 marker: ::std::marker::PhantomData,
53166 }
53167 }
53168}
53169#[repr(transparent)]
53170pub struct VideoEncodeH265DpbSlotInfoEXTBuilder<'a> {
53171 inner: VideoEncodeH265DpbSlotInfoEXT,
53172 marker: ::std::marker::PhantomData<&'a ()>,
53173}
53174impl<'a> ::std::ops::Deref for VideoEncodeH265DpbSlotInfoEXTBuilder<'a> {
53175 type Target = VideoEncodeH265DpbSlotInfoEXT;
53176 fn deref(&self) -> &Self::Target {
53177 &self.inner
53178 }
53179}
53180impl<'a> ::std::ops::DerefMut for VideoEncodeH265DpbSlotInfoEXTBuilder<'a> {
53181 fn deref_mut(&mut self) -> &mut Self::Target {
53182 &mut self.inner
53183 }
53184}
53185impl<'a> VideoEncodeH265DpbSlotInfoEXTBuilder<'a> {
53186 pub fn slot_index(mut self, slot_index: i8) -> Self {
53187 self.inner.slot_index = slot_index;
53188 self
53189 }
53190 pub fn std_reference_info(
53191 mut self,
53192 std_reference_info: &'a StdVideoEncodeH265ReferenceInfo,
53193 ) -> Self {
53194 self.inner.p_std_reference_info = std_reference_info;
53195 self
53196 }
53197 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53198 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53199 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
53200 pub fn build(self) -> VideoEncodeH265DpbSlotInfoEXT {
53201 self.inner
53202 }
53203}
53204#[repr(C)]
53205#[cfg_attr(feature = "debug", derive(Debug))]
53206#[derive(Copy, Clone)]
53207#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265ReferenceListsEXT.html>"]
53208pub struct VideoEncodeH265ReferenceListsEXT {
53209 pub s_type: StructureType,
53210 pub p_next: *const c_void,
53211 pub reference_list0_entry_count: u8,
53212 pub p_reference_list0_entries: *const VideoEncodeH265DpbSlotInfoEXT,
53213 pub reference_list1_entry_count: u8,
53214 pub p_reference_list1_entries: *const VideoEncodeH265DpbSlotInfoEXT,
53215 pub p_reference_modifications: *const StdVideoEncodeH265ReferenceModifications,
53216}
53217impl ::std::default::Default for VideoEncodeH265ReferenceListsEXT {
53218 fn default() -> Self {
53219 Self {
53220 s_type: StructureType::VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT,
53221 p_next: ::std::ptr::null(),
53222 reference_list0_entry_count: u8::default(),
53223 p_reference_list0_entries: ::std::ptr::null(),
53224 reference_list1_entry_count: u8::default(),
53225 p_reference_list1_entries: ::std::ptr::null(),
53226 p_reference_modifications: ::std::ptr::null(),
53227 }
53228 }
53229}
53230impl VideoEncodeH265ReferenceListsEXT {
53231 pub fn builder<'a>() -> VideoEncodeH265ReferenceListsEXTBuilder<'a> {
53232 VideoEncodeH265ReferenceListsEXTBuilder {
53233 inner: Self::default(),
53234 marker: ::std::marker::PhantomData,
53235 }
53236 }
53237}
53238#[repr(transparent)]
53239pub struct VideoEncodeH265ReferenceListsEXTBuilder<'a> {
53240 inner: VideoEncodeH265ReferenceListsEXT,
53241 marker: ::std::marker::PhantomData<&'a ()>,
53242}
53243impl<'a> ::std::ops::Deref for VideoEncodeH265ReferenceListsEXTBuilder<'a> {
53244 type Target = VideoEncodeH265ReferenceListsEXT;
53245 fn deref(&self) -> &Self::Target {
53246 &self.inner
53247 }
53248}
53249impl<'a> ::std::ops::DerefMut for VideoEncodeH265ReferenceListsEXTBuilder<'a> {
53250 fn deref_mut(&mut self) -> &mut Self::Target {
53251 &mut self.inner
53252 }
53253}
53254impl<'a> VideoEncodeH265ReferenceListsEXTBuilder<'a> {
53255 pub fn reference_list0_entries(
53256 mut self,
53257 reference_list0_entries: &'a [VideoEncodeH265DpbSlotInfoEXT],
53258 ) -> Self {
53259 self.inner.reference_list0_entry_count = reference_list0_entries.len() as _;
53260 self.inner.p_reference_list0_entries = reference_list0_entries.as_ptr();
53261 self
53262 }
53263 pub fn reference_list1_entries(
53264 mut self,
53265 reference_list1_entries: &'a [VideoEncodeH265DpbSlotInfoEXT],
53266 ) -> Self {
53267 self.inner.reference_list1_entry_count = reference_list1_entries.len() as _;
53268 self.inner.p_reference_list1_entries = reference_list1_entries.as_ptr();
53269 self
53270 }
53271 pub fn reference_modifications(
53272 mut self,
53273 reference_modifications: &'a StdVideoEncodeH265ReferenceModifications,
53274 ) -> Self {
53275 self.inner.p_reference_modifications = reference_modifications;
53276 self
53277 }
53278 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53279 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53280 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
53281 pub fn build(self) -> VideoEncodeH265ReferenceListsEXT {
53282 self.inner
53283 }
53284}
53285#[repr(C)]
53286#[cfg_attr(feature = "debug", derive(Debug))]
53287#[derive(Copy, Clone)]
53288#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceInheritedViewportScissorFeaturesNV.html>"]
53289pub struct PhysicalDeviceInheritedViewportScissorFeaturesNV {
53290 pub s_type: StructureType,
53291 pub p_next: *mut c_void,
53292 pub inherited_viewport_scissor2_d: Bool32,
53293}
53294impl ::std::default::Default for PhysicalDeviceInheritedViewportScissorFeaturesNV {
53295 fn default() -> Self {
53296 Self {
53297 s_type: StructureType::PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV,
53298 p_next: ::std::ptr::null_mut(),
53299 inherited_viewport_scissor2_d: Bool32::default(),
53300 }
53301 }
53302}
53303impl PhysicalDeviceInheritedViewportScissorFeaturesNV {
53304 pub fn builder<'a>() -> PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> {
53305 PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder {
53306 inner: Self::default(),
53307 marker: ::std::marker::PhantomData,
53308 }
53309 }
53310}
53311#[repr(transparent)]
53312pub struct PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> {
53313 inner: PhysicalDeviceInheritedViewportScissorFeaturesNV,
53314 marker: ::std::marker::PhantomData<&'a ()>,
53315}
53316unsafe impl ExtendsPhysicalDeviceFeatures2
53317 for PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'_>
53318{
53319}
53320unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInheritedViewportScissorFeaturesNV {}
53321unsafe impl ExtendsDeviceCreateInfo
53322 for PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'_>
53323{
53324}
53325unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInheritedViewportScissorFeaturesNV {}
53326impl<'a> ::std::ops::Deref for PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> {
53327 type Target = PhysicalDeviceInheritedViewportScissorFeaturesNV;
53328 fn deref(&self) -> &Self::Target {
53329 &self.inner
53330 }
53331}
53332impl<'a> ::std::ops::DerefMut for PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> {
53333 fn deref_mut(&mut self) -> &mut Self::Target {
53334 &mut self.inner
53335 }
53336}
53337impl<'a> PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> {
53338 pub fn inherited_viewport_scissor2_d(mut self, inherited_viewport_scissor2_d: bool) -> Self {
53339 self.inner.inherited_viewport_scissor2_d = inherited_viewport_scissor2_d.into();
53340 self
53341 }
53342 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53343 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53344 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
53345 pub fn build(self) -> PhysicalDeviceInheritedViewportScissorFeaturesNV {
53346 self.inner
53347 }
53348}
53349#[repr(C)]
53350#[cfg_attr(feature = "debug", derive(Debug))]
53351#[derive(Copy, Clone)]
53352#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferInheritanceViewportScissorInfoNV.html>"]
53353pub struct CommandBufferInheritanceViewportScissorInfoNV {
53354 pub s_type: StructureType,
53355 pub p_next: *const c_void,
53356 pub viewport_scissor2_d: Bool32,
53357 pub viewport_depth_count: u32,
53358 pub p_viewport_depths: *const Viewport,
53359}
53360impl ::std::default::Default for CommandBufferInheritanceViewportScissorInfoNV {
53361 fn default() -> Self {
53362 Self {
53363 s_type: StructureType::COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV,
53364 p_next: ::std::ptr::null(),
53365 viewport_scissor2_d: Bool32::default(),
53366 viewport_depth_count: u32::default(),
53367 p_viewport_depths: ::std::ptr::null(),
53368 }
53369 }
53370}
53371impl CommandBufferInheritanceViewportScissorInfoNV {
53372 pub fn builder<'a>() -> CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> {
53373 CommandBufferInheritanceViewportScissorInfoNVBuilder {
53374 inner: Self::default(),
53375 marker: ::std::marker::PhantomData,
53376 }
53377 }
53378}
53379#[repr(transparent)]
53380pub struct CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> {
53381 inner: CommandBufferInheritanceViewportScissorInfoNV,
53382 marker: ::std::marker::PhantomData<&'a ()>,
53383}
53384unsafe impl ExtendsCommandBufferInheritanceInfo
53385 for CommandBufferInheritanceViewportScissorInfoNVBuilder<'_>
53386{
53387}
53388unsafe impl ExtendsCommandBufferInheritanceInfo for CommandBufferInheritanceViewportScissorInfoNV {}
53389impl<'a> ::std::ops::Deref for CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> {
53390 type Target = CommandBufferInheritanceViewportScissorInfoNV;
53391 fn deref(&self) -> &Self::Target {
53392 &self.inner
53393 }
53394}
53395impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> {
53396 fn deref_mut(&mut self) -> &mut Self::Target {
53397 &mut self.inner
53398 }
53399}
53400impl<'a> CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> {
53401 pub fn viewport_scissor2_d(mut self, viewport_scissor2_d: bool) -> Self {
53402 self.inner.viewport_scissor2_d = viewport_scissor2_d.into();
53403 self
53404 }
53405 pub fn viewport_depth_count(mut self, viewport_depth_count: u32) -> Self {
53406 self.inner.viewport_depth_count = viewport_depth_count;
53407 self
53408 }
53409 pub fn viewport_depths(mut self, viewport_depths: &'a Viewport) -> Self {
53410 self.inner.p_viewport_depths = viewport_depths;
53411 self
53412 }
53413 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53414 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53415 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
53416 pub fn build(self) -> CommandBufferInheritanceViewportScissorInfoNV {
53417 self.inner
53418 }
53419}
53420#[repr(C)]
53421#[cfg_attr(feature = "debug", derive(Debug))]
53422#[derive(Copy, Clone)]
53423#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT.html>"]
53424pub struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
53425 pub s_type: StructureType,
53426 pub p_next: *mut c_void,
53427 pub ycbcr2plane444_formats: Bool32,
53428}
53429impl ::std::default::Default for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
53430 fn default() -> Self {
53431 Self {
53432 s_type: StructureType::PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT,
53433 p_next: ::std::ptr::null_mut(),
53434 ycbcr2plane444_formats: Bool32::default(),
53435 }
53436 }
53437}
53438impl PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
53439 pub fn builder<'a>() -> PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> {
53440 PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder {
53441 inner: Self::default(),
53442 marker: ::std::marker::PhantomData,
53443 }
53444 }
53445}
53446#[repr(transparent)]
53447pub struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> {
53448 inner: PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT,
53449 marker: ::std::marker::PhantomData<&'a ()>,
53450}
53451unsafe impl ExtendsPhysicalDeviceFeatures2
53452 for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'_>
53453{
53454}
53455unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {}
53456unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'_> {}
53457unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {}
53458impl<'a> ::std::ops::Deref for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> {
53459 type Target = PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
53460 fn deref(&self) -> &Self::Target {
53461 &self.inner
53462 }
53463}
53464impl<'a> ::std::ops::DerefMut for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> {
53465 fn deref_mut(&mut self) -> &mut Self::Target {
53466 &mut self.inner
53467 }
53468}
53469impl<'a> PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> {
53470 pub fn ycbcr2plane444_formats(mut self, ycbcr2plane444_formats: bool) -> Self {
53471 self.inner.ycbcr2plane444_formats = ycbcr2plane444_formats.into();
53472 self
53473 }
53474 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53475 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53476 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
53477 pub fn build(self) -> PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
53478 self.inner
53479 }
53480}
53481#[repr(C)]
53482#[cfg_attr(feature = "debug", derive(Debug))]
53483#[derive(Copy, Clone)]
53484#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProvokingVertexFeaturesEXT.html>"]
53485pub struct PhysicalDeviceProvokingVertexFeaturesEXT {
53486 pub s_type: StructureType,
53487 pub p_next: *mut c_void,
53488 pub provoking_vertex_last: Bool32,
53489 pub transform_feedback_preserves_provoking_vertex: Bool32,
53490}
53491impl ::std::default::Default for PhysicalDeviceProvokingVertexFeaturesEXT {
53492 fn default() -> Self {
53493 Self {
53494 s_type: StructureType::PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT,
53495 p_next: ::std::ptr::null_mut(),
53496 provoking_vertex_last: Bool32::default(),
53497 transform_feedback_preserves_provoking_vertex: Bool32::default(),
53498 }
53499 }
53500}
53501impl PhysicalDeviceProvokingVertexFeaturesEXT {
53502 pub fn builder<'a>() -> PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> {
53503 PhysicalDeviceProvokingVertexFeaturesEXTBuilder {
53504 inner: Self::default(),
53505 marker: ::std::marker::PhantomData,
53506 }
53507 }
53508}
53509#[repr(transparent)]
53510pub struct PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> {
53511 inner: PhysicalDeviceProvokingVertexFeaturesEXT,
53512 marker: ::std::marker::PhantomData<&'a ()>,
53513}
53514unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'_> {}
53515unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProvokingVertexFeaturesEXT {}
53516unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'_> {}
53517unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProvokingVertexFeaturesEXT {}
53518impl<'a> ::std::ops::Deref for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> {
53519 type Target = PhysicalDeviceProvokingVertexFeaturesEXT;
53520 fn deref(&self) -> &Self::Target {
53521 &self.inner
53522 }
53523}
53524impl<'a> ::std::ops::DerefMut for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> {
53525 fn deref_mut(&mut self) -> &mut Self::Target {
53526 &mut self.inner
53527 }
53528}
53529impl<'a> PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> {
53530 pub fn provoking_vertex_last(mut self, provoking_vertex_last: bool) -> Self {
53531 self.inner.provoking_vertex_last = provoking_vertex_last.into();
53532 self
53533 }
53534 pub fn transform_feedback_preserves_provoking_vertex(
53535 mut self,
53536 transform_feedback_preserves_provoking_vertex: bool,
53537 ) -> Self {
53538 self.inner.transform_feedback_preserves_provoking_vertex =
53539 transform_feedback_preserves_provoking_vertex.into();
53540 self
53541 }
53542 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53543 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53544 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
53545 pub fn build(self) -> PhysicalDeviceProvokingVertexFeaturesEXT {
53546 self.inner
53547 }
53548}
53549#[repr(C)]
53550#[cfg_attr(feature = "debug", derive(Debug))]
53551#[derive(Copy, Clone)]
53552#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProvokingVertexPropertiesEXT.html>"]
53553pub struct PhysicalDeviceProvokingVertexPropertiesEXT {
53554 pub s_type: StructureType,
53555 pub p_next: *mut c_void,
53556 pub provoking_vertex_mode_per_pipeline: Bool32,
53557 pub transform_feedback_preserves_triangle_fan_provoking_vertex: Bool32,
53558}
53559impl ::std::default::Default for PhysicalDeviceProvokingVertexPropertiesEXT {
53560 fn default() -> Self {
53561 Self {
53562 s_type: StructureType::PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT,
53563 p_next: ::std::ptr::null_mut(),
53564 provoking_vertex_mode_per_pipeline: Bool32::default(),
53565 transform_feedback_preserves_triangle_fan_provoking_vertex: Bool32::default(),
53566 }
53567 }
53568}
53569impl PhysicalDeviceProvokingVertexPropertiesEXT {
53570 pub fn builder<'a>() -> PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> {
53571 PhysicalDeviceProvokingVertexPropertiesEXTBuilder {
53572 inner: Self::default(),
53573 marker: ::std::marker::PhantomData,
53574 }
53575 }
53576}
53577#[repr(transparent)]
53578pub struct PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> {
53579 inner: PhysicalDeviceProvokingVertexPropertiesEXT,
53580 marker: ::std::marker::PhantomData<&'a ()>,
53581}
53582unsafe impl ExtendsPhysicalDeviceProperties2
53583 for PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'_>
53584{
53585}
53586unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceProvokingVertexPropertiesEXT {}
53587impl<'a> ::std::ops::Deref for PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> {
53588 type Target = PhysicalDeviceProvokingVertexPropertiesEXT;
53589 fn deref(&self) -> &Self::Target {
53590 &self.inner
53591 }
53592}
53593impl<'a> ::std::ops::DerefMut for PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> {
53594 fn deref_mut(&mut self) -> &mut Self::Target {
53595 &mut self.inner
53596 }
53597}
53598impl<'a> PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> {
53599 pub fn provoking_vertex_mode_per_pipeline(
53600 mut self,
53601 provoking_vertex_mode_per_pipeline: bool,
53602 ) -> Self {
53603 self.inner.provoking_vertex_mode_per_pipeline = provoking_vertex_mode_per_pipeline.into();
53604 self
53605 }
53606 pub fn transform_feedback_preserves_triangle_fan_provoking_vertex(
53607 mut self,
53608 transform_feedback_preserves_triangle_fan_provoking_vertex: bool,
53609 ) -> Self {
53610 self.inner
53611 .transform_feedback_preserves_triangle_fan_provoking_vertex =
53612 transform_feedback_preserves_triangle_fan_provoking_vertex.into();
53613 self
53614 }
53615 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53616 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53617 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
53618 pub fn build(self) -> PhysicalDeviceProvokingVertexPropertiesEXT {
53619 self.inner
53620 }
53621}
53622#[repr(C)]
53623#[cfg_attr(feature = "debug", derive(Debug))]
53624#[derive(Copy, Clone)]
53625#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationProvokingVertexStateCreateInfoEXT.html>"]
53626pub struct PipelineRasterizationProvokingVertexStateCreateInfoEXT {
53627 pub s_type: StructureType,
53628 pub p_next: *const c_void,
53629 pub provoking_vertex_mode: ProvokingVertexModeEXT,
53630}
53631impl ::std::default::Default for PipelineRasterizationProvokingVertexStateCreateInfoEXT {
53632 fn default() -> Self {
53633 Self {
53634 s_type: StructureType::PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT,
53635 p_next: ::std::ptr::null(),
53636 provoking_vertex_mode: ProvokingVertexModeEXT::default(),
53637 }
53638 }
53639}
53640impl PipelineRasterizationProvokingVertexStateCreateInfoEXT {
53641 pub fn builder<'a>() -> PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> {
53642 PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder {
53643 inner: Self::default(),
53644 marker: ::std::marker::PhantomData,
53645 }
53646 }
53647}
53648#[repr(transparent)]
53649pub struct PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> {
53650 inner: PipelineRasterizationProvokingVertexStateCreateInfoEXT,
53651 marker: ::std::marker::PhantomData<&'a ()>,
53652}
53653unsafe impl ExtendsPipelineRasterizationStateCreateInfo
53654 for PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'_>
53655{
53656}
53657unsafe impl ExtendsPipelineRasterizationStateCreateInfo
53658 for PipelineRasterizationProvokingVertexStateCreateInfoEXT
53659{
53660}
53661impl<'a> ::std::ops::Deref for PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> {
53662 type Target = PipelineRasterizationProvokingVertexStateCreateInfoEXT;
53663 fn deref(&self) -> &Self::Target {
53664 &self.inner
53665 }
53666}
53667impl<'a> ::std::ops::DerefMut
53668 for PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a>
53669{
53670 fn deref_mut(&mut self) -> &mut Self::Target {
53671 &mut self.inner
53672 }
53673}
53674impl<'a> PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> {
53675 pub fn provoking_vertex_mode(mut self, provoking_vertex_mode: ProvokingVertexModeEXT) -> Self {
53676 self.inner.provoking_vertex_mode = provoking_vertex_mode;
53677 self
53678 }
53679 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53680 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53681 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
53682 pub fn build(self) -> PipelineRasterizationProvokingVertexStateCreateInfoEXT {
53683 self.inner
53684 }
53685}
53686#[repr(C)]
53687#[cfg_attr(feature = "debug", derive(Debug))]
53688#[derive(Copy, Clone)]
53689#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCuModuleCreateInfoNVX.html>"]
53690pub struct CuModuleCreateInfoNVX {
53691 pub s_type: StructureType,
53692 pub p_next: *const c_void,
53693 pub data_size: usize,
53694 pub p_data: *const c_void,
53695}
53696impl ::std::default::Default for CuModuleCreateInfoNVX {
53697 fn default() -> Self {
53698 Self {
53699 s_type: StructureType::CU_MODULE_CREATE_INFO_NVX,
53700 p_next: ::std::ptr::null(),
53701 data_size: usize::default(),
53702 p_data: ::std::ptr::null(),
53703 }
53704 }
53705}
53706impl CuModuleCreateInfoNVX {
53707 pub fn builder<'a>() -> CuModuleCreateInfoNVXBuilder<'a> {
53708 CuModuleCreateInfoNVXBuilder {
53709 inner: Self::default(),
53710 marker: ::std::marker::PhantomData,
53711 }
53712 }
53713}
53714#[repr(transparent)]
53715pub struct CuModuleCreateInfoNVXBuilder<'a> {
53716 inner: CuModuleCreateInfoNVX,
53717 marker: ::std::marker::PhantomData<&'a ()>,
53718}
53719impl<'a> ::std::ops::Deref for CuModuleCreateInfoNVXBuilder<'a> {
53720 type Target = CuModuleCreateInfoNVX;
53721 fn deref(&self) -> &Self::Target {
53722 &self.inner
53723 }
53724}
53725impl<'a> ::std::ops::DerefMut for CuModuleCreateInfoNVXBuilder<'a> {
53726 fn deref_mut(&mut self) -> &mut Self::Target {
53727 &mut self.inner
53728 }
53729}
53730impl<'a> CuModuleCreateInfoNVXBuilder<'a> {
53731 pub fn data(mut self, data: &'a [u8]) -> Self {
53732 self.inner.data_size = data.len();
53733 self.inner.p_data = data.as_ptr() as *const c_void;
53734 self
53735 }
53736 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53737 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53738 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
53739 pub fn build(self) -> CuModuleCreateInfoNVX {
53740 self.inner
53741 }
53742}
53743#[repr(C)]
53744#[cfg_attr(feature = "debug", derive(Debug))]
53745#[derive(Copy, Clone)]
53746#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCuFunctionCreateInfoNVX.html>"]
53747pub struct CuFunctionCreateInfoNVX {
53748 pub s_type: StructureType,
53749 pub p_next: *const c_void,
53750 pub module: CuModuleNVX,
53751 pub p_name: *const c_char,
53752}
53753impl ::std::default::Default for CuFunctionCreateInfoNVX {
53754 fn default() -> Self {
53755 Self {
53756 s_type: StructureType::CU_FUNCTION_CREATE_INFO_NVX,
53757 p_next: ::std::ptr::null(),
53758 module: CuModuleNVX::default(),
53759 p_name: ::std::ptr::null(),
53760 }
53761 }
53762}
53763impl CuFunctionCreateInfoNVX {
53764 pub fn builder<'a>() -> CuFunctionCreateInfoNVXBuilder<'a> {
53765 CuFunctionCreateInfoNVXBuilder {
53766 inner: Self::default(),
53767 marker: ::std::marker::PhantomData,
53768 }
53769 }
53770}
53771#[repr(transparent)]
53772pub struct CuFunctionCreateInfoNVXBuilder<'a> {
53773 inner: CuFunctionCreateInfoNVX,
53774 marker: ::std::marker::PhantomData<&'a ()>,
53775}
53776impl<'a> ::std::ops::Deref for CuFunctionCreateInfoNVXBuilder<'a> {
53777 type Target = CuFunctionCreateInfoNVX;
53778 fn deref(&self) -> &Self::Target {
53779 &self.inner
53780 }
53781}
53782impl<'a> ::std::ops::DerefMut for CuFunctionCreateInfoNVXBuilder<'a> {
53783 fn deref_mut(&mut self) -> &mut Self::Target {
53784 &mut self.inner
53785 }
53786}
53787impl<'a> CuFunctionCreateInfoNVXBuilder<'a> {
53788 pub fn module(mut self, module: CuModuleNVX) -> Self {
53789 self.inner.module = module;
53790 self
53791 }
53792 pub fn name(mut self, name: &'a ::std::ffi::CStr) -> Self {
53793 self.inner.p_name = name.as_ptr();
53794 self
53795 }
53796 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53797 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53798 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
53799 pub fn build(self) -> CuFunctionCreateInfoNVX {
53800 self.inner
53801 }
53802}
53803#[repr(C)]
53804#[cfg_attr(feature = "debug", derive(Debug))]
53805#[derive(Copy, Clone)]
53806#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCuLaunchInfoNVX.html>"]
53807pub struct CuLaunchInfoNVX {
53808 pub s_type: StructureType,
53809 pub p_next: *const c_void,
53810 pub function: CuFunctionNVX,
53811 pub grid_dim_x: u32,
53812 pub grid_dim_y: u32,
53813 pub grid_dim_z: u32,
53814 pub block_dim_x: u32,
53815 pub block_dim_y: u32,
53816 pub block_dim_z: u32,
53817 pub shared_mem_bytes: u32,
53818 pub param_count: usize,
53819 pub p_params: *const *const c_void,
53820 pub extra_count: usize,
53821 pub p_extras: *const *const c_void,
53822}
53823impl ::std::default::Default for CuLaunchInfoNVX {
53824 fn default() -> Self {
53825 Self {
53826 s_type: StructureType::CU_LAUNCH_INFO_NVX,
53827 p_next: ::std::ptr::null(),
53828 function: CuFunctionNVX::default(),
53829 grid_dim_x: u32::default(),
53830 grid_dim_y: u32::default(),
53831 grid_dim_z: u32::default(),
53832 block_dim_x: u32::default(),
53833 block_dim_y: u32::default(),
53834 block_dim_z: u32::default(),
53835 shared_mem_bytes: u32::default(),
53836 param_count: usize::default(),
53837 p_params: ::std::ptr::null(),
53838 extra_count: usize::default(),
53839 p_extras: ::std::ptr::null(),
53840 }
53841 }
53842}
53843impl CuLaunchInfoNVX {
53844 pub fn builder<'a>() -> CuLaunchInfoNVXBuilder<'a> {
53845 CuLaunchInfoNVXBuilder {
53846 inner: Self::default(),
53847 marker: ::std::marker::PhantomData,
53848 }
53849 }
53850}
53851#[repr(transparent)]
53852pub struct CuLaunchInfoNVXBuilder<'a> {
53853 inner: CuLaunchInfoNVX,
53854 marker: ::std::marker::PhantomData<&'a ()>,
53855}
53856impl<'a> ::std::ops::Deref for CuLaunchInfoNVXBuilder<'a> {
53857 type Target = CuLaunchInfoNVX;
53858 fn deref(&self) -> &Self::Target {
53859 &self.inner
53860 }
53861}
53862impl<'a> ::std::ops::DerefMut for CuLaunchInfoNVXBuilder<'a> {
53863 fn deref_mut(&mut self) -> &mut Self::Target {
53864 &mut self.inner
53865 }
53866}
53867impl<'a> CuLaunchInfoNVXBuilder<'a> {
53868 pub fn function(mut self, function: CuFunctionNVX) -> Self {
53869 self.inner.function = function;
53870 self
53871 }
53872 pub fn grid_dim_x(mut self, grid_dim_x: u32) -> Self {
53873 self.inner.grid_dim_x = grid_dim_x;
53874 self
53875 }
53876 pub fn grid_dim_y(mut self, grid_dim_y: u32) -> Self {
53877 self.inner.grid_dim_y = grid_dim_y;
53878 self
53879 }
53880 pub fn grid_dim_z(mut self, grid_dim_z: u32) -> Self {
53881 self.inner.grid_dim_z = grid_dim_z;
53882 self
53883 }
53884 pub fn block_dim_x(mut self, block_dim_x: u32) -> Self {
53885 self.inner.block_dim_x = block_dim_x;
53886 self
53887 }
53888 pub fn block_dim_y(mut self, block_dim_y: u32) -> Self {
53889 self.inner.block_dim_y = block_dim_y;
53890 self
53891 }
53892 pub fn block_dim_z(mut self, block_dim_z: u32) -> Self {
53893 self.inner.block_dim_z = block_dim_z;
53894 self
53895 }
53896 pub fn shared_mem_bytes(mut self, shared_mem_bytes: u32) -> Self {
53897 self.inner.shared_mem_bytes = shared_mem_bytes;
53898 self
53899 }
53900 pub fn params(mut self, params: &'a [*const c_void]) -> Self {
53901 self.inner.param_count = params.len();
53902 self.inner.p_params = params.as_ptr();
53903 self
53904 }
53905 pub fn extras(mut self, extras: &'a [*const c_void]) -> Self {
53906 self.inner.extra_count = extras.len();
53907 self.inner.p_extras = extras.as_ptr();
53908 self
53909 }
53910 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53911 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53912 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
53913 pub fn build(self) -> CuLaunchInfoNVX {
53914 self.inner
53915 }
53916}
53917#[repr(C)]
53918#[cfg_attr(feature = "debug", derive(Debug))]
53919#[derive(Copy, Clone)]
53920#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderIntegerDotProductFeatures.html>"]
53921pub struct PhysicalDeviceShaderIntegerDotProductFeatures {
53922 pub s_type: StructureType,
53923 pub p_next: *mut c_void,
53924 pub shader_integer_dot_product: Bool32,
53925}
53926impl ::std::default::Default for PhysicalDeviceShaderIntegerDotProductFeatures {
53927 fn default() -> Self {
53928 Self {
53929 s_type: StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES,
53930 p_next: ::std::ptr::null_mut(),
53931 shader_integer_dot_product: Bool32::default(),
53932 }
53933 }
53934}
53935impl PhysicalDeviceShaderIntegerDotProductFeatures {
53936 pub fn builder<'a>() -> PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> {
53937 PhysicalDeviceShaderIntegerDotProductFeaturesBuilder {
53938 inner: Self::default(),
53939 marker: ::std::marker::PhantomData,
53940 }
53941 }
53942}
53943#[repr(transparent)]
53944pub struct PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> {
53945 inner: PhysicalDeviceShaderIntegerDotProductFeatures,
53946 marker: ::std::marker::PhantomData<&'a ()>,
53947}
53948unsafe impl ExtendsPhysicalDeviceFeatures2
53949 for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'_>
53950{
53951}
53952unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderIntegerDotProductFeatures {}
53953unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'_> {}
53954unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerDotProductFeatures {}
53955impl<'a> ::std::ops::Deref for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> {
53956 type Target = PhysicalDeviceShaderIntegerDotProductFeatures;
53957 fn deref(&self) -> &Self::Target {
53958 &self.inner
53959 }
53960}
53961impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> {
53962 fn deref_mut(&mut self) -> &mut Self::Target {
53963 &mut self.inner
53964 }
53965}
53966impl<'a> PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> {
53967 pub fn shader_integer_dot_product(mut self, shader_integer_dot_product: bool) -> Self {
53968 self.inner.shader_integer_dot_product = shader_integer_dot_product.into();
53969 self
53970 }
53971 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53972 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53973 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
53974 pub fn build(self) -> PhysicalDeviceShaderIntegerDotProductFeatures {
53975 self.inner
53976 }
53977}
53978#[repr(C)]
53979#[cfg_attr(feature = "debug", derive(Debug))]
53980#[derive(Copy, Clone)]
53981#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderIntegerDotProductProperties.html>"]
53982pub struct PhysicalDeviceShaderIntegerDotProductProperties {
53983 pub s_type: StructureType,
53984 pub p_next: *mut c_void,
53985 pub integer_dot_product8_bit_unsigned_accelerated: Bool32,
53986 pub integer_dot_product8_bit_signed_accelerated: Bool32,
53987 pub integer_dot_product8_bit_mixed_signedness_accelerated: Bool32,
53988 pub integer_dot_product4x8_bit_packed_unsigned_accelerated: Bool32,
53989 pub integer_dot_product4x8_bit_packed_signed_accelerated: Bool32,
53990 pub integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: Bool32,
53991 pub integer_dot_product16_bit_unsigned_accelerated: Bool32,
53992 pub integer_dot_product16_bit_signed_accelerated: Bool32,
53993 pub integer_dot_product16_bit_mixed_signedness_accelerated: Bool32,
53994 pub integer_dot_product32_bit_unsigned_accelerated: Bool32,
53995 pub integer_dot_product32_bit_signed_accelerated: Bool32,
53996 pub integer_dot_product32_bit_mixed_signedness_accelerated: Bool32,
53997 pub integer_dot_product64_bit_unsigned_accelerated: Bool32,
53998 pub integer_dot_product64_bit_signed_accelerated: Bool32,
53999 pub integer_dot_product64_bit_mixed_signedness_accelerated: Bool32,
54000 pub integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: Bool32,
54001 pub integer_dot_product_accumulating_saturating8_bit_signed_accelerated: Bool32,
54002 pub integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: Bool32,
54003 pub integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: Bool32,
54004 pub integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: Bool32,
54005 pub integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated:
54006 Bool32,
54007 pub integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: Bool32,
54008 pub integer_dot_product_accumulating_saturating16_bit_signed_accelerated: Bool32,
54009 pub integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: Bool32,
54010 pub integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: Bool32,
54011 pub integer_dot_product_accumulating_saturating32_bit_signed_accelerated: Bool32,
54012 pub integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: Bool32,
54013 pub integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: Bool32,
54014 pub integer_dot_product_accumulating_saturating64_bit_signed_accelerated: Bool32,
54015 pub integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: Bool32,
54016}
54017impl ::std::default::Default for PhysicalDeviceShaderIntegerDotProductProperties {
54018 fn default() -> Self {
54019 Self { s_type : StructureType :: PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES , 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 () }
54020 }
54021}
54022impl PhysicalDeviceShaderIntegerDotProductProperties {
54023 pub fn builder<'a>() -> PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> {
54024 PhysicalDeviceShaderIntegerDotProductPropertiesBuilder {
54025 inner: Self::default(),
54026 marker: ::std::marker::PhantomData,
54027 }
54028 }
54029}
54030#[repr(transparent)]
54031pub struct PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> {
54032 inner: PhysicalDeviceShaderIntegerDotProductProperties,
54033 marker: ::std::marker::PhantomData<&'a ()>,
54034}
54035unsafe impl ExtendsPhysicalDeviceProperties2
54036 for PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'_>
54037{
54038}
54039unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderIntegerDotProductProperties {}
54040impl<'a> ::std::ops::Deref for PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> {
54041 type Target = PhysicalDeviceShaderIntegerDotProductProperties;
54042 fn deref(&self) -> &Self::Target {
54043 &self.inner
54044 }
54045}
54046impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> {
54047 fn deref_mut(&mut self) -> &mut Self::Target {
54048 &mut self.inner
54049 }
54050}
54051impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> {
54052 pub fn integer_dot_product8_bit_unsigned_accelerated(
54053 mut self,
54054 integer_dot_product8_bit_unsigned_accelerated: bool,
54055 ) -> Self {
54056 self.inner.integer_dot_product8_bit_unsigned_accelerated =
54057 integer_dot_product8_bit_unsigned_accelerated.into();
54058 self
54059 }
54060 pub fn integer_dot_product8_bit_signed_accelerated(
54061 mut self,
54062 integer_dot_product8_bit_signed_accelerated: bool,
54063 ) -> Self {
54064 self.inner.integer_dot_product8_bit_signed_accelerated =
54065 integer_dot_product8_bit_signed_accelerated.into();
54066 self
54067 }
54068 pub fn integer_dot_product8_bit_mixed_signedness_accelerated(
54069 mut self,
54070 integer_dot_product8_bit_mixed_signedness_accelerated: bool,
54071 ) -> Self {
54072 self.inner
54073 .integer_dot_product8_bit_mixed_signedness_accelerated =
54074 integer_dot_product8_bit_mixed_signedness_accelerated.into();
54075 self
54076 }
54077 pub fn integer_dot_product4x8_bit_packed_unsigned_accelerated(
54078 mut self,
54079 integer_dot_product4x8_bit_packed_unsigned_accelerated: bool,
54080 ) -> Self {
54081 self.inner
54082 .integer_dot_product4x8_bit_packed_unsigned_accelerated =
54083 integer_dot_product4x8_bit_packed_unsigned_accelerated.into();
54084 self
54085 }
54086 pub fn integer_dot_product4x8_bit_packed_signed_accelerated(
54087 mut self,
54088 integer_dot_product4x8_bit_packed_signed_accelerated: bool,
54089 ) -> Self {
54090 self.inner
54091 .integer_dot_product4x8_bit_packed_signed_accelerated =
54092 integer_dot_product4x8_bit_packed_signed_accelerated.into();
54093 self
54094 }
54095 pub fn integer_dot_product4x8_bit_packed_mixed_signedness_accelerated(
54096 mut self,
54097 integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: bool,
54098 ) -> Self {
54099 self.inner
54100 .integer_dot_product4x8_bit_packed_mixed_signedness_accelerated =
54101 integer_dot_product4x8_bit_packed_mixed_signedness_accelerated.into();
54102 self
54103 }
54104 pub fn integer_dot_product16_bit_unsigned_accelerated(
54105 mut self,
54106 integer_dot_product16_bit_unsigned_accelerated: bool,
54107 ) -> Self {
54108 self.inner.integer_dot_product16_bit_unsigned_accelerated =
54109 integer_dot_product16_bit_unsigned_accelerated.into();
54110 self
54111 }
54112 pub fn integer_dot_product16_bit_signed_accelerated(
54113 mut self,
54114 integer_dot_product16_bit_signed_accelerated: bool,
54115 ) -> Self {
54116 self.inner.integer_dot_product16_bit_signed_accelerated =
54117 integer_dot_product16_bit_signed_accelerated.into();
54118 self
54119 }
54120 pub fn integer_dot_product16_bit_mixed_signedness_accelerated(
54121 mut self,
54122 integer_dot_product16_bit_mixed_signedness_accelerated: bool,
54123 ) -> Self {
54124 self.inner
54125 .integer_dot_product16_bit_mixed_signedness_accelerated =
54126 integer_dot_product16_bit_mixed_signedness_accelerated.into();
54127 self
54128 }
54129 pub fn integer_dot_product32_bit_unsigned_accelerated(
54130 mut self,
54131 integer_dot_product32_bit_unsigned_accelerated: bool,
54132 ) -> Self {
54133 self.inner.integer_dot_product32_bit_unsigned_accelerated =
54134 integer_dot_product32_bit_unsigned_accelerated.into();
54135 self
54136 }
54137 pub fn integer_dot_product32_bit_signed_accelerated(
54138 mut self,
54139 integer_dot_product32_bit_signed_accelerated: bool,
54140 ) -> Self {
54141 self.inner.integer_dot_product32_bit_signed_accelerated =
54142 integer_dot_product32_bit_signed_accelerated.into();
54143 self
54144 }
54145 pub fn integer_dot_product32_bit_mixed_signedness_accelerated(
54146 mut self,
54147 integer_dot_product32_bit_mixed_signedness_accelerated: bool,
54148 ) -> Self {
54149 self.inner
54150 .integer_dot_product32_bit_mixed_signedness_accelerated =
54151 integer_dot_product32_bit_mixed_signedness_accelerated.into();
54152 self
54153 }
54154 pub fn integer_dot_product64_bit_unsigned_accelerated(
54155 mut self,
54156 integer_dot_product64_bit_unsigned_accelerated: bool,
54157 ) -> Self {
54158 self.inner.integer_dot_product64_bit_unsigned_accelerated =
54159 integer_dot_product64_bit_unsigned_accelerated.into();
54160 self
54161 }
54162 pub fn integer_dot_product64_bit_signed_accelerated(
54163 mut self,
54164 integer_dot_product64_bit_signed_accelerated: bool,
54165 ) -> Self {
54166 self.inner.integer_dot_product64_bit_signed_accelerated =
54167 integer_dot_product64_bit_signed_accelerated.into();
54168 self
54169 }
54170 pub fn integer_dot_product64_bit_mixed_signedness_accelerated(
54171 mut self,
54172 integer_dot_product64_bit_mixed_signedness_accelerated: bool,
54173 ) -> Self {
54174 self.inner
54175 .integer_dot_product64_bit_mixed_signedness_accelerated =
54176 integer_dot_product64_bit_mixed_signedness_accelerated.into();
54177 self
54178 }
54179 pub fn integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated(
54180 mut self,
54181 integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: bool,
54182 ) -> Self {
54183 self.inner
54184 .integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated =
54185 integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated.into();
54186 self
54187 }
54188 pub fn integer_dot_product_accumulating_saturating8_bit_signed_accelerated(
54189 mut self,
54190 integer_dot_product_accumulating_saturating8_bit_signed_accelerated: bool,
54191 ) -> Self {
54192 self.inner
54193 .integer_dot_product_accumulating_saturating8_bit_signed_accelerated =
54194 integer_dot_product_accumulating_saturating8_bit_signed_accelerated.into();
54195 self
54196 }
54197 pub fn integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated(
54198 mut self,
54199 integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: bool,
54200 ) -> Self {
54201 self.inner
54202 .integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated =
54203 integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated.into();
54204 self
54205 }
54206 pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated(
54207 mut self,
54208 integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: bool,
54209 ) -> Self {
54210 self.inner
54211 .integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated =
54212 integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated.into();
54213 self
54214 }
54215 pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated(
54216 mut self,
54217 integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: bool,
54218 ) -> Self {
54219 self.inner
54220 .integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated =
54221 integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated.into();
54222 self
54223 }
54224 pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated(
54225 mut self,
54226 integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : bool,
54227 ) -> Self {
54228 self . inner . integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated . into () ;
54229 self
54230 }
54231 pub fn integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated(
54232 mut self,
54233 integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: bool,
54234 ) -> Self {
54235 self.inner
54236 .integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated =
54237 integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated.into();
54238 self
54239 }
54240 pub fn integer_dot_product_accumulating_saturating16_bit_signed_accelerated(
54241 mut self,
54242 integer_dot_product_accumulating_saturating16_bit_signed_accelerated: bool,
54243 ) -> Self {
54244 self.inner
54245 .integer_dot_product_accumulating_saturating16_bit_signed_accelerated =
54246 integer_dot_product_accumulating_saturating16_bit_signed_accelerated.into();
54247 self
54248 }
54249 pub fn integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated(
54250 mut self,
54251 integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: bool,
54252 ) -> Self {
54253 self.inner
54254 .integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated =
54255 integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated.into();
54256 self
54257 }
54258 pub fn integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated(
54259 mut self,
54260 integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: bool,
54261 ) -> Self {
54262 self.inner
54263 .integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated =
54264 integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated.into();
54265 self
54266 }
54267 pub fn integer_dot_product_accumulating_saturating32_bit_signed_accelerated(
54268 mut self,
54269 integer_dot_product_accumulating_saturating32_bit_signed_accelerated: bool,
54270 ) -> Self {
54271 self.inner
54272 .integer_dot_product_accumulating_saturating32_bit_signed_accelerated =
54273 integer_dot_product_accumulating_saturating32_bit_signed_accelerated.into();
54274 self
54275 }
54276 pub fn integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated(
54277 mut self,
54278 integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: bool,
54279 ) -> Self {
54280 self.inner
54281 .integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated =
54282 integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated.into();
54283 self
54284 }
54285 pub fn integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated(
54286 mut self,
54287 integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: bool,
54288 ) -> Self {
54289 self.inner
54290 .integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated =
54291 integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated.into();
54292 self
54293 }
54294 pub fn integer_dot_product_accumulating_saturating64_bit_signed_accelerated(
54295 mut self,
54296 integer_dot_product_accumulating_saturating64_bit_signed_accelerated: bool,
54297 ) -> Self {
54298 self.inner
54299 .integer_dot_product_accumulating_saturating64_bit_signed_accelerated =
54300 integer_dot_product_accumulating_saturating64_bit_signed_accelerated.into();
54301 self
54302 }
54303 pub fn integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated(
54304 mut self,
54305 integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: bool,
54306 ) -> Self {
54307 self.inner
54308 .integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated =
54309 integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated.into();
54310 self
54311 }
54312 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54313 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54314 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
54315 pub fn build(self) -> PhysicalDeviceShaderIntegerDotProductProperties {
54316 self.inner
54317 }
54318}
54319#[repr(C)]
54320#[cfg_attr(feature = "debug", derive(Debug))]
54321#[derive(Copy, Clone)]
54322#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDrmPropertiesEXT.html>"]
54323pub struct PhysicalDeviceDrmPropertiesEXT {
54324 pub s_type: StructureType,
54325 pub p_next: *mut c_void,
54326 pub has_primary: Bool32,
54327 pub has_render: Bool32,
54328 pub primary_major: i64,
54329 pub primary_minor: i64,
54330 pub render_major: i64,
54331 pub render_minor: i64,
54332}
54333impl ::std::default::Default for PhysicalDeviceDrmPropertiesEXT {
54334 fn default() -> Self {
54335 Self {
54336 s_type: StructureType::PHYSICAL_DEVICE_DRM_PROPERTIES_EXT,
54337 p_next: ::std::ptr::null_mut(),
54338 has_primary: Bool32::default(),
54339 has_render: Bool32::default(),
54340 primary_major: i64::default(),
54341 primary_minor: i64::default(),
54342 render_major: i64::default(),
54343 render_minor: i64::default(),
54344 }
54345 }
54346}
54347impl PhysicalDeviceDrmPropertiesEXT {
54348 pub fn builder<'a>() -> PhysicalDeviceDrmPropertiesEXTBuilder<'a> {
54349 PhysicalDeviceDrmPropertiesEXTBuilder {
54350 inner: Self::default(),
54351 marker: ::std::marker::PhantomData,
54352 }
54353 }
54354}
54355#[repr(transparent)]
54356pub struct PhysicalDeviceDrmPropertiesEXTBuilder<'a> {
54357 inner: PhysicalDeviceDrmPropertiesEXT,
54358 marker: ::std::marker::PhantomData<&'a ()>,
54359}
54360unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDrmPropertiesEXTBuilder<'_> {}
54361unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDrmPropertiesEXT {}
54362impl<'a> ::std::ops::Deref for PhysicalDeviceDrmPropertiesEXTBuilder<'a> {
54363 type Target = PhysicalDeviceDrmPropertiesEXT;
54364 fn deref(&self) -> &Self::Target {
54365 &self.inner
54366 }
54367}
54368impl<'a> ::std::ops::DerefMut for PhysicalDeviceDrmPropertiesEXTBuilder<'a> {
54369 fn deref_mut(&mut self) -> &mut Self::Target {
54370 &mut self.inner
54371 }
54372}
54373impl<'a> PhysicalDeviceDrmPropertiesEXTBuilder<'a> {
54374 pub fn has_primary(mut self, has_primary: bool) -> Self {
54375 self.inner.has_primary = has_primary.into();
54376 self
54377 }
54378 pub fn has_render(mut self, has_render: bool) -> Self {
54379 self.inner.has_render = has_render.into();
54380 self
54381 }
54382 pub fn primary_major(mut self, primary_major: i64) -> Self {
54383 self.inner.primary_major = primary_major;
54384 self
54385 }
54386 pub fn primary_minor(mut self, primary_minor: i64) -> Self {
54387 self.inner.primary_minor = primary_minor;
54388 self
54389 }
54390 pub fn render_major(mut self, render_major: i64) -> Self {
54391 self.inner.render_major = render_major;
54392 self
54393 }
54394 pub fn render_minor(mut self, render_minor: i64) -> Self {
54395 self.inner.render_minor = render_minor;
54396 self
54397 }
54398 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54399 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54400 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
54401 pub fn build(self) -> PhysicalDeviceDrmPropertiesEXT {
54402 self.inner
54403 }
54404}
54405#[repr(C)]
54406#[cfg_attr(feature = "debug", derive(Debug))]
54407#[derive(Copy, Clone)]
54408#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingMotionBlurFeaturesNV.html>"]
54409pub struct PhysicalDeviceRayTracingMotionBlurFeaturesNV {
54410 pub s_type: StructureType,
54411 pub p_next: *mut c_void,
54412 pub ray_tracing_motion_blur: Bool32,
54413 pub ray_tracing_motion_blur_pipeline_trace_rays_indirect: Bool32,
54414}
54415impl ::std::default::Default for PhysicalDeviceRayTracingMotionBlurFeaturesNV {
54416 fn default() -> Self {
54417 Self {
54418 s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV,
54419 p_next: ::std::ptr::null_mut(),
54420 ray_tracing_motion_blur: Bool32::default(),
54421 ray_tracing_motion_blur_pipeline_trace_rays_indirect: Bool32::default(),
54422 }
54423 }
54424}
54425impl PhysicalDeviceRayTracingMotionBlurFeaturesNV {
54426 pub fn builder<'a>() -> PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> {
54427 PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder {
54428 inner: Self::default(),
54429 marker: ::std::marker::PhantomData,
54430 }
54431 }
54432}
54433#[repr(transparent)]
54434pub struct PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> {
54435 inner: PhysicalDeviceRayTracingMotionBlurFeaturesNV,
54436 marker: ::std::marker::PhantomData<&'a ()>,
54437}
54438unsafe impl ExtendsPhysicalDeviceFeatures2
54439 for PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'_>
54440{
54441}
54442unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingMotionBlurFeaturesNV {}
54443unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'_> {}
54444unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingMotionBlurFeaturesNV {}
54445impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> {
54446 type Target = PhysicalDeviceRayTracingMotionBlurFeaturesNV;
54447 fn deref(&self) -> &Self::Target {
54448 &self.inner
54449 }
54450}
54451impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> {
54452 fn deref_mut(&mut self) -> &mut Self::Target {
54453 &mut self.inner
54454 }
54455}
54456impl<'a> PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> {
54457 pub fn ray_tracing_motion_blur(mut self, ray_tracing_motion_blur: bool) -> Self {
54458 self.inner.ray_tracing_motion_blur = ray_tracing_motion_blur.into();
54459 self
54460 }
54461 pub fn ray_tracing_motion_blur_pipeline_trace_rays_indirect(
54462 mut self,
54463 ray_tracing_motion_blur_pipeline_trace_rays_indirect: bool,
54464 ) -> Self {
54465 self.inner
54466 .ray_tracing_motion_blur_pipeline_trace_rays_indirect =
54467 ray_tracing_motion_blur_pipeline_trace_rays_indirect.into();
54468 self
54469 }
54470 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54471 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54472 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
54473 pub fn build(self) -> PhysicalDeviceRayTracingMotionBlurFeaturesNV {
54474 self.inner
54475 }
54476}
54477#[repr(C)]
54478#[derive(Copy, Clone)]
54479#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryMotionTrianglesDataNV.html>"]
54480pub struct AccelerationStructureGeometryMotionTrianglesDataNV {
54481 pub s_type: StructureType,
54482 pub p_next: *const c_void,
54483 pub vertex_data: DeviceOrHostAddressConstKHR,
54484}
54485#[cfg(feature = "debug")]
54486impl fmt::Debug for AccelerationStructureGeometryMotionTrianglesDataNV {
54487 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
54488 fmt.debug_struct("AccelerationStructureGeometryMotionTrianglesDataNV")
54489 .field("s_type", &self.s_type)
54490 .field("p_next", &self.p_next)
54491 .field("vertex_data", &"union")
54492 .finish()
54493 }
54494}
54495impl ::std::default::Default for AccelerationStructureGeometryMotionTrianglesDataNV {
54496 fn default() -> Self {
54497 Self {
54498 s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV,
54499 p_next: ::std::ptr::null(),
54500 vertex_data: DeviceOrHostAddressConstKHR::default(),
54501 }
54502 }
54503}
54504impl AccelerationStructureGeometryMotionTrianglesDataNV {
54505 pub fn builder<'a>() -> AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> {
54506 AccelerationStructureGeometryMotionTrianglesDataNVBuilder {
54507 inner: Self::default(),
54508 marker: ::std::marker::PhantomData,
54509 }
54510 }
54511}
54512#[repr(transparent)]
54513pub struct AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> {
54514 inner: AccelerationStructureGeometryMotionTrianglesDataNV,
54515 marker: ::std::marker::PhantomData<&'a ()>,
54516}
54517unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR
54518 for AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'_>
54519{
54520}
54521unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR
54522 for AccelerationStructureGeometryMotionTrianglesDataNV
54523{
54524}
54525impl<'a> ::std::ops::Deref for AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> {
54526 type Target = AccelerationStructureGeometryMotionTrianglesDataNV;
54527 fn deref(&self) -> &Self::Target {
54528 &self.inner
54529 }
54530}
54531impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> {
54532 fn deref_mut(&mut self) -> &mut Self::Target {
54533 &mut self.inner
54534 }
54535}
54536impl<'a> AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> {
54537 pub fn vertex_data(mut self, vertex_data: DeviceOrHostAddressConstKHR) -> Self {
54538 self.inner.vertex_data = vertex_data;
54539 self
54540 }
54541 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54542 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54543 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
54544 pub fn build(self) -> AccelerationStructureGeometryMotionTrianglesDataNV {
54545 self.inner
54546 }
54547}
54548#[repr(C)]
54549#[cfg_attr(feature = "debug", derive(Debug))]
54550#[derive(Copy, Clone)]
54551#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMotionInfoNV.html>"]
54552pub struct AccelerationStructureMotionInfoNV {
54553 pub s_type: StructureType,
54554 pub p_next: *const c_void,
54555 pub max_instances: u32,
54556 pub flags: AccelerationStructureMotionInfoFlagsNV,
54557}
54558impl ::std::default::Default for AccelerationStructureMotionInfoNV {
54559 fn default() -> Self {
54560 Self {
54561 s_type: StructureType::ACCELERATION_STRUCTURE_MOTION_INFO_NV,
54562 p_next: ::std::ptr::null(),
54563 max_instances: u32::default(),
54564 flags: AccelerationStructureMotionInfoFlagsNV::default(),
54565 }
54566 }
54567}
54568impl AccelerationStructureMotionInfoNV {
54569 pub fn builder<'a>() -> AccelerationStructureMotionInfoNVBuilder<'a> {
54570 AccelerationStructureMotionInfoNVBuilder {
54571 inner: Self::default(),
54572 marker: ::std::marker::PhantomData,
54573 }
54574 }
54575}
54576#[repr(transparent)]
54577pub struct AccelerationStructureMotionInfoNVBuilder<'a> {
54578 inner: AccelerationStructureMotionInfoNV,
54579 marker: ::std::marker::PhantomData<&'a ()>,
54580}
54581unsafe impl ExtendsAccelerationStructureCreateInfoKHR
54582 for AccelerationStructureMotionInfoNVBuilder<'_>
54583{
54584}
54585unsafe impl ExtendsAccelerationStructureCreateInfoKHR for AccelerationStructureMotionInfoNV {}
54586impl<'a> ::std::ops::Deref for AccelerationStructureMotionInfoNVBuilder<'a> {
54587 type Target = AccelerationStructureMotionInfoNV;
54588 fn deref(&self) -> &Self::Target {
54589 &self.inner
54590 }
54591}
54592impl<'a> ::std::ops::DerefMut for AccelerationStructureMotionInfoNVBuilder<'a> {
54593 fn deref_mut(&mut self) -> &mut Self::Target {
54594 &mut self.inner
54595 }
54596}
54597impl<'a> AccelerationStructureMotionInfoNVBuilder<'a> {
54598 pub fn max_instances(mut self, max_instances: u32) -> Self {
54599 self.inner.max_instances = max_instances;
54600 self
54601 }
54602 pub fn flags(mut self, flags: AccelerationStructureMotionInfoFlagsNV) -> Self {
54603 self.inner.flags = flags;
54604 self
54605 }
54606 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54607 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54608 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
54609 pub fn build(self) -> AccelerationStructureMotionInfoNV {
54610 self.inner
54611 }
54612}
54613#[repr(C)]
54614#[cfg_attr(feature = "debug", derive(Debug))]
54615#[derive(Copy, Clone, Default)]
54616#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSRTDataNV.html>"]
54617pub struct SRTDataNV {
54618 pub sx: f32,
54619 pub a: f32,
54620 pub b: f32,
54621 pub pvx: f32,
54622 pub sy: f32,
54623 pub c: f32,
54624 pub pvy: f32,
54625 pub sz: f32,
54626 pub pvz: f32,
54627 pub qx: f32,
54628 pub qy: f32,
54629 pub qz: f32,
54630 pub qw: f32,
54631 pub tx: f32,
54632 pub ty: f32,
54633 pub tz: f32,
54634}
54635impl SRTDataNV {
54636 pub fn builder<'a>() -> SRTDataNVBuilder<'a> {
54637 SRTDataNVBuilder {
54638 inner: Self::default(),
54639 marker: ::std::marker::PhantomData,
54640 }
54641 }
54642}
54643#[repr(transparent)]
54644pub struct SRTDataNVBuilder<'a> {
54645 inner: SRTDataNV,
54646 marker: ::std::marker::PhantomData<&'a ()>,
54647}
54648impl<'a> ::std::ops::Deref for SRTDataNVBuilder<'a> {
54649 type Target = SRTDataNV;
54650 fn deref(&self) -> &Self::Target {
54651 &self.inner
54652 }
54653}
54654impl<'a> ::std::ops::DerefMut for SRTDataNVBuilder<'a> {
54655 fn deref_mut(&mut self) -> &mut Self::Target {
54656 &mut self.inner
54657 }
54658}
54659impl<'a> SRTDataNVBuilder<'a> {
54660 pub fn sx(mut self, sx: f32) -> Self {
54661 self.inner.sx = sx;
54662 self
54663 }
54664 pub fn a(mut self, a: f32) -> Self {
54665 self.inner.a = a;
54666 self
54667 }
54668 pub fn b(mut self, b: f32) -> Self {
54669 self.inner.b = b;
54670 self
54671 }
54672 pub fn pvx(mut self, pvx: f32) -> Self {
54673 self.inner.pvx = pvx;
54674 self
54675 }
54676 pub fn sy(mut self, sy: f32) -> Self {
54677 self.inner.sy = sy;
54678 self
54679 }
54680 pub fn c(mut self, c: f32) -> Self {
54681 self.inner.c = c;
54682 self
54683 }
54684 pub fn pvy(mut self, pvy: f32) -> Self {
54685 self.inner.pvy = pvy;
54686 self
54687 }
54688 pub fn sz(mut self, sz: f32) -> Self {
54689 self.inner.sz = sz;
54690 self
54691 }
54692 pub fn pvz(mut self, pvz: f32) -> Self {
54693 self.inner.pvz = pvz;
54694 self
54695 }
54696 pub fn qx(mut self, qx: f32) -> Self {
54697 self.inner.qx = qx;
54698 self
54699 }
54700 pub fn qy(mut self, qy: f32) -> Self {
54701 self.inner.qy = qy;
54702 self
54703 }
54704 pub fn qz(mut self, qz: f32) -> Self {
54705 self.inner.qz = qz;
54706 self
54707 }
54708 pub fn qw(mut self, qw: f32) -> Self {
54709 self.inner.qw = qw;
54710 self
54711 }
54712 pub fn tx(mut self, tx: f32) -> Self {
54713 self.inner.tx = tx;
54714 self
54715 }
54716 pub fn ty(mut self, ty: f32) -> Self {
54717 self.inner.ty = ty;
54718 self
54719 }
54720 pub fn tz(mut self, tz: f32) -> Self {
54721 self.inner.tz = tz;
54722 self
54723 }
54724 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54725 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54726 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
54727 pub fn build(self) -> SRTDataNV {
54728 self.inner
54729 }
54730}
54731#[repr(C)]
54732#[derive(Copy, Clone)]
54733#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureSRTMotionInstanceNV.html>"]
54734pub struct AccelerationStructureSRTMotionInstanceNV {
54735 pub transform_t0: SRTDataNV,
54736 pub transform_t1: SRTDataNV,
54737 #[doc = r" Use [`Packed24_8::new(instance_custom_index, mask)`][Packed24_8::new()] to construct this field"]
54738 pub instance_custom_index_and_mask: Packed24_8,
54739 #[doc = r" Use [`Packed24_8::new(instance_shader_binding_table_record_offset, flags)`][Packed24_8::new()] to construct this field"]
54740 pub instance_shader_binding_table_record_offset_and_flags: Packed24_8,
54741 pub acceleration_structure_reference: AccelerationStructureReferenceKHR,
54742}
54743#[repr(C)]
54744#[derive(Copy, Clone)]
54745#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/AccelerationStructureMatrixMotionInstanceNV.html>"]
54746pub struct AccelerationStructureMatrixMotionInstanceNV {
54747 pub transform_t0: TransformMatrixKHR,
54748 pub transform_t1: TransformMatrixKHR,
54749 #[doc = r" Use [`Packed24_8::new(instance_custom_index, mask)`][Packed24_8::new()] to construct this field"]
54750 pub instance_custom_index_and_mask: Packed24_8,
54751 #[doc = r" Use [`Packed24_8::new(instance_shader_binding_table_record_offset, flags)`][Packed24_8::new()] to construct this field"]
54752 pub instance_shader_binding_table_record_offset_and_flags: Packed24_8,
54753 pub acceleration_structure_reference: AccelerationStructureReferenceKHR,
54754}
54755#[repr(C)]
54756#[derive(Copy, Clone)]
54757#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMotionInstanceDataNV.html>"]
54758pub union AccelerationStructureMotionInstanceDataNV {
54759 pub static_instance: AccelerationStructureInstanceKHR,
54760 pub matrix_motion_instance: AccelerationStructureMatrixMotionInstanceNV,
54761 pub srt_motion_instance: AccelerationStructureSRTMotionInstanceNV,
54762}
54763impl ::std::default::Default for AccelerationStructureMotionInstanceDataNV {
54764 fn default() -> Self {
54765 unsafe { ::std::mem::zeroed() }
54766 }
54767}
54768#[repr(C)]
54769#[derive(Copy, Clone, Default)]
54770#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMotionInstanceNV.html>"]
54771pub struct AccelerationStructureMotionInstanceNV {
54772 pub ty: AccelerationStructureMotionInstanceTypeNV,
54773 pub flags: AccelerationStructureMotionInstanceFlagsNV,
54774 pub data: AccelerationStructureMotionInstanceDataNV,
54775}
54776#[cfg(feature = "debug")]
54777impl fmt::Debug for AccelerationStructureMotionInstanceNV {
54778 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
54779 fmt.debug_struct("AccelerationStructureMotionInstanceNV")
54780 .field("ty", &self.ty)
54781 .field("flags", &self.flags)
54782 .field("data", &"union")
54783 .finish()
54784 }
54785}
54786impl AccelerationStructureMotionInstanceNV {
54787 pub fn builder<'a>() -> AccelerationStructureMotionInstanceNVBuilder<'a> {
54788 AccelerationStructureMotionInstanceNVBuilder {
54789 inner: Self::default(),
54790 marker: ::std::marker::PhantomData,
54791 }
54792 }
54793}
54794#[repr(transparent)]
54795pub struct AccelerationStructureMotionInstanceNVBuilder<'a> {
54796 inner: AccelerationStructureMotionInstanceNV,
54797 marker: ::std::marker::PhantomData<&'a ()>,
54798}
54799impl<'a> ::std::ops::Deref for AccelerationStructureMotionInstanceNVBuilder<'a> {
54800 type Target = AccelerationStructureMotionInstanceNV;
54801 fn deref(&self) -> &Self::Target {
54802 &self.inner
54803 }
54804}
54805impl<'a> ::std::ops::DerefMut for AccelerationStructureMotionInstanceNVBuilder<'a> {
54806 fn deref_mut(&mut self) -> &mut Self::Target {
54807 &mut self.inner
54808 }
54809}
54810impl<'a> AccelerationStructureMotionInstanceNVBuilder<'a> {
54811 pub fn ty(mut self, ty: AccelerationStructureMotionInstanceTypeNV) -> Self {
54812 self.inner.ty = ty;
54813 self
54814 }
54815 pub fn flags(mut self, flags: AccelerationStructureMotionInstanceFlagsNV) -> Self {
54816 self.inner.flags = flags;
54817 self
54818 }
54819 pub fn data(mut self, data: AccelerationStructureMotionInstanceDataNV) -> Self {
54820 self.inner.data = data;
54821 self
54822 }
54823 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54824 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54825 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
54826 pub fn build(self) -> AccelerationStructureMotionInstanceNV {
54827 self.inner
54828 }
54829}
54830#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRemoteAddressNV.html>"]
54831pub type RemoteAddressNV = c_void;
54832#[repr(C)]
54833#[cfg_attr(feature = "debug", derive(Debug))]
54834#[derive(Copy, Clone)]
54835#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryGetRemoteAddressInfoNV.html>"]
54836pub struct MemoryGetRemoteAddressInfoNV {
54837 pub s_type: StructureType,
54838 pub p_next: *const c_void,
54839 pub memory: DeviceMemory,
54840 pub handle_type: ExternalMemoryHandleTypeFlags,
54841}
54842impl ::std::default::Default for MemoryGetRemoteAddressInfoNV {
54843 fn default() -> Self {
54844 Self {
54845 s_type: StructureType::MEMORY_GET_REMOTE_ADDRESS_INFO_NV,
54846 p_next: ::std::ptr::null(),
54847 memory: DeviceMemory::default(),
54848 handle_type: ExternalMemoryHandleTypeFlags::default(),
54849 }
54850 }
54851}
54852impl MemoryGetRemoteAddressInfoNV {
54853 pub fn builder<'a>() -> MemoryGetRemoteAddressInfoNVBuilder<'a> {
54854 MemoryGetRemoteAddressInfoNVBuilder {
54855 inner: Self::default(),
54856 marker: ::std::marker::PhantomData,
54857 }
54858 }
54859}
54860#[repr(transparent)]
54861pub struct MemoryGetRemoteAddressInfoNVBuilder<'a> {
54862 inner: MemoryGetRemoteAddressInfoNV,
54863 marker: ::std::marker::PhantomData<&'a ()>,
54864}
54865impl<'a> ::std::ops::Deref for MemoryGetRemoteAddressInfoNVBuilder<'a> {
54866 type Target = MemoryGetRemoteAddressInfoNV;
54867 fn deref(&self) -> &Self::Target {
54868 &self.inner
54869 }
54870}
54871impl<'a> ::std::ops::DerefMut for MemoryGetRemoteAddressInfoNVBuilder<'a> {
54872 fn deref_mut(&mut self) -> &mut Self::Target {
54873 &mut self.inner
54874 }
54875}
54876impl<'a> MemoryGetRemoteAddressInfoNVBuilder<'a> {
54877 pub fn memory(mut self, memory: DeviceMemory) -> Self {
54878 self.inner.memory = memory;
54879 self
54880 }
54881 pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
54882 self.inner.handle_type = handle_type;
54883 self
54884 }
54885 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54886 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54887 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
54888 pub fn build(self) -> MemoryGetRemoteAddressInfoNV {
54889 self.inner
54890 }
54891}
54892#[repr(C)]
54893#[cfg_attr(feature = "debug", derive(Debug))]
54894#[derive(Copy, Clone)]
54895#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMemoryBufferCollectionFUCHSIA.html>"]
54896pub struct ImportMemoryBufferCollectionFUCHSIA {
54897 pub s_type: StructureType,
54898 pub p_next: *const c_void,
54899 pub collection: BufferCollectionFUCHSIA,
54900 pub index: u32,
54901}
54902impl ::std::default::Default for ImportMemoryBufferCollectionFUCHSIA {
54903 fn default() -> Self {
54904 Self {
54905 s_type: StructureType::IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA,
54906 p_next: ::std::ptr::null(),
54907 collection: BufferCollectionFUCHSIA::default(),
54908 index: u32::default(),
54909 }
54910 }
54911}
54912impl ImportMemoryBufferCollectionFUCHSIA {
54913 pub fn builder<'a>() -> ImportMemoryBufferCollectionFUCHSIABuilder<'a> {
54914 ImportMemoryBufferCollectionFUCHSIABuilder {
54915 inner: Self::default(),
54916 marker: ::std::marker::PhantomData,
54917 }
54918 }
54919}
54920#[repr(transparent)]
54921pub struct ImportMemoryBufferCollectionFUCHSIABuilder<'a> {
54922 inner: ImportMemoryBufferCollectionFUCHSIA,
54923 marker: ::std::marker::PhantomData<&'a ()>,
54924}
54925unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryBufferCollectionFUCHSIABuilder<'_> {}
54926unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryBufferCollectionFUCHSIA {}
54927impl<'a> ::std::ops::Deref for ImportMemoryBufferCollectionFUCHSIABuilder<'a> {
54928 type Target = ImportMemoryBufferCollectionFUCHSIA;
54929 fn deref(&self) -> &Self::Target {
54930 &self.inner
54931 }
54932}
54933impl<'a> ::std::ops::DerefMut for ImportMemoryBufferCollectionFUCHSIABuilder<'a> {
54934 fn deref_mut(&mut self) -> &mut Self::Target {
54935 &mut self.inner
54936 }
54937}
54938impl<'a> ImportMemoryBufferCollectionFUCHSIABuilder<'a> {
54939 pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self {
54940 self.inner.collection = collection;
54941 self
54942 }
54943 pub fn index(mut self, index: u32) -> Self {
54944 self.inner.index = index;
54945 self
54946 }
54947 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54948 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54949 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
54950 pub fn build(self) -> ImportMemoryBufferCollectionFUCHSIA {
54951 self.inner
54952 }
54953}
54954#[repr(C)]
54955#[cfg_attr(feature = "debug", derive(Debug))]
54956#[derive(Copy, Clone)]
54957#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCollectionImageCreateInfoFUCHSIA.html>"]
54958pub struct BufferCollectionImageCreateInfoFUCHSIA {
54959 pub s_type: StructureType,
54960 pub p_next: *const c_void,
54961 pub collection: BufferCollectionFUCHSIA,
54962 pub index: u32,
54963}
54964impl ::std::default::Default for BufferCollectionImageCreateInfoFUCHSIA {
54965 fn default() -> Self {
54966 Self {
54967 s_type: StructureType::BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA,
54968 p_next: ::std::ptr::null(),
54969 collection: BufferCollectionFUCHSIA::default(),
54970 index: u32::default(),
54971 }
54972 }
54973}
54974impl BufferCollectionImageCreateInfoFUCHSIA {
54975 pub fn builder<'a>() -> BufferCollectionImageCreateInfoFUCHSIABuilder<'a> {
54976 BufferCollectionImageCreateInfoFUCHSIABuilder {
54977 inner: Self::default(),
54978 marker: ::std::marker::PhantomData,
54979 }
54980 }
54981}
54982#[repr(transparent)]
54983pub struct BufferCollectionImageCreateInfoFUCHSIABuilder<'a> {
54984 inner: BufferCollectionImageCreateInfoFUCHSIA,
54985 marker: ::std::marker::PhantomData<&'a ()>,
54986}
54987unsafe impl ExtendsImageCreateInfo for BufferCollectionImageCreateInfoFUCHSIABuilder<'_> {}
54988unsafe impl ExtendsImageCreateInfo for BufferCollectionImageCreateInfoFUCHSIA {}
54989impl<'a> ::std::ops::Deref for BufferCollectionImageCreateInfoFUCHSIABuilder<'a> {
54990 type Target = BufferCollectionImageCreateInfoFUCHSIA;
54991 fn deref(&self) -> &Self::Target {
54992 &self.inner
54993 }
54994}
54995impl<'a> ::std::ops::DerefMut for BufferCollectionImageCreateInfoFUCHSIABuilder<'a> {
54996 fn deref_mut(&mut self) -> &mut Self::Target {
54997 &mut self.inner
54998 }
54999}
55000impl<'a> BufferCollectionImageCreateInfoFUCHSIABuilder<'a> {
55001 pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self {
55002 self.inner.collection = collection;
55003 self
55004 }
55005 pub fn index(mut self, index: u32) -> Self {
55006 self.inner.index = index;
55007 self
55008 }
55009 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55010 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55011 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
55012 pub fn build(self) -> BufferCollectionImageCreateInfoFUCHSIA {
55013 self.inner
55014 }
55015}
55016#[repr(C)]
55017#[cfg_attr(feature = "debug", derive(Debug))]
55018#[derive(Copy, Clone)]
55019#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCollectionBufferCreateInfoFUCHSIA.html>"]
55020pub struct BufferCollectionBufferCreateInfoFUCHSIA {
55021 pub s_type: StructureType,
55022 pub p_next: *const c_void,
55023 pub collection: BufferCollectionFUCHSIA,
55024 pub index: u32,
55025}
55026impl ::std::default::Default for BufferCollectionBufferCreateInfoFUCHSIA {
55027 fn default() -> Self {
55028 Self {
55029 s_type: StructureType::BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA,
55030 p_next: ::std::ptr::null(),
55031 collection: BufferCollectionFUCHSIA::default(),
55032 index: u32::default(),
55033 }
55034 }
55035}
55036impl BufferCollectionBufferCreateInfoFUCHSIA {
55037 pub fn builder<'a>() -> BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> {
55038 BufferCollectionBufferCreateInfoFUCHSIABuilder {
55039 inner: Self::default(),
55040 marker: ::std::marker::PhantomData,
55041 }
55042 }
55043}
55044#[repr(transparent)]
55045pub struct BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> {
55046 inner: BufferCollectionBufferCreateInfoFUCHSIA,
55047 marker: ::std::marker::PhantomData<&'a ()>,
55048}
55049unsafe impl ExtendsBufferCreateInfo for BufferCollectionBufferCreateInfoFUCHSIABuilder<'_> {}
55050unsafe impl ExtendsBufferCreateInfo for BufferCollectionBufferCreateInfoFUCHSIA {}
55051impl<'a> ::std::ops::Deref for BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> {
55052 type Target = BufferCollectionBufferCreateInfoFUCHSIA;
55053 fn deref(&self) -> &Self::Target {
55054 &self.inner
55055 }
55056}
55057impl<'a> ::std::ops::DerefMut for BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> {
55058 fn deref_mut(&mut self) -> &mut Self::Target {
55059 &mut self.inner
55060 }
55061}
55062impl<'a> BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> {
55063 pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self {
55064 self.inner.collection = collection;
55065 self
55066 }
55067 pub fn index(mut self, index: u32) -> Self {
55068 self.inner.index = index;
55069 self
55070 }
55071 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55072 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55073 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
55074 pub fn build(self) -> BufferCollectionBufferCreateInfoFUCHSIA {
55075 self.inner
55076 }
55077}
55078#[repr(C)]
55079#[cfg_attr(feature = "debug", derive(Debug))]
55080#[derive(Copy, Clone)]
55081#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCollectionCreateInfoFUCHSIA.html>"]
55082pub struct BufferCollectionCreateInfoFUCHSIA {
55083 pub s_type: StructureType,
55084 pub p_next: *const c_void,
55085 pub collection_token: zx_handle_t,
55086}
55087impl ::std::default::Default for BufferCollectionCreateInfoFUCHSIA {
55088 fn default() -> Self {
55089 Self {
55090 s_type: StructureType::BUFFER_COLLECTION_CREATE_INFO_FUCHSIA,
55091 p_next: ::std::ptr::null(),
55092 collection_token: zx_handle_t::default(),
55093 }
55094 }
55095}
55096impl BufferCollectionCreateInfoFUCHSIA {
55097 pub fn builder<'a>() -> BufferCollectionCreateInfoFUCHSIABuilder<'a> {
55098 BufferCollectionCreateInfoFUCHSIABuilder {
55099 inner: Self::default(),
55100 marker: ::std::marker::PhantomData,
55101 }
55102 }
55103}
55104#[repr(transparent)]
55105pub struct BufferCollectionCreateInfoFUCHSIABuilder<'a> {
55106 inner: BufferCollectionCreateInfoFUCHSIA,
55107 marker: ::std::marker::PhantomData<&'a ()>,
55108}
55109impl<'a> ::std::ops::Deref for BufferCollectionCreateInfoFUCHSIABuilder<'a> {
55110 type Target = BufferCollectionCreateInfoFUCHSIA;
55111 fn deref(&self) -> &Self::Target {
55112 &self.inner
55113 }
55114}
55115impl<'a> ::std::ops::DerefMut for BufferCollectionCreateInfoFUCHSIABuilder<'a> {
55116 fn deref_mut(&mut self) -> &mut Self::Target {
55117 &mut self.inner
55118 }
55119}
55120impl<'a> BufferCollectionCreateInfoFUCHSIABuilder<'a> {
55121 pub fn collection_token(mut self, collection_token: zx_handle_t) -> Self {
55122 self.inner.collection_token = collection_token;
55123 self
55124 }
55125 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55126 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55127 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
55128 pub fn build(self) -> BufferCollectionCreateInfoFUCHSIA {
55129 self.inner
55130 }
55131}
55132#[repr(C)]
55133#[cfg_attr(feature = "debug", derive(Debug))]
55134#[derive(Copy, Clone)]
55135#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCollectionPropertiesFUCHSIA.html>"]
55136pub struct BufferCollectionPropertiesFUCHSIA {
55137 pub s_type: StructureType,
55138 pub p_next: *mut c_void,
55139 pub memory_type_bits: u32,
55140 pub buffer_count: u32,
55141 pub create_info_index: u32,
55142 pub sysmem_pixel_format: u64,
55143 pub format_features: FormatFeatureFlags,
55144 pub sysmem_color_space_index: SysmemColorSpaceFUCHSIA,
55145 pub sampler_ycbcr_conversion_components: ComponentMapping,
55146 pub suggested_ycbcr_model: SamplerYcbcrModelConversion,
55147 pub suggested_ycbcr_range: SamplerYcbcrRange,
55148 pub suggested_x_chroma_offset: ChromaLocation,
55149 pub suggested_y_chroma_offset: ChromaLocation,
55150}
55151impl ::std::default::Default for BufferCollectionPropertiesFUCHSIA {
55152 fn default() -> Self {
55153 Self {
55154 s_type: StructureType::BUFFER_COLLECTION_PROPERTIES_FUCHSIA,
55155 p_next: ::std::ptr::null_mut(),
55156 memory_type_bits: u32::default(),
55157 buffer_count: u32::default(),
55158 create_info_index: u32::default(),
55159 sysmem_pixel_format: u64::default(),
55160 format_features: FormatFeatureFlags::default(),
55161 sysmem_color_space_index: SysmemColorSpaceFUCHSIA::default(),
55162 sampler_ycbcr_conversion_components: ComponentMapping::default(),
55163 suggested_ycbcr_model: SamplerYcbcrModelConversion::default(),
55164 suggested_ycbcr_range: SamplerYcbcrRange::default(),
55165 suggested_x_chroma_offset: ChromaLocation::default(),
55166 suggested_y_chroma_offset: ChromaLocation::default(),
55167 }
55168 }
55169}
55170impl BufferCollectionPropertiesFUCHSIA {
55171 pub fn builder<'a>() -> BufferCollectionPropertiesFUCHSIABuilder<'a> {
55172 BufferCollectionPropertiesFUCHSIABuilder {
55173 inner: Self::default(),
55174 marker: ::std::marker::PhantomData,
55175 }
55176 }
55177}
55178#[repr(transparent)]
55179pub struct BufferCollectionPropertiesFUCHSIABuilder<'a> {
55180 inner: BufferCollectionPropertiesFUCHSIA,
55181 marker: ::std::marker::PhantomData<&'a ()>,
55182}
55183impl<'a> ::std::ops::Deref for BufferCollectionPropertiesFUCHSIABuilder<'a> {
55184 type Target = BufferCollectionPropertiesFUCHSIA;
55185 fn deref(&self) -> &Self::Target {
55186 &self.inner
55187 }
55188}
55189impl<'a> ::std::ops::DerefMut for BufferCollectionPropertiesFUCHSIABuilder<'a> {
55190 fn deref_mut(&mut self) -> &mut Self::Target {
55191 &mut self.inner
55192 }
55193}
55194impl<'a> BufferCollectionPropertiesFUCHSIABuilder<'a> {
55195 pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self {
55196 self.inner.memory_type_bits = memory_type_bits;
55197 self
55198 }
55199 pub fn buffer_count(mut self, buffer_count: u32) -> Self {
55200 self.inner.buffer_count = buffer_count;
55201 self
55202 }
55203 pub fn create_info_index(mut self, create_info_index: u32) -> Self {
55204 self.inner.create_info_index = create_info_index;
55205 self
55206 }
55207 pub fn sysmem_pixel_format(mut self, sysmem_pixel_format: u64) -> Self {
55208 self.inner.sysmem_pixel_format = sysmem_pixel_format;
55209 self
55210 }
55211 pub fn format_features(mut self, format_features: FormatFeatureFlags) -> Self {
55212 self.inner.format_features = format_features;
55213 self
55214 }
55215 pub fn sysmem_color_space_index(
55216 mut self,
55217 sysmem_color_space_index: SysmemColorSpaceFUCHSIA,
55218 ) -> Self {
55219 self.inner.sysmem_color_space_index = sysmem_color_space_index;
55220 self
55221 }
55222 pub fn sampler_ycbcr_conversion_components(
55223 mut self,
55224 sampler_ycbcr_conversion_components: ComponentMapping,
55225 ) -> Self {
55226 self.inner.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components;
55227 self
55228 }
55229 pub fn suggested_ycbcr_model(
55230 mut self,
55231 suggested_ycbcr_model: SamplerYcbcrModelConversion,
55232 ) -> Self {
55233 self.inner.suggested_ycbcr_model = suggested_ycbcr_model;
55234 self
55235 }
55236 pub fn suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self {
55237 self.inner.suggested_ycbcr_range = suggested_ycbcr_range;
55238 self
55239 }
55240 pub fn suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self {
55241 self.inner.suggested_x_chroma_offset = suggested_x_chroma_offset;
55242 self
55243 }
55244 pub fn suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self {
55245 self.inner.suggested_y_chroma_offset = suggested_y_chroma_offset;
55246 self
55247 }
55248 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55249 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55250 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
55251 pub fn build(self) -> BufferCollectionPropertiesFUCHSIA {
55252 self.inner
55253 }
55254}
55255#[repr(C)]
55256#[cfg_attr(feature = "debug", derive(Debug))]
55257#[derive(Copy, Clone)]
55258#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferConstraintsInfoFUCHSIA.html>"]
55259pub struct BufferConstraintsInfoFUCHSIA {
55260 pub s_type: StructureType,
55261 pub p_next: *const c_void,
55262 pub create_info: BufferCreateInfo,
55263 pub required_format_features: FormatFeatureFlags,
55264 pub buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA,
55265}
55266impl ::std::default::Default for BufferConstraintsInfoFUCHSIA {
55267 fn default() -> Self {
55268 Self {
55269 s_type: StructureType::BUFFER_CONSTRAINTS_INFO_FUCHSIA,
55270 p_next: ::std::ptr::null(),
55271 create_info: BufferCreateInfo::default(),
55272 required_format_features: FormatFeatureFlags::default(),
55273 buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA::default(),
55274 }
55275 }
55276}
55277impl BufferConstraintsInfoFUCHSIA {
55278 pub fn builder<'a>() -> BufferConstraintsInfoFUCHSIABuilder<'a> {
55279 BufferConstraintsInfoFUCHSIABuilder {
55280 inner: Self::default(),
55281 marker: ::std::marker::PhantomData,
55282 }
55283 }
55284}
55285#[repr(transparent)]
55286pub struct BufferConstraintsInfoFUCHSIABuilder<'a> {
55287 inner: BufferConstraintsInfoFUCHSIA,
55288 marker: ::std::marker::PhantomData<&'a ()>,
55289}
55290impl<'a> ::std::ops::Deref for BufferConstraintsInfoFUCHSIABuilder<'a> {
55291 type Target = BufferConstraintsInfoFUCHSIA;
55292 fn deref(&self) -> &Self::Target {
55293 &self.inner
55294 }
55295}
55296impl<'a> ::std::ops::DerefMut for BufferConstraintsInfoFUCHSIABuilder<'a> {
55297 fn deref_mut(&mut self) -> &mut Self::Target {
55298 &mut self.inner
55299 }
55300}
55301impl<'a> BufferConstraintsInfoFUCHSIABuilder<'a> {
55302 pub fn create_info(mut self, create_info: BufferCreateInfo) -> Self {
55303 self.inner.create_info = create_info;
55304 self
55305 }
55306 pub fn required_format_features(
55307 mut self,
55308 required_format_features: FormatFeatureFlags,
55309 ) -> Self {
55310 self.inner.required_format_features = required_format_features;
55311 self
55312 }
55313 pub fn buffer_collection_constraints(
55314 mut self,
55315 buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA,
55316 ) -> Self {
55317 self.inner.buffer_collection_constraints = buffer_collection_constraints;
55318 self
55319 }
55320 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55321 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55322 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
55323 pub fn build(self) -> BufferConstraintsInfoFUCHSIA {
55324 self.inner
55325 }
55326}
55327#[repr(C)]
55328#[cfg_attr(feature = "debug", derive(Debug))]
55329#[derive(Copy, Clone)]
55330#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSysmemColorSpaceFUCHSIA.html>"]
55331pub struct SysmemColorSpaceFUCHSIA {
55332 pub s_type: StructureType,
55333 pub p_next: *const c_void,
55334 pub color_space: u32,
55335}
55336impl ::std::default::Default for SysmemColorSpaceFUCHSIA {
55337 fn default() -> Self {
55338 Self {
55339 s_type: StructureType::SYSMEM_COLOR_SPACE_FUCHSIA,
55340 p_next: ::std::ptr::null(),
55341 color_space: u32::default(),
55342 }
55343 }
55344}
55345impl SysmemColorSpaceFUCHSIA {
55346 pub fn builder<'a>() -> SysmemColorSpaceFUCHSIABuilder<'a> {
55347 SysmemColorSpaceFUCHSIABuilder {
55348 inner: Self::default(),
55349 marker: ::std::marker::PhantomData,
55350 }
55351 }
55352}
55353#[repr(transparent)]
55354pub struct SysmemColorSpaceFUCHSIABuilder<'a> {
55355 inner: SysmemColorSpaceFUCHSIA,
55356 marker: ::std::marker::PhantomData<&'a ()>,
55357}
55358impl<'a> ::std::ops::Deref for SysmemColorSpaceFUCHSIABuilder<'a> {
55359 type Target = SysmemColorSpaceFUCHSIA;
55360 fn deref(&self) -> &Self::Target {
55361 &self.inner
55362 }
55363}
55364impl<'a> ::std::ops::DerefMut for SysmemColorSpaceFUCHSIABuilder<'a> {
55365 fn deref_mut(&mut self) -> &mut Self::Target {
55366 &mut self.inner
55367 }
55368}
55369impl<'a> SysmemColorSpaceFUCHSIABuilder<'a> {
55370 pub fn color_space(mut self, color_space: u32) -> Self {
55371 self.inner.color_space = color_space;
55372 self
55373 }
55374 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55375 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55376 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
55377 pub fn build(self) -> SysmemColorSpaceFUCHSIA {
55378 self.inner
55379 }
55380}
55381#[repr(C)]
55382#[cfg_attr(feature = "debug", derive(Debug))]
55383#[derive(Copy, Clone)]
55384#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageFormatConstraintsInfoFUCHSIA.html>"]
55385pub struct ImageFormatConstraintsInfoFUCHSIA {
55386 pub s_type: StructureType,
55387 pub p_next: *const c_void,
55388 pub image_create_info: ImageCreateInfo,
55389 pub required_format_features: FormatFeatureFlags,
55390 pub flags: ImageFormatConstraintsFlagsFUCHSIA,
55391 pub sysmem_pixel_format: u64,
55392 pub color_space_count: u32,
55393 pub p_color_spaces: *const SysmemColorSpaceFUCHSIA,
55394}
55395impl ::std::default::Default for ImageFormatConstraintsInfoFUCHSIA {
55396 fn default() -> Self {
55397 Self {
55398 s_type: StructureType::IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA,
55399 p_next: ::std::ptr::null(),
55400 image_create_info: ImageCreateInfo::default(),
55401 required_format_features: FormatFeatureFlags::default(),
55402 flags: ImageFormatConstraintsFlagsFUCHSIA::default(),
55403 sysmem_pixel_format: u64::default(),
55404 color_space_count: u32::default(),
55405 p_color_spaces: ::std::ptr::null(),
55406 }
55407 }
55408}
55409impl ImageFormatConstraintsInfoFUCHSIA {
55410 pub fn builder<'a>() -> ImageFormatConstraintsInfoFUCHSIABuilder<'a> {
55411 ImageFormatConstraintsInfoFUCHSIABuilder {
55412 inner: Self::default(),
55413 marker: ::std::marker::PhantomData,
55414 }
55415 }
55416}
55417#[repr(transparent)]
55418pub struct ImageFormatConstraintsInfoFUCHSIABuilder<'a> {
55419 inner: ImageFormatConstraintsInfoFUCHSIA,
55420 marker: ::std::marker::PhantomData<&'a ()>,
55421}
55422impl<'a> ::std::ops::Deref for ImageFormatConstraintsInfoFUCHSIABuilder<'a> {
55423 type Target = ImageFormatConstraintsInfoFUCHSIA;
55424 fn deref(&self) -> &Self::Target {
55425 &self.inner
55426 }
55427}
55428impl<'a> ::std::ops::DerefMut for ImageFormatConstraintsInfoFUCHSIABuilder<'a> {
55429 fn deref_mut(&mut self) -> &mut Self::Target {
55430 &mut self.inner
55431 }
55432}
55433impl<'a> ImageFormatConstraintsInfoFUCHSIABuilder<'a> {
55434 pub fn image_create_info(mut self, image_create_info: ImageCreateInfo) -> Self {
55435 self.inner.image_create_info = image_create_info;
55436 self
55437 }
55438 pub fn required_format_features(
55439 mut self,
55440 required_format_features: FormatFeatureFlags,
55441 ) -> Self {
55442 self.inner.required_format_features = required_format_features;
55443 self
55444 }
55445 pub fn flags(mut self, flags: ImageFormatConstraintsFlagsFUCHSIA) -> Self {
55446 self.inner.flags = flags;
55447 self
55448 }
55449 pub fn sysmem_pixel_format(mut self, sysmem_pixel_format: u64) -> Self {
55450 self.inner.sysmem_pixel_format = sysmem_pixel_format;
55451 self
55452 }
55453 pub fn color_spaces(mut self, color_spaces: &'a [SysmemColorSpaceFUCHSIA]) -> Self {
55454 self.inner.color_space_count = color_spaces.len() as _;
55455 self.inner.p_color_spaces = color_spaces.as_ptr();
55456 self
55457 }
55458 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55459 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55460 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
55461 pub fn build(self) -> ImageFormatConstraintsInfoFUCHSIA {
55462 self.inner
55463 }
55464}
55465#[repr(C)]
55466#[cfg_attr(feature = "debug", derive(Debug))]
55467#[derive(Copy, Clone)]
55468#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageConstraintsInfoFUCHSIA.html>"]
55469pub struct ImageConstraintsInfoFUCHSIA {
55470 pub s_type: StructureType,
55471 pub p_next: *const c_void,
55472 pub format_constraints_count: u32,
55473 pub p_format_constraints: *const ImageFormatConstraintsInfoFUCHSIA,
55474 pub buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA,
55475 pub flags: ImageConstraintsInfoFlagsFUCHSIA,
55476}
55477impl ::std::default::Default for ImageConstraintsInfoFUCHSIA {
55478 fn default() -> Self {
55479 Self {
55480 s_type: StructureType::IMAGE_CONSTRAINTS_INFO_FUCHSIA,
55481 p_next: ::std::ptr::null(),
55482 format_constraints_count: u32::default(),
55483 p_format_constraints: ::std::ptr::null(),
55484 buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA::default(),
55485 flags: ImageConstraintsInfoFlagsFUCHSIA::default(),
55486 }
55487 }
55488}
55489impl ImageConstraintsInfoFUCHSIA {
55490 pub fn builder<'a>() -> ImageConstraintsInfoFUCHSIABuilder<'a> {
55491 ImageConstraintsInfoFUCHSIABuilder {
55492 inner: Self::default(),
55493 marker: ::std::marker::PhantomData,
55494 }
55495 }
55496}
55497#[repr(transparent)]
55498pub struct ImageConstraintsInfoFUCHSIABuilder<'a> {
55499 inner: ImageConstraintsInfoFUCHSIA,
55500 marker: ::std::marker::PhantomData<&'a ()>,
55501}
55502impl<'a> ::std::ops::Deref for ImageConstraintsInfoFUCHSIABuilder<'a> {
55503 type Target = ImageConstraintsInfoFUCHSIA;
55504 fn deref(&self) -> &Self::Target {
55505 &self.inner
55506 }
55507}
55508impl<'a> ::std::ops::DerefMut for ImageConstraintsInfoFUCHSIABuilder<'a> {
55509 fn deref_mut(&mut self) -> &mut Self::Target {
55510 &mut self.inner
55511 }
55512}
55513impl<'a> ImageConstraintsInfoFUCHSIABuilder<'a> {
55514 pub fn format_constraints(
55515 mut self,
55516 format_constraints: &'a [ImageFormatConstraintsInfoFUCHSIA],
55517 ) -> Self {
55518 self.inner.format_constraints_count = format_constraints.len() as _;
55519 self.inner.p_format_constraints = format_constraints.as_ptr();
55520 self
55521 }
55522 pub fn buffer_collection_constraints(
55523 mut self,
55524 buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA,
55525 ) -> Self {
55526 self.inner.buffer_collection_constraints = buffer_collection_constraints;
55527 self
55528 }
55529 pub fn flags(mut self, flags: ImageConstraintsInfoFlagsFUCHSIA) -> Self {
55530 self.inner.flags = flags;
55531 self
55532 }
55533 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55534 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55535 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
55536 pub fn build(self) -> ImageConstraintsInfoFUCHSIA {
55537 self.inner
55538 }
55539}
55540#[repr(C)]
55541#[cfg_attr(feature = "debug", derive(Debug))]
55542#[derive(Copy, Clone)]
55543#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCollectionConstraintsInfoFUCHSIA.html>"]
55544pub struct BufferCollectionConstraintsInfoFUCHSIA {
55545 pub s_type: StructureType,
55546 pub p_next: *const c_void,
55547 pub min_buffer_count: u32,
55548 pub max_buffer_count: u32,
55549 pub min_buffer_count_for_camping: u32,
55550 pub min_buffer_count_for_dedicated_slack: u32,
55551 pub min_buffer_count_for_shared_slack: u32,
55552}
55553impl ::std::default::Default for BufferCollectionConstraintsInfoFUCHSIA {
55554 fn default() -> Self {
55555 Self {
55556 s_type: StructureType::BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA,
55557 p_next: ::std::ptr::null(),
55558 min_buffer_count: u32::default(),
55559 max_buffer_count: u32::default(),
55560 min_buffer_count_for_camping: u32::default(),
55561 min_buffer_count_for_dedicated_slack: u32::default(),
55562 min_buffer_count_for_shared_slack: u32::default(),
55563 }
55564 }
55565}
55566impl BufferCollectionConstraintsInfoFUCHSIA {
55567 pub fn builder<'a>() -> BufferCollectionConstraintsInfoFUCHSIABuilder<'a> {
55568 BufferCollectionConstraintsInfoFUCHSIABuilder {
55569 inner: Self::default(),
55570 marker: ::std::marker::PhantomData,
55571 }
55572 }
55573}
55574#[repr(transparent)]
55575pub struct BufferCollectionConstraintsInfoFUCHSIABuilder<'a> {
55576 inner: BufferCollectionConstraintsInfoFUCHSIA,
55577 marker: ::std::marker::PhantomData<&'a ()>,
55578}
55579impl<'a> ::std::ops::Deref for BufferCollectionConstraintsInfoFUCHSIABuilder<'a> {
55580 type Target = BufferCollectionConstraintsInfoFUCHSIA;
55581 fn deref(&self) -> &Self::Target {
55582 &self.inner
55583 }
55584}
55585impl<'a> ::std::ops::DerefMut for BufferCollectionConstraintsInfoFUCHSIABuilder<'a> {
55586 fn deref_mut(&mut self) -> &mut Self::Target {
55587 &mut self.inner
55588 }
55589}
55590impl<'a> BufferCollectionConstraintsInfoFUCHSIABuilder<'a> {
55591 pub fn min_buffer_count(mut self, min_buffer_count: u32) -> Self {
55592 self.inner.min_buffer_count = min_buffer_count;
55593 self
55594 }
55595 pub fn max_buffer_count(mut self, max_buffer_count: u32) -> Self {
55596 self.inner.max_buffer_count = max_buffer_count;
55597 self
55598 }
55599 pub fn min_buffer_count_for_camping(mut self, min_buffer_count_for_camping: u32) -> Self {
55600 self.inner.min_buffer_count_for_camping = min_buffer_count_for_camping;
55601 self
55602 }
55603 pub fn min_buffer_count_for_dedicated_slack(
55604 mut self,
55605 min_buffer_count_for_dedicated_slack: u32,
55606 ) -> Self {
55607 self.inner.min_buffer_count_for_dedicated_slack = min_buffer_count_for_dedicated_slack;
55608 self
55609 }
55610 pub fn min_buffer_count_for_shared_slack(
55611 mut self,
55612 min_buffer_count_for_shared_slack: u32,
55613 ) -> Self {
55614 self.inner.min_buffer_count_for_shared_slack = min_buffer_count_for_shared_slack;
55615 self
55616 }
55617 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55618 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55619 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
55620 pub fn build(self) -> BufferCollectionConstraintsInfoFUCHSIA {
55621 self.inner
55622 }
55623}
55624#[repr(C)]
55625#[cfg_attr(feature = "debug", derive(Debug))]
55626#[derive(Copy, Clone)]
55627#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT.html>"]
55628pub struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT {
55629 pub s_type: StructureType,
55630 pub p_next: *mut c_void,
55631 pub format_rgba10x6_without_y_cb_cr_sampler: Bool32,
55632}
55633impl ::std::default::Default for PhysicalDeviceRGBA10X6FormatsFeaturesEXT {
55634 fn default() -> Self {
55635 Self {
55636 s_type: StructureType::PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT,
55637 p_next: ::std::ptr::null_mut(),
55638 format_rgba10x6_without_y_cb_cr_sampler: Bool32::default(),
55639 }
55640 }
55641}
55642impl PhysicalDeviceRGBA10X6FormatsFeaturesEXT {
55643 pub fn builder<'a>() -> PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> {
55644 PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder {
55645 inner: Self::default(),
55646 marker: ::std::marker::PhantomData,
55647 }
55648 }
55649}
55650#[repr(transparent)]
55651pub struct PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> {
55652 inner: PhysicalDeviceRGBA10X6FormatsFeaturesEXT,
55653 marker: ::std::marker::PhantomData<&'a ()>,
55654}
55655unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'_> {}
55656unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRGBA10X6FormatsFeaturesEXT {}
55657unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'_> {}
55658unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRGBA10X6FormatsFeaturesEXT {}
55659impl<'a> ::std::ops::Deref for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> {
55660 type Target = PhysicalDeviceRGBA10X6FormatsFeaturesEXT;
55661 fn deref(&self) -> &Self::Target {
55662 &self.inner
55663 }
55664}
55665impl<'a> ::std::ops::DerefMut for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> {
55666 fn deref_mut(&mut self) -> &mut Self::Target {
55667 &mut self.inner
55668 }
55669}
55670impl<'a> PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> {
55671 pub fn format_rgba10x6_without_y_cb_cr_sampler(
55672 mut self,
55673 format_rgba10x6_without_y_cb_cr_sampler: bool,
55674 ) -> Self {
55675 self.inner.format_rgba10x6_without_y_cb_cr_sampler =
55676 format_rgba10x6_without_y_cb_cr_sampler.into();
55677 self
55678 }
55679 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55680 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55681 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
55682 pub fn build(self) -> PhysicalDeviceRGBA10X6FormatsFeaturesEXT {
55683 self.inner
55684 }
55685}
55686#[repr(C)]
55687#[cfg_attr(feature = "debug", derive(Debug))]
55688#[derive(Copy, Clone)]
55689#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFormatProperties3.html>"]
55690pub struct FormatProperties3 {
55691 pub s_type: StructureType,
55692 pub p_next: *mut c_void,
55693 pub linear_tiling_features: FormatFeatureFlags2,
55694 pub optimal_tiling_features: FormatFeatureFlags2,
55695 pub buffer_features: FormatFeatureFlags2,
55696}
55697impl ::std::default::Default for FormatProperties3 {
55698 fn default() -> Self {
55699 Self {
55700 s_type: StructureType::FORMAT_PROPERTIES_3,
55701 p_next: ::std::ptr::null_mut(),
55702 linear_tiling_features: FormatFeatureFlags2::default(),
55703 optimal_tiling_features: FormatFeatureFlags2::default(),
55704 buffer_features: FormatFeatureFlags2::default(),
55705 }
55706 }
55707}
55708impl FormatProperties3 {
55709 pub fn builder<'a>() -> FormatProperties3Builder<'a> {
55710 FormatProperties3Builder {
55711 inner: Self::default(),
55712 marker: ::std::marker::PhantomData,
55713 }
55714 }
55715}
55716#[repr(transparent)]
55717pub struct FormatProperties3Builder<'a> {
55718 inner: FormatProperties3,
55719 marker: ::std::marker::PhantomData<&'a ()>,
55720}
55721unsafe impl ExtendsFormatProperties2 for FormatProperties3Builder<'_> {}
55722unsafe impl ExtendsFormatProperties2 for FormatProperties3 {}
55723impl<'a> ::std::ops::Deref for FormatProperties3Builder<'a> {
55724 type Target = FormatProperties3;
55725 fn deref(&self) -> &Self::Target {
55726 &self.inner
55727 }
55728}
55729impl<'a> ::std::ops::DerefMut for FormatProperties3Builder<'a> {
55730 fn deref_mut(&mut self) -> &mut Self::Target {
55731 &mut self.inner
55732 }
55733}
55734impl<'a> FormatProperties3Builder<'a> {
55735 pub fn linear_tiling_features(mut self, linear_tiling_features: FormatFeatureFlags2) -> Self {
55736 self.inner.linear_tiling_features = linear_tiling_features;
55737 self
55738 }
55739 pub fn optimal_tiling_features(mut self, optimal_tiling_features: FormatFeatureFlags2) -> Self {
55740 self.inner.optimal_tiling_features = optimal_tiling_features;
55741 self
55742 }
55743 pub fn buffer_features(mut self, buffer_features: FormatFeatureFlags2) -> Self {
55744 self.inner.buffer_features = buffer_features;
55745 self
55746 }
55747 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55748 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55749 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
55750 pub fn build(self) -> FormatProperties3 {
55751 self.inner
55752 }
55753}
55754#[repr(C)]
55755#[cfg_attr(feature = "debug", derive(Debug))]
55756#[derive(Copy, Clone)]
55757#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrmFormatModifierPropertiesList2EXT.html>"]
55758pub struct DrmFormatModifierPropertiesList2EXT {
55759 pub s_type: StructureType,
55760 pub p_next: *mut c_void,
55761 pub drm_format_modifier_count: u32,
55762 pub p_drm_format_modifier_properties: *mut DrmFormatModifierProperties2EXT,
55763}
55764impl ::std::default::Default for DrmFormatModifierPropertiesList2EXT {
55765 fn default() -> Self {
55766 Self {
55767 s_type: StructureType::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT,
55768 p_next: ::std::ptr::null_mut(),
55769 drm_format_modifier_count: u32::default(),
55770 p_drm_format_modifier_properties: ::std::ptr::null_mut(),
55771 }
55772 }
55773}
55774impl DrmFormatModifierPropertiesList2EXT {
55775 pub fn builder<'a>() -> DrmFormatModifierPropertiesList2EXTBuilder<'a> {
55776 DrmFormatModifierPropertiesList2EXTBuilder {
55777 inner: Self::default(),
55778 marker: ::std::marker::PhantomData,
55779 }
55780 }
55781}
55782#[repr(transparent)]
55783pub struct DrmFormatModifierPropertiesList2EXTBuilder<'a> {
55784 inner: DrmFormatModifierPropertiesList2EXT,
55785 marker: ::std::marker::PhantomData<&'a ()>,
55786}
55787unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesList2EXTBuilder<'_> {}
55788unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesList2EXT {}
55789impl<'a> ::std::ops::Deref for DrmFormatModifierPropertiesList2EXTBuilder<'a> {
55790 type Target = DrmFormatModifierPropertiesList2EXT;
55791 fn deref(&self) -> &Self::Target {
55792 &self.inner
55793 }
55794}
55795impl<'a> ::std::ops::DerefMut for DrmFormatModifierPropertiesList2EXTBuilder<'a> {
55796 fn deref_mut(&mut self) -> &mut Self::Target {
55797 &mut self.inner
55798 }
55799}
55800impl<'a> DrmFormatModifierPropertiesList2EXTBuilder<'a> {
55801 pub fn drm_format_modifier_properties(
55802 mut self,
55803 drm_format_modifier_properties: &'a mut [DrmFormatModifierProperties2EXT],
55804 ) -> Self {
55805 self.inner.drm_format_modifier_count = drm_format_modifier_properties.len() as _;
55806 self.inner.p_drm_format_modifier_properties = drm_format_modifier_properties.as_mut_ptr();
55807 self
55808 }
55809 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55810 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55811 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
55812 pub fn build(self) -> DrmFormatModifierPropertiesList2EXT {
55813 self.inner
55814 }
55815}
55816#[repr(C)]
55817#[cfg_attr(feature = "debug", derive(Debug))]
55818#[derive(Copy, Clone, Default)]
55819#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrmFormatModifierProperties2EXT.html>"]
55820pub struct DrmFormatModifierProperties2EXT {
55821 pub drm_format_modifier: u64,
55822 pub drm_format_modifier_plane_count: u32,
55823 pub drm_format_modifier_tiling_features: FormatFeatureFlags2,
55824}
55825impl DrmFormatModifierProperties2EXT {
55826 pub fn builder<'a>() -> DrmFormatModifierProperties2EXTBuilder<'a> {
55827 DrmFormatModifierProperties2EXTBuilder {
55828 inner: Self::default(),
55829 marker: ::std::marker::PhantomData,
55830 }
55831 }
55832}
55833#[repr(transparent)]
55834pub struct DrmFormatModifierProperties2EXTBuilder<'a> {
55835 inner: DrmFormatModifierProperties2EXT,
55836 marker: ::std::marker::PhantomData<&'a ()>,
55837}
55838impl<'a> ::std::ops::Deref for DrmFormatModifierProperties2EXTBuilder<'a> {
55839 type Target = DrmFormatModifierProperties2EXT;
55840 fn deref(&self) -> &Self::Target {
55841 &self.inner
55842 }
55843}
55844impl<'a> ::std::ops::DerefMut for DrmFormatModifierProperties2EXTBuilder<'a> {
55845 fn deref_mut(&mut self) -> &mut Self::Target {
55846 &mut self.inner
55847 }
55848}
55849impl<'a> DrmFormatModifierProperties2EXTBuilder<'a> {
55850 pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self {
55851 self.inner.drm_format_modifier = drm_format_modifier;
55852 self
55853 }
55854 pub fn drm_format_modifier_plane_count(mut self, drm_format_modifier_plane_count: u32) -> Self {
55855 self.inner.drm_format_modifier_plane_count = drm_format_modifier_plane_count;
55856 self
55857 }
55858 pub fn drm_format_modifier_tiling_features(
55859 mut self,
55860 drm_format_modifier_tiling_features: FormatFeatureFlags2,
55861 ) -> Self {
55862 self.inner.drm_format_modifier_tiling_features = drm_format_modifier_tiling_features;
55863 self
55864 }
55865 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55866 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55867 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
55868 pub fn build(self) -> DrmFormatModifierProperties2EXT {
55869 self.inner
55870 }
55871}
55872#[repr(C)]
55873#[cfg_attr(feature = "debug", derive(Debug))]
55874#[derive(Copy, Clone)]
55875#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAndroidHardwareBufferFormatProperties2ANDROID.html>"]
55876pub struct AndroidHardwareBufferFormatProperties2ANDROID {
55877 pub s_type: StructureType,
55878 pub p_next: *mut c_void,
55879 pub format: Format,
55880 pub external_format: u64,
55881 pub format_features: FormatFeatureFlags2,
55882 pub sampler_ycbcr_conversion_components: ComponentMapping,
55883 pub suggested_ycbcr_model: SamplerYcbcrModelConversion,
55884 pub suggested_ycbcr_range: SamplerYcbcrRange,
55885 pub suggested_x_chroma_offset: ChromaLocation,
55886 pub suggested_y_chroma_offset: ChromaLocation,
55887}
55888impl ::std::default::Default for AndroidHardwareBufferFormatProperties2ANDROID {
55889 fn default() -> Self {
55890 Self {
55891 s_type: StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID,
55892 p_next: ::std::ptr::null_mut(),
55893 format: Format::default(),
55894 external_format: u64::default(),
55895 format_features: FormatFeatureFlags2::default(),
55896 sampler_ycbcr_conversion_components: ComponentMapping::default(),
55897 suggested_ycbcr_model: SamplerYcbcrModelConversion::default(),
55898 suggested_ycbcr_range: SamplerYcbcrRange::default(),
55899 suggested_x_chroma_offset: ChromaLocation::default(),
55900 suggested_y_chroma_offset: ChromaLocation::default(),
55901 }
55902 }
55903}
55904impl AndroidHardwareBufferFormatProperties2ANDROID {
55905 pub fn builder<'a>() -> AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> {
55906 AndroidHardwareBufferFormatProperties2ANDROIDBuilder {
55907 inner: Self::default(),
55908 marker: ::std::marker::PhantomData,
55909 }
55910 }
55911}
55912#[repr(transparent)]
55913pub struct AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> {
55914 inner: AndroidHardwareBufferFormatProperties2ANDROID,
55915 marker: ::std::marker::PhantomData<&'a ()>,
55916}
55917unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID
55918 for AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'_>
55919{
55920}
55921unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID
55922 for AndroidHardwareBufferFormatProperties2ANDROID
55923{
55924}
55925impl<'a> ::std::ops::Deref for AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> {
55926 type Target = AndroidHardwareBufferFormatProperties2ANDROID;
55927 fn deref(&self) -> &Self::Target {
55928 &self.inner
55929 }
55930}
55931impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> {
55932 fn deref_mut(&mut self) -> &mut Self::Target {
55933 &mut self.inner
55934 }
55935}
55936impl<'a> AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> {
55937 pub fn format(mut self, format: Format) -> Self {
55938 self.inner.format = format;
55939 self
55940 }
55941 pub fn external_format(mut self, external_format: u64) -> Self {
55942 self.inner.external_format = external_format;
55943 self
55944 }
55945 pub fn format_features(mut self, format_features: FormatFeatureFlags2) -> Self {
55946 self.inner.format_features = format_features;
55947 self
55948 }
55949 pub fn sampler_ycbcr_conversion_components(
55950 mut self,
55951 sampler_ycbcr_conversion_components: ComponentMapping,
55952 ) -> Self {
55953 self.inner.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components;
55954 self
55955 }
55956 pub fn suggested_ycbcr_model(
55957 mut self,
55958 suggested_ycbcr_model: SamplerYcbcrModelConversion,
55959 ) -> Self {
55960 self.inner.suggested_ycbcr_model = suggested_ycbcr_model;
55961 self
55962 }
55963 pub fn suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self {
55964 self.inner.suggested_ycbcr_range = suggested_ycbcr_range;
55965 self
55966 }
55967 pub fn suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self {
55968 self.inner.suggested_x_chroma_offset = suggested_x_chroma_offset;
55969 self
55970 }
55971 pub fn suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self {
55972 self.inner.suggested_y_chroma_offset = suggested_y_chroma_offset;
55973 self
55974 }
55975 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55976 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55977 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
55978 pub fn build(self) -> AndroidHardwareBufferFormatProperties2ANDROID {
55979 self.inner
55980 }
55981}
55982#[repr(C)]
55983#[cfg_attr(feature = "debug", derive(Debug))]
55984#[derive(Copy, Clone)]
55985#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRenderingCreateInfo.html>"]
55986pub struct PipelineRenderingCreateInfo {
55987 pub s_type: StructureType,
55988 pub p_next: *const c_void,
55989 pub view_mask: u32,
55990 pub color_attachment_count: u32,
55991 pub p_color_attachment_formats: *const Format,
55992 pub depth_attachment_format: Format,
55993 pub stencil_attachment_format: Format,
55994}
55995impl ::std::default::Default for PipelineRenderingCreateInfo {
55996 fn default() -> Self {
55997 Self {
55998 s_type: StructureType::PIPELINE_RENDERING_CREATE_INFO,
55999 p_next: ::std::ptr::null(),
56000 view_mask: u32::default(),
56001 color_attachment_count: u32::default(),
56002 p_color_attachment_formats: ::std::ptr::null(),
56003 depth_attachment_format: Format::default(),
56004 stencil_attachment_format: Format::default(),
56005 }
56006 }
56007}
56008impl PipelineRenderingCreateInfo {
56009 pub fn builder<'a>() -> PipelineRenderingCreateInfoBuilder<'a> {
56010 PipelineRenderingCreateInfoBuilder {
56011 inner: Self::default(),
56012 marker: ::std::marker::PhantomData,
56013 }
56014 }
56015}
56016#[repr(transparent)]
56017pub struct PipelineRenderingCreateInfoBuilder<'a> {
56018 inner: PipelineRenderingCreateInfo,
56019 marker: ::std::marker::PhantomData<&'a ()>,
56020}
56021unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRenderingCreateInfoBuilder<'_> {}
56022unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRenderingCreateInfo {}
56023impl<'a> ::std::ops::Deref for PipelineRenderingCreateInfoBuilder<'a> {
56024 type Target = PipelineRenderingCreateInfo;
56025 fn deref(&self) -> &Self::Target {
56026 &self.inner
56027 }
56028}
56029impl<'a> ::std::ops::DerefMut for PipelineRenderingCreateInfoBuilder<'a> {
56030 fn deref_mut(&mut self) -> &mut Self::Target {
56031 &mut self.inner
56032 }
56033}
56034impl<'a> PipelineRenderingCreateInfoBuilder<'a> {
56035 pub fn view_mask(mut self, view_mask: u32) -> Self {
56036 self.inner.view_mask = view_mask;
56037 self
56038 }
56039 pub fn color_attachment_formats(mut self, color_attachment_formats: &'a [Format]) -> Self {
56040 self.inner.color_attachment_count = color_attachment_formats.len() as _;
56041 self.inner.p_color_attachment_formats = color_attachment_formats.as_ptr();
56042 self
56043 }
56044 pub fn depth_attachment_format(mut self, depth_attachment_format: Format) -> Self {
56045 self.inner.depth_attachment_format = depth_attachment_format;
56046 self
56047 }
56048 pub fn stencil_attachment_format(mut self, stencil_attachment_format: Format) -> Self {
56049 self.inner.stencil_attachment_format = stencil_attachment_format;
56050 self
56051 }
56052 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56053 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56054 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
56055 pub fn build(self) -> PipelineRenderingCreateInfo {
56056 self.inner
56057 }
56058}
56059#[repr(C)]
56060#[cfg_attr(feature = "debug", derive(Debug))]
56061#[derive(Copy, Clone)]
56062#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderingInfo.html>"]
56063pub struct RenderingInfo {
56064 pub s_type: StructureType,
56065 pub p_next: *const c_void,
56066 pub flags: RenderingFlags,
56067 pub render_area: Rect2D,
56068 pub layer_count: u32,
56069 pub view_mask: u32,
56070 pub color_attachment_count: u32,
56071 pub p_color_attachments: *const RenderingAttachmentInfo,
56072 pub p_depth_attachment: *const RenderingAttachmentInfo,
56073 pub p_stencil_attachment: *const RenderingAttachmentInfo,
56074}
56075impl ::std::default::Default for RenderingInfo {
56076 fn default() -> Self {
56077 Self {
56078 s_type: StructureType::RENDERING_INFO,
56079 p_next: ::std::ptr::null(),
56080 flags: RenderingFlags::default(),
56081 render_area: Rect2D::default(),
56082 layer_count: u32::default(),
56083 view_mask: u32::default(),
56084 color_attachment_count: u32::default(),
56085 p_color_attachments: ::std::ptr::null(),
56086 p_depth_attachment: ::std::ptr::null(),
56087 p_stencil_attachment: ::std::ptr::null(),
56088 }
56089 }
56090}
56091impl RenderingInfo {
56092 pub fn builder<'a>() -> RenderingInfoBuilder<'a> {
56093 RenderingInfoBuilder {
56094 inner: Self::default(),
56095 marker: ::std::marker::PhantomData,
56096 }
56097 }
56098}
56099#[repr(transparent)]
56100pub struct RenderingInfoBuilder<'a> {
56101 inner: RenderingInfo,
56102 marker: ::std::marker::PhantomData<&'a ()>,
56103}
56104pub unsafe trait ExtendsRenderingInfo {}
56105impl<'a> ::std::ops::Deref for RenderingInfoBuilder<'a> {
56106 type Target = RenderingInfo;
56107 fn deref(&self) -> &Self::Target {
56108 &self.inner
56109 }
56110}
56111impl<'a> ::std::ops::DerefMut for RenderingInfoBuilder<'a> {
56112 fn deref_mut(&mut self) -> &mut Self::Target {
56113 &mut self.inner
56114 }
56115}
56116impl<'a> RenderingInfoBuilder<'a> {
56117 pub fn flags(mut self, flags: RenderingFlags) -> Self {
56118 self.inner.flags = flags;
56119 self
56120 }
56121 pub fn render_area(mut self, render_area: Rect2D) -> Self {
56122 self.inner.render_area = render_area;
56123 self
56124 }
56125 pub fn layer_count(mut self, layer_count: u32) -> Self {
56126 self.inner.layer_count = layer_count;
56127 self
56128 }
56129 pub fn view_mask(mut self, view_mask: u32) -> Self {
56130 self.inner.view_mask = view_mask;
56131 self
56132 }
56133 pub fn color_attachments(mut self, color_attachments: &'a [RenderingAttachmentInfo]) -> Self {
56134 self.inner.color_attachment_count = color_attachments.len() as _;
56135 self.inner.p_color_attachments = color_attachments.as_ptr();
56136 self
56137 }
56138 pub fn depth_attachment(mut self, depth_attachment: &'a RenderingAttachmentInfo) -> Self {
56139 self.inner.p_depth_attachment = depth_attachment;
56140 self
56141 }
56142 pub fn stencil_attachment(mut self, stencil_attachment: &'a RenderingAttachmentInfo) -> Self {
56143 self.inner.p_stencil_attachment = stencil_attachment;
56144 self
56145 }
56146 #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
56147 #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
56148 #[doc = r" valid extension structs can be pushed into the chain."]
56149 #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
56150 #[doc = r" chain will look like `A -> D -> B -> C`."]
56151 pub fn push_next<T: ExtendsRenderingInfo>(mut self, next: &'a mut T) -> Self {
56152 unsafe {
56153 let next_ptr = <*const T>::cast(next);
56154 let last_next = ptr_chain_iter(next).last().unwrap();
56155 (*last_next).p_next = self.inner.p_next as _;
56156 self.inner.p_next = next_ptr;
56157 }
56158 self
56159 }
56160 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56161 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56162 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
56163 pub fn build(self) -> RenderingInfo {
56164 self.inner
56165 }
56166}
56167#[repr(C)]
56168#[derive(Copy, Clone)]
56169#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderingAttachmentInfo.html>"]
56170pub struct RenderingAttachmentInfo {
56171 pub s_type: StructureType,
56172 pub p_next: *const c_void,
56173 pub image_view: ImageView,
56174 pub image_layout: ImageLayout,
56175 pub resolve_mode: ResolveModeFlags,
56176 pub resolve_image_view: ImageView,
56177 pub resolve_image_layout: ImageLayout,
56178 pub load_op: AttachmentLoadOp,
56179 pub store_op: AttachmentStoreOp,
56180 pub clear_value: ClearValue,
56181}
56182#[cfg(feature = "debug")]
56183impl fmt::Debug for RenderingAttachmentInfo {
56184 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
56185 fmt.debug_struct("RenderingAttachmentInfo")
56186 .field("s_type", &self.s_type)
56187 .field("p_next", &self.p_next)
56188 .field("image_view", &self.image_view)
56189 .field("image_layout", &self.image_layout)
56190 .field("resolve_mode", &self.resolve_mode)
56191 .field("resolve_image_view", &self.resolve_image_view)
56192 .field("resolve_image_layout", &self.resolve_image_layout)
56193 .field("load_op", &self.load_op)
56194 .field("store_op", &self.store_op)
56195 .field("clear_value", &"union")
56196 .finish()
56197 }
56198}
56199impl ::std::default::Default for RenderingAttachmentInfo {
56200 fn default() -> Self {
56201 Self {
56202 s_type: StructureType::RENDERING_ATTACHMENT_INFO,
56203 p_next: ::std::ptr::null(),
56204 image_view: ImageView::default(),
56205 image_layout: ImageLayout::default(),
56206 resolve_mode: ResolveModeFlags::default(),
56207 resolve_image_view: ImageView::default(),
56208 resolve_image_layout: ImageLayout::default(),
56209 load_op: AttachmentLoadOp::default(),
56210 store_op: AttachmentStoreOp::default(),
56211 clear_value: ClearValue::default(),
56212 }
56213 }
56214}
56215impl RenderingAttachmentInfo {
56216 pub fn builder<'a>() -> RenderingAttachmentInfoBuilder<'a> {
56217 RenderingAttachmentInfoBuilder {
56218 inner: Self::default(),
56219 marker: ::std::marker::PhantomData,
56220 }
56221 }
56222}
56223#[repr(transparent)]
56224pub struct RenderingAttachmentInfoBuilder<'a> {
56225 inner: RenderingAttachmentInfo,
56226 marker: ::std::marker::PhantomData<&'a ()>,
56227}
56228impl<'a> ::std::ops::Deref for RenderingAttachmentInfoBuilder<'a> {
56229 type Target = RenderingAttachmentInfo;
56230 fn deref(&self) -> &Self::Target {
56231 &self.inner
56232 }
56233}
56234impl<'a> ::std::ops::DerefMut for RenderingAttachmentInfoBuilder<'a> {
56235 fn deref_mut(&mut self) -> &mut Self::Target {
56236 &mut self.inner
56237 }
56238}
56239impl<'a> RenderingAttachmentInfoBuilder<'a> {
56240 pub fn image_view(mut self, image_view: ImageView) -> Self {
56241 self.inner.image_view = image_view;
56242 self
56243 }
56244 pub fn image_layout(mut self, image_layout: ImageLayout) -> Self {
56245 self.inner.image_layout = image_layout;
56246 self
56247 }
56248 pub fn resolve_mode(mut self, resolve_mode: ResolveModeFlags) -> Self {
56249 self.inner.resolve_mode = resolve_mode;
56250 self
56251 }
56252 pub fn resolve_image_view(mut self, resolve_image_view: ImageView) -> Self {
56253 self.inner.resolve_image_view = resolve_image_view;
56254 self
56255 }
56256 pub fn resolve_image_layout(mut self, resolve_image_layout: ImageLayout) -> Self {
56257 self.inner.resolve_image_layout = resolve_image_layout;
56258 self
56259 }
56260 pub fn load_op(mut self, load_op: AttachmentLoadOp) -> Self {
56261 self.inner.load_op = load_op;
56262 self
56263 }
56264 pub fn store_op(mut self, store_op: AttachmentStoreOp) -> Self {
56265 self.inner.store_op = store_op;
56266 self
56267 }
56268 pub fn clear_value(mut self, clear_value: ClearValue) -> Self {
56269 self.inner.clear_value = clear_value;
56270 self
56271 }
56272 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56273 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56274 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
56275 pub fn build(self) -> RenderingAttachmentInfo {
56276 self.inner
56277 }
56278}
56279#[repr(C)]
56280#[cfg_attr(feature = "debug", derive(Debug))]
56281#[derive(Copy, Clone)]
56282#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderingFragmentShadingRateAttachmentInfoKHR.html>"]
56283pub struct RenderingFragmentShadingRateAttachmentInfoKHR {
56284 pub s_type: StructureType,
56285 pub p_next: *const c_void,
56286 pub image_view: ImageView,
56287 pub image_layout: ImageLayout,
56288 pub shading_rate_attachment_texel_size: Extent2D,
56289}
56290impl ::std::default::Default for RenderingFragmentShadingRateAttachmentInfoKHR {
56291 fn default() -> Self {
56292 Self {
56293 s_type: StructureType::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR,
56294 p_next: ::std::ptr::null(),
56295 image_view: ImageView::default(),
56296 image_layout: ImageLayout::default(),
56297 shading_rate_attachment_texel_size: Extent2D::default(),
56298 }
56299 }
56300}
56301impl RenderingFragmentShadingRateAttachmentInfoKHR {
56302 pub fn builder<'a>() -> RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> {
56303 RenderingFragmentShadingRateAttachmentInfoKHRBuilder {
56304 inner: Self::default(),
56305 marker: ::std::marker::PhantomData,
56306 }
56307 }
56308}
56309#[repr(transparent)]
56310pub struct RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> {
56311 inner: RenderingFragmentShadingRateAttachmentInfoKHR,
56312 marker: ::std::marker::PhantomData<&'a ()>,
56313}
56314unsafe impl ExtendsRenderingInfo for RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'_> {}
56315unsafe impl ExtendsRenderingInfo for RenderingFragmentShadingRateAttachmentInfoKHR {}
56316impl<'a> ::std::ops::Deref for RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> {
56317 type Target = RenderingFragmentShadingRateAttachmentInfoKHR;
56318 fn deref(&self) -> &Self::Target {
56319 &self.inner
56320 }
56321}
56322impl<'a> ::std::ops::DerefMut for RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> {
56323 fn deref_mut(&mut self) -> &mut Self::Target {
56324 &mut self.inner
56325 }
56326}
56327impl<'a> RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> {
56328 pub fn image_view(mut self, image_view: ImageView) -> Self {
56329 self.inner.image_view = image_view;
56330 self
56331 }
56332 pub fn image_layout(mut self, image_layout: ImageLayout) -> Self {
56333 self.inner.image_layout = image_layout;
56334 self
56335 }
56336 pub fn shading_rate_attachment_texel_size(
56337 mut self,
56338 shading_rate_attachment_texel_size: Extent2D,
56339 ) -> Self {
56340 self.inner.shading_rate_attachment_texel_size = shading_rate_attachment_texel_size;
56341 self
56342 }
56343 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56344 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56345 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
56346 pub fn build(self) -> RenderingFragmentShadingRateAttachmentInfoKHR {
56347 self.inner
56348 }
56349}
56350#[repr(C)]
56351#[cfg_attr(feature = "debug", derive(Debug))]
56352#[derive(Copy, Clone)]
56353#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderingFragmentDensityMapAttachmentInfoEXT.html>"]
56354pub struct RenderingFragmentDensityMapAttachmentInfoEXT {
56355 pub s_type: StructureType,
56356 pub p_next: *const c_void,
56357 pub image_view: ImageView,
56358 pub image_layout: ImageLayout,
56359}
56360impl ::std::default::Default for RenderingFragmentDensityMapAttachmentInfoEXT {
56361 fn default() -> Self {
56362 Self {
56363 s_type: StructureType::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT,
56364 p_next: ::std::ptr::null(),
56365 image_view: ImageView::default(),
56366 image_layout: ImageLayout::default(),
56367 }
56368 }
56369}
56370impl RenderingFragmentDensityMapAttachmentInfoEXT {
56371 pub fn builder<'a>() -> RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> {
56372 RenderingFragmentDensityMapAttachmentInfoEXTBuilder {
56373 inner: Self::default(),
56374 marker: ::std::marker::PhantomData,
56375 }
56376 }
56377}
56378#[repr(transparent)]
56379pub struct RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> {
56380 inner: RenderingFragmentDensityMapAttachmentInfoEXT,
56381 marker: ::std::marker::PhantomData<&'a ()>,
56382}
56383unsafe impl ExtendsRenderingInfo for RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'_> {}
56384unsafe impl ExtendsRenderingInfo for RenderingFragmentDensityMapAttachmentInfoEXT {}
56385impl<'a> ::std::ops::Deref for RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> {
56386 type Target = RenderingFragmentDensityMapAttachmentInfoEXT;
56387 fn deref(&self) -> &Self::Target {
56388 &self.inner
56389 }
56390}
56391impl<'a> ::std::ops::DerefMut for RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> {
56392 fn deref_mut(&mut self) -> &mut Self::Target {
56393 &mut self.inner
56394 }
56395}
56396impl<'a> RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> {
56397 pub fn image_view(mut self, image_view: ImageView) -> Self {
56398 self.inner.image_view = image_view;
56399 self
56400 }
56401 pub fn image_layout(mut self, image_layout: ImageLayout) -> Self {
56402 self.inner.image_layout = image_layout;
56403 self
56404 }
56405 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56406 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56407 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
56408 pub fn build(self) -> RenderingFragmentDensityMapAttachmentInfoEXT {
56409 self.inner
56410 }
56411}
56412#[repr(C)]
56413#[cfg_attr(feature = "debug", derive(Debug))]
56414#[derive(Copy, Clone)]
56415#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDynamicRenderingFeatures.html>"]
56416pub struct PhysicalDeviceDynamicRenderingFeatures {
56417 pub s_type: StructureType,
56418 pub p_next: *mut c_void,
56419 pub dynamic_rendering: Bool32,
56420}
56421impl ::std::default::Default for PhysicalDeviceDynamicRenderingFeatures {
56422 fn default() -> Self {
56423 Self {
56424 s_type: StructureType::PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES,
56425 p_next: ::std::ptr::null_mut(),
56426 dynamic_rendering: Bool32::default(),
56427 }
56428 }
56429}
56430impl PhysicalDeviceDynamicRenderingFeatures {
56431 pub fn builder<'a>() -> PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> {
56432 PhysicalDeviceDynamicRenderingFeaturesBuilder {
56433 inner: Self::default(),
56434 marker: ::std::marker::PhantomData,
56435 }
56436 }
56437}
56438#[repr(transparent)]
56439pub struct PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> {
56440 inner: PhysicalDeviceDynamicRenderingFeatures,
56441 marker: ::std::marker::PhantomData<&'a ()>,
56442}
56443unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDynamicRenderingFeaturesBuilder<'_> {}
56444unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDynamicRenderingFeatures {}
56445unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDynamicRenderingFeaturesBuilder<'_> {}
56446unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDynamicRenderingFeatures {}
56447impl<'a> ::std::ops::Deref for PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> {
56448 type Target = PhysicalDeviceDynamicRenderingFeatures;
56449 fn deref(&self) -> &Self::Target {
56450 &self.inner
56451 }
56452}
56453impl<'a> ::std::ops::DerefMut for PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> {
56454 fn deref_mut(&mut self) -> &mut Self::Target {
56455 &mut self.inner
56456 }
56457}
56458impl<'a> PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> {
56459 pub fn dynamic_rendering(mut self, dynamic_rendering: bool) -> Self {
56460 self.inner.dynamic_rendering = dynamic_rendering.into();
56461 self
56462 }
56463 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56464 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56465 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
56466 pub fn build(self) -> PhysicalDeviceDynamicRenderingFeatures {
56467 self.inner
56468 }
56469}
56470#[repr(C)]
56471#[cfg_attr(feature = "debug", derive(Debug))]
56472#[derive(Copy, Clone)]
56473#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferInheritanceRenderingInfo.html>"]
56474pub struct CommandBufferInheritanceRenderingInfo {
56475 pub s_type: StructureType,
56476 pub p_next: *const c_void,
56477 pub flags: RenderingFlags,
56478 pub view_mask: u32,
56479 pub color_attachment_count: u32,
56480 pub p_color_attachment_formats: *const Format,
56481 pub depth_attachment_format: Format,
56482 pub stencil_attachment_format: Format,
56483 pub rasterization_samples: SampleCountFlags,
56484}
56485impl ::std::default::Default for CommandBufferInheritanceRenderingInfo {
56486 fn default() -> Self {
56487 Self {
56488 s_type: StructureType::COMMAND_BUFFER_INHERITANCE_RENDERING_INFO,
56489 p_next: ::std::ptr::null(),
56490 flags: RenderingFlags::default(),
56491 view_mask: u32::default(),
56492 color_attachment_count: u32::default(),
56493 p_color_attachment_formats: ::std::ptr::null(),
56494 depth_attachment_format: Format::default(),
56495 stencil_attachment_format: Format::default(),
56496 rasterization_samples: SampleCountFlags::default(),
56497 }
56498 }
56499}
56500impl CommandBufferInheritanceRenderingInfo {
56501 pub fn builder<'a>() -> CommandBufferInheritanceRenderingInfoBuilder<'a> {
56502 CommandBufferInheritanceRenderingInfoBuilder {
56503 inner: Self::default(),
56504 marker: ::std::marker::PhantomData,
56505 }
56506 }
56507}
56508#[repr(transparent)]
56509pub struct CommandBufferInheritanceRenderingInfoBuilder<'a> {
56510 inner: CommandBufferInheritanceRenderingInfo,
56511 marker: ::std::marker::PhantomData<&'a ()>,
56512}
56513unsafe impl ExtendsCommandBufferInheritanceInfo
56514 for CommandBufferInheritanceRenderingInfoBuilder<'_>
56515{
56516}
56517unsafe impl ExtendsCommandBufferInheritanceInfo for CommandBufferInheritanceRenderingInfo {}
56518impl<'a> ::std::ops::Deref for CommandBufferInheritanceRenderingInfoBuilder<'a> {
56519 type Target = CommandBufferInheritanceRenderingInfo;
56520 fn deref(&self) -> &Self::Target {
56521 &self.inner
56522 }
56523}
56524impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceRenderingInfoBuilder<'a> {
56525 fn deref_mut(&mut self) -> &mut Self::Target {
56526 &mut self.inner
56527 }
56528}
56529impl<'a> CommandBufferInheritanceRenderingInfoBuilder<'a> {
56530 pub fn flags(mut self, flags: RenderingFlags) -> Self {
56531 self.inner.flags = flags;
56532 self
56533 }
56534 pub fn view_mask(mut self, view_mask: u32) -> Self {
56535 self.inner.view_mask = view_mask;
56536 self
56537 }
56538 pub fn color_attachment_formats(mut self, color_attachment_formats: &'a [Format]) -> Self {
56539 self.inner.color_attachment_count = color_attachment_formats.len() as _;
56540 self.inner.p_color_attachment_formats = color_attachment_formats.as_ptr();
56541 self
56542 }
56543 pub fn depth_attachment_format(mut self, depth_attachment_format: Format) -> Self {
56544 self.inner.depth_attachment_format = depth_attachment_format;
56545 self
56546 }
56547 pub fn stencil_attachment_format(mut self, stencil_attachment_format: Format) -> Self {
56548 self.inner.stencil_attachment_format = stencil_attachment_format;
56549 self
56550 }
56551 pub fn rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self {
56552 self.inner.rasterization_samples = rasterization_samples;
56553 self
56554 }
56555 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56556 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56557 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
56558 pub fn build(self) -> CommandBufferInheritanceRenderingInfo {
56559 self.inner
56560 }
56561}
56562#[repr(C)]
56563#[cfg_attr(feature = "debug", derive(Debug))]
56564#[derive(Copy, Clone)]
56565#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentSampleCountInfoAMD.html>"]
56566pub struct AttachmentSampleCountInfoAMD {
56567 pub s_type: StructureType,
56568 pub p_next: *const c_void,
56569 pub color_attachment_count: u32,
56570 pub p_color_attachment_samples: *const SampleCountFlags,
56571 pub depth_stencil_attachment_samples: SampleCountFlags,
56572}
56573impl ::std::default::Default for AttachmentSampleCountInfoAMD {
56574 fn default() -> Self {
56575 Self {
56576 s_type: StructureType::ATTACHMENT_SAMPLE_COUNT_INFO_AMD,
56577 p_next: ::std::ptr::null(),
56578 color_attachment_count: u32::default(),
56579 p_color_attachment_samples: ::std::ptr::null(),
56580 depth_stencil_attachment_samples: SampleCountFlags::default(),
56581 }
56582 }
56583}
56584impl AttachmentSampleCountInfoAMD {
56585 pub fn builder<'a>() -> AttachmentSampleCountInfoAMDBuilder<'a> {
56586 AttachmentSampleCountInfoAMDBuilder {
56587 inner: Self::default(),
56588 marker: ::std::marker::PhantomData,
56589 }
56590 }
56591}
56592#[repr(transparent)]
56593pub struct AttachmentSampleCountInfoAMDBuilder<'a> {
56594 inner: AttachmentSampleCountInfoAMD,
56595 marker: ::std::marker::PhantomData<&'a ()>,
56596}
56597unsafe impl ExtendsCommandBufferInheritanceInfo for AttachmentSampleCountInfoAMDBuilder<'_> {}
56598unsafe impl ExtendsCommandBufferInheritanceInfo for AttachmentSampleCountInfoAMD {}
56599unsafe impl ExtendsGraphicsPipelineCreateInfo for AttachmentSampleCountInfoAMDBuilder<'_> {}
56600unsafe impl ExtendsGraphicsPipelineCreateInfo for AttachmentSampleCountInfoAMD {}
56601impl<'a> ::std::ops::Deref for AttachmentSampleCountInfoAMDBuilder<'a> {
56602 type Target = AttachmentSampleCountInfoAMD;
56603 fn deref(&self) -> &Self::Target {
56604 &self.inner
56605 }
56606}
56607impl<'a> ::std::ops::DerefMut for AttachmentSampleCountInfoAMDBuilder<'a> {
56608 fn deref_mut(&mut self) -> &mut Self::Target {
56609 &mut self.inner
56610 }
56611}
56612impl<'a> AttachmentSampleCountInfoAMDBuilder<'a> {
56613 pub fn color_attachment_samples(
56614 mut self,
56615 color_attachment_samples: &'a [SampleCountFlags],
56616 ) -> Self {
56617 self.inner.color_attachment_count = color_attachment_samples.len() as _;
56618 self.inner.p_color_attachment_samples = color_attachment_samples.as_ptr();
56619 self
56620 }
56621 pub fn depth_stencil_attachment_samples(
56622 mut self,
56623 depth_stencil_attachment_samples: SampleCountFlags,
56624 ) -> Self {
56625 self.inner.depth_stencil_attachment_samples = depth_stencil_attachment_samples;
56626 self
56627 }
56628 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56629 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56630 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
56631 pub fn build(self) -> AttachmentSampleCountInfoAMD {
56632 self.inner
56633 }
56634}
56635#[repr(C)]
56636#[cfg_attr(feature = "debug", derive(Debug))]
56637#[derive(Copy, Clone)]
56638#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMultiviewPerViewAttributesInfoNVX.html>"]
56639pub struct MultiviewPerViewAttributesInfoNVX {
56640 pub s_type: StructureType,
56641 pub p_next: *const c_void,
56642 pub per_view_attributes: Bool32,
56643 pub per_view_attributes_position_x_only: Bool32,
56644}
56645impl ::std::default::Default for MultiviewPerViewAttributesInfoNVX {
56646 fn default() -> Self {
56647 Self {
56648 s_type: StructureType::MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX,
56649 p_next: ::std::ptr::null(),
56650 per_view_attributes: Bool32::default(),
56651 per_view_attributes_position_x_only: Bool32::default(),
56652 }
56653 }
56654}
56655impl MultiviewPerViewAttributesInfoNVX {
56656 pub fn builder<'a>() -> MultiviewPerViewAttributesInfoNVXBuilder<'a> {
56657 MultiviewPerViewAttributesInfoNVXBuilder {
56658 inner: Self::default(),
56659 marker: ::std::marker::PhantomData,
56660 }
56661 }
56662}
56663#[repr(transparent)]
56664pub struct MultiviewPerViewAttributesInfoNVXBuilder<'a> {
56665 inner: MultiviewPerViewAttributesInfoNVX,
56666 marker: ::std::marker::PhantomData<&'a ()>,
56667}
56668unsafe impl ExtendsCommandBufferInheritanceInfo for MultiviewPerViewAttributesInfoNVXBuilder<'_> {}
56669unsafe impl ExtendsCommandBufferInheritanceInfo for MultiviewPerViewAttributesInfoNVX {}
56670unsafe impl ExtendsGraphicsPipelineCreateInfo for MultiviewPerViewAttributesInfoNVXBuilder<'_> {}
56671unsafe impl ExtendsGraphicsPipelineCreateInfo for MultiviewPerViewAttributesInfoNVX {}
56672unsafe impl ExtendsRenderingInfo for MultiviewPerViewAttributesInfoNVXBuilder<'_> {}
56673unsafe impl ExtendsRenderingInfo for MultiviewPerViewAttributesInfoNVX {}
56674impl<'a> ::std::ops::Deref for MultiviewPerViewAttributesInfoNVXBuilder<'a> {
56675 type Target = MultiviewPerViewAttributesInfoNVX;
56676 fn deref(&self) -> &Self::Target {
56677 &self.inner
56678 }
56679}
56680impl<'a> ::std::ops::DerefMut for MultiviewPerViewAttributesInfoNVXBuilder<'a> {
56681 fn deref_mut(&mut self) -> &mut Self::Target {
56682 &mut self.inner
56683 }
56684}
56685impl<'a> MultiviewPerViewAttributesInfoNVXBuilder<'a> {
56686 pub fn per_view_attributes(mut self, per_view_attributes: bool) -> Self {
56687 self.inner.per_view_attributes = per_view_attributes.into();
56688 self
56689 }
56690 pub fn per_view_attributes_position_x_only(
56691 mut self,
56692 per_view_attributes_position_x_only: bool,
56693 ) -> Self {
56694 self.inner.per_view_attributes_position_x_only = per_view_attributes_position_x_only.into();
56695 self
56696 }
56697 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56698 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56699 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
56700 pub fn build(self) -> MultiviewPerViewAttributesInfoNVX {
56701 self.inner
56702 }
56703}
56704#[repr(C)]
56705#[cfg_attr(feature = "debug", derive(Debug))]
56706#[derive(Copy, Clone)]
56707#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageViewMinLodFeaturesEXT.html>"]
56708pub struct PhysicalDeviceImageViewMinLodFeaturesEXT {
56709 pub s_type: StructureType,
56710 pub p_next: *mut c_void,
56711 pub min_lod: Bool32,
56712}
56713impl ::std::default::Default for PhysicalDeviceImageViewMinLodFeaturesEXT {
56714 fn default() -> Self {
56715 Self {
56716 s_type: StructureType::PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT,
56717 p_next: ::std::ptr::null_mut(),
56718 min_lod: Bool32::default(),
56719 }
56720 }
56721}
56722impl PhysicalDeviceImageViewMinLodFeaturesEXT {
56723 pub fn builder<'a>() -> PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> {
56724 PhysicalDeviceImageViewMinLodFeaturesEXTBuilder {
56725 inner: Self::default(),
56726 marker: ::std::marker::PhantomData,
56727 }
56728 }
56729}
56730#[repr(transparent)]
56731pub struct PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> {
56732 inner: PhysicalDeviceImageViewMinLodFeaturesEXT,
56733 marker: ::std::marker::PhantomData<&'a ()>,
56734}
56735unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'_> {}
56736unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageViewMinLodFeaturesEXT {}
56737unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'_> {}
56738unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageViewMinLodFeaturesEXT {}
56739impl<'a> ::std::ops::Deref for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> {
56740 type Target = PhysicalDeviceImageViewMinLodFeaturesEXT;
56741 fn deref(&self) -> &Self::Target {
56742 &self.inner
56743 }
56744}
56745impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> {
56746 fn deref_mut(&mut self) -> &mut Self::Target {
56747 &mut self.inner
56748 }
56749}
56750impl<'a> PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> {
56751 pub fn min_lod(mut self, min_lod: bool) -> Self {
56752 self.inner.min_lod = min_lod.into();
56753 self
56754 }
56755 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56756 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56757 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
56758 pub fn build(self) -> PhysicalDeviceImageViewMinLodFeaturesEXT {
56759 self.inner
56760 }
56761}
56762#[repr(C)]
56763#[cfg_attr(feature = "debug", derive(Debug))]
56764#[derive(Copy, Clone)]
56765#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewMinLodCreateInfoEXT.html>"]
56766pub struct ImageViewMinLodCreateInfoEXT {
56767 pub s_type: StructureType,
56768 pub p_next: *const c_void,
56769 pub min_lod: f32,
56770}
56771impl ::std::default::Default for ImageViewMinLodCreateInfoEXT {
56772 fn default() -> Self {
56773 Self {
56774 s_type: StructureType::IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT,
56775 p_next: ::std::ptr::null(),
56776 min_lod: f32::default(),
56777 }
56778 }
56779}
56780impl ImageViewMinLodCreateInfoEXT {
56781 pub fn builder<'a>() -> ImageViewMinLodCreateInfoEXTBuilder<'a> {
56782 ImageViewMinLodCreateInfoEXTBuilder {
56783 inner: Self::default(),
56784 marker: ::std::marker::PhantomData,
56785 }
56786 }
56787}
56788#[repr(transparent)]
56789pub struct ImageViewMinLodCreateInfoEXTBuilder<'a> {
56790 inner: ImageViewMinLodCreateInfoEXT,
56791 marker: ::std::marker::PhantomData<&'a ()>,
56792}
56793unsafe impl ExtendsImageViewCreateInfo for ImageViewMinLodCreateInfoEXTBuilder<'_> {}
56794unsafe impl ExtendsImageViewCreateInfo for ImageViewMinLodCreateInfoEXT {}
56795impl<'a> ::std::ops::Deref for ImageViewMinLodCreateInfoEXTBuilder<'a> {
56796 type Target = ImageViewMinLodCreateInfoEXT;
56797 fn deref(&self) -> &Self::Target {
56798 &self.inner
56799 }
56800}
56801impl<'a> ::std::ops::DerefMut for ImageViewMinLodCreateInfoEXTBuilder<'a> {
56802 fn deref_mut(&mut self) -> &mut Self::Target {
56803 &mut self.inner
56804 }
56805}
56806impl<'a> ImageViewMinLodCreateInfoEXTBuilder<'a> {
56807 pub fn min_lod(mut self, min_lod: f32) -> Self {
56808 self.inner.min_lod = min_lod;
56809 self
56810 }
56811 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56812 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56813 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
56814 pub fn build(self) -> ImageViewMinLodCreateInfoEXT {
56815 self.inner
56816 }
56817}
56818#[repr(C)]
56819#[cfg_attr(feature = "debug", derive(Debug))]
56820#[derive(Copy, Clone)]
56821#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.html>"]
56822pub struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM {
56823 pub s_type: StructureType,
56824 pub p_next: *mut c_void,
56825 pub rasterization_order_color_attachment_access: Bool32,
56826 pub rasterization_order_depth_attachment_access: Bool32,
56827 pub rasterization_order_stencil_attachment_access: Bool32,
56828}
56829impl ::std::default::Default for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM {
56830 fn default() -> Self {
56831 Self {
56832 s_type:
56833 StructureType::PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM,
56834 p_next: ::std::ptr::null_mut(),
56835 rasterization_order_color_attachment_access: Bool32::default(),
56836 rasterization_order_depth_attachment_access: Bool32::default(),
56837 rasterization_order_stencil_attachment_access: Bool32::default(),
56838 }
56839 }
56840}
56841impl PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM {
56842 pub fn builder<'a>() -> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'a> {
56843 PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder {
56844 inner: Self::default(),
56845 marker: ::std::marker::PhantomData,
56846 }
56847 }
56848}
56849#[repr(transparent)]
56850pub struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'a> {
56851 inner: PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM,
56852 marker: ::std::marker::PhantomData<&'a ()>,
56853}
56854unsafe impl ExtendsPhysicalDeviceFeatures2
56855 for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'_>
56856{
56857}
56858unsafe impl ExtendsPhysicalDeviceFeatures2
56859 for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM
56860{
56861}
56862unsafe impl ExtendsDeviceCreateInfo
56863 for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'_>
56864{
56865}
56866unsafe impl ExtendsDeviceCreateInfo
56867 for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM
56868{
56869}
56870impl<'a> ::std::ops::Deref
56871 for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'a>
56872{
56873 type Target = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM;
56874 fn deref(&self) -> &Self::Target {
56875 &self.inner
56876 }
56877}
56878impl<'a> ::std::ops::DerefMut
56879 for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'a>
56880{
56881 fn deref_mut(&mut self) -> &mut Self::Target {
56882 &mut self.inner
56883 }
56884}
56885impl<'a> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'a> {
56886 pub fn rasterization_order_color_attachment_access(
56887 mut self,
56888 rasterization_order_color_attachment_access: bool,
56889 ) -> Self {
56890 self.inner.rasterization_order_color_attachment_access =
56891 rasterization_order_color_attachment_access.into();
56892 self
56893 }
56894 pub fn rasterization_order_depth_attachment_access(
56895 mut self,
56896 rasterization_order_depth_attachment_access: bool,
56897 ) -> Self {
56898 self.inner.rasterization_order_depth_attachment_access =
56899 rasterization_order_depth_attachment_access.into();
56900 self
56901 }
56902 pub fn rasterization_order_stencil_attachment_access(
56903 mut self,
56904 rasterization_order_stencil_attachment_access: bool,
56905 ) -> Self {
56906 self.inner.rasterization_order_stencil_attachment_access =
56907 rasterization_order_stencil_attachment_access.into();
56908 self
56909 }
56910 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56911 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56912 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
56913 pub fn build(self) -> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM {
56914 self.inner
56915 }
56916}
56917#[repr(C)]
56918#[cfg_attr(feature = "debug", derive(Debug))]
56919#[derive(Copy, Clone)]
56920#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceLinearColorAttachmentFeaturesNV.html>"]
56921pub struct PhysicalDeviceLinearColorAttachmentFeaturesNV {
56922 pub s_type: StructureType,
56923 pub p_next: *mut c_void,
56924 pub linear_color_attachment: Bool32,
56925}
56926impl ::std::default::Default for PhysicalDeviceLinearColorAttachmentFeaturesNV {
56927 fn default() -> Self {
56928 Self {
56929 s_type: StructureType::PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV,
56930 p_next: ::std::ptr::null_mut(),
56931 linear_color_attachment: Bool32::default(),
56932 }
56933 }
56934}
56935impl PhysicalDeviceLinearColorAttachmentFeaturesNV {
56936 pub fn builder<'a>() -> PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> {
56937 PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder {
56938 inner: Self::default(),
56939 marker: ::std::marker::PhantomData,
56940 }
56941 }
56942}
56943#[repr(transparent)]
56944pub struct PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> {
56945 inner: PhysicalDeviceLinearColorAttachmentFeaturesNV,
56946 marker: ::std::marker::PhantomData<&'a ()>,
56947}
56948unsafe impl ExtendsPhysicalDeviceFeatures2
56949 for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'_>
56950{
56951}
56952unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLinearColorAttachmentFeaturesNV {}
56953unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'_> {}
56954unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLinearColorAttachmentFeaturesNV {}
56955impl<'a> ::std::ops::Deref for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> {
56956 type Target = PhysicalDeviceLinearColorAttachmentFeaturesNV;
56957 fn deref(&self) -> &Self::Target {
56958 &self.inner
56959 }
56960}
56961impl<'a> ::std::ops::DerefMut for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> {
56962 fn deref_mut(&mut self) -> &mut Self::Target {
56963 &mut self.inner
56964 }
56965}
56966impl<'a> PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> {
56967 pub fn linear_color_attachment(mut self, linear_color_attachment: bool) -> Self {
56968 self.inner.linear_color_attachment = linear_color_attachment.into();
56969 self
56970 }
56971 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56972 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56973 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
56974 pub fn build(self) -> PhysicalDeviceLinearColorAttachmentFeaturesNV {
56975 self.inner
56976 }
56977}
56978#[repr(C)]
56979#[cfg_attr(feature = "debug", derive(Debug))]
56980#[derive(Copy, Clone)]
56981#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE.html>"]
56982pub struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
56983 pub s_type: StructureType,
56984 pub p_next: *mut c_void,
56985 pub descriptor_set_host_mapping: Bool32,
56986}
56987impl ::std::default::Default for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
56988 fn default() -> Self {
56989 Self {
56990 s_type: StructureType::PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE,
56991 p_next: ::std::ptr::null_mut(),
56992 descriptor_set_host_mapping: Bool32::default(),
56993 }
56994 }
56995}
56996impl PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
56997 pub fn builder<'a>() -> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> {
56998 PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder {
56999 inner: Self::default(),
57000 marker: ::std::marker::PhantomData,
57001 }
57002 }
57003}
57004#[repr(transparent)]
57005pub struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> {
57006 inner: PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE,
57007 marker: ::std::marker::PhantomData<&'a ()>,
57008}
57009unsafe impl ExtendsPhysicalDeviceFeatures2
57010 for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'_>
57011{
57012}
57013unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {}
57014unsafe impl ExtendsDeviceCreateInfo
57015 for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'_>
57016{
57017}
57018unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {}
57019impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> {
57020 type Target = PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE;
57021 fn deref(&self) -> &Self::Target {
57022 &self.inner
57023 }
57024}
57025impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> {
57026 fn deref_mut(&mut self) -> &mut Self::Target {
57027 &mut self.inner
57028 }
57029}
57030impl<'a> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> {
57031 pub fn descriptor_set_host_mapping(mut self, descriptor_set_host_mapping: bool) -> Self {
57032 self.inner.descriptor_set_host_mapping = descriptor_set_host_mapping.into();
57033 self
57034 }
57035 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
57036 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
57037 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
57038 pub fn build(self) -> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
57039 self.inner
57040 }
57041}
57042#[repr(C)]
57043#[cfg_attr(feature = "debug", derive(Debug))]
57044#[derive(Copy, Clone)]
57045#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetBindingReferenceVALVE.html>"]
57046pub struct DescriptorSetBindingReferenceVALVE {
57047 pub s_type: StructureType,
57048 pub p_next: *const c_void,
57049 pub descriptor_set_layout: DescriptorSetLayout,
57050 pub binding: u32,
57051}
57052impl ::std::default::Default for DescriptorSetBindingReferenceVALVE {
57053 fn default() -> Self {
57054 Self {
57055 s_type: StructureType::DESCRIPTOR_SET_BINDING_REFERENCE_VALVE,
57056 p_next: ::std::ptr::null(),
57057 descriptor_set_layout: DescriptorSetLayout::default(),
57058 binding: u32::default(),
57059 }
57060 }
57061}
57062impl DescriptorSetBindingReferenceVALVE {
57063 pub fn builder<'a>() -> DescriptorSetBindingReferenceVALVEBuilder<'a> {
57064 DescriptorSetBindingReferenceVALVEBuilder {
57065 inner: Self::default(),
57066 marker: ::std::marker::PhantomData,
57067 }
57068 }
57069}
57070#[repr(transparent)]
57071pub struct DescriptorSetBindingReferenceVALVEBuilder<'a> {
57072 inner: DescriptorSetBindingReferenceVALVE,
57073 marker: ::std::marker::PhantomData<&'a ()>,
57074}
57075impl<'a> ::std::ops::Deref for DescriptorSetBindingReferenceVALVEBuilder<'a> {
57076 type Target = DescriptorSetBindingReferenceVALVE;
57077 fn deref(&self) -> &Self::Target {
57078 &self.inner
57079 }
57080}
57081impl<'a> ::std::ops::DerefMut for DescriptorSetBindingReferenceVALVEBuilder<'a> {
57082 fn deref_mut(&mut self) -> &mut Self::Target {
57083 &mut self.inner
57084 }
57085}
57086impl<'a> DescriptorSetBindingReferenceVALVEBuilder<'a> {
57087 pub fn descriptor_set_layout(mut self, descriptor_set_layout: DescriptorSetLayout) -> Self {
57088 self.inner.descriptor_set_layout = descriptor_set_layout;
57089 self
57090 }
57091 pub fn binding(mut self, binding: u32) -> Self {
57092 self.inner.binding = binding;
57093 self
57094 }
57095 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
57096 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
57097 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
57098 pub fn build(self) -> DescriptorSetBindingReferenceVALVE {
57099 self.inner
57100 }
57101}
57102#[repr(C)]
57103#[cfg_attr(feature = "debug", derive(Debug))]
57104#[derive(Copy, Clone)]
57105#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutHostMappingInfoVALVE.html>"]
57106pub struct DescriptorSetLayoutHostMappingInfoVALVE {
57107 pub s_type: StructureType,
57108 pub p_next: *mut c_void,
57109 pub descriptor_offset: usize,
57110 pub descriptor_size: u32,
57111}
57112impl ::std::default::Default for DescriptorSetLayoutHostMappingInfoVALVE {
57113 fn default() -> Self {
57114 Self {
57115 s_type: StructureType::DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE,
57116 p_next: ::std::ptr::null_mut(),
57117 descriptor_offset: usize::default(),
57118 descriptor_size: u32::default(),
57119 }
57120 }
57121}
57122impl DescriptorSetLayoutHostMappingInfoVALVE {
57123 pub fn builder<'a>() -> DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> {
57124 DescriptorSetLayoutHostMappingInfoVALVEBuilder {
57125 inner: Self::default(),
57126 marker: ::std::marker::PhantomData,
57127 }
57128 }
57129}
57130#[repr(transparent)]
57131pub struct DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> {
57132 inner: DescriptorSetLayoutHostMappingInfoVALVE,
57133 marker: ::std::marker::PhantomData<&'a ()>,
57134}
57135impl<'a> ::std::ops::Deref for DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> {
57136 type Target = DescriptorSetLayoutHostMappingInfoVALVE;
57137 fn deref(&self) -> &Self::Target {
57138 &self.inner
57139 }
57140}
57141impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> {
57142 fn deref_mut(&mut self) -> &mut Self::Target {
57143 &mut self.inner
57144 }
57145}
57146impl<'a> DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> {
57147 pub fn descriptor_offset(mut self, descriptor_offset: usize) -> Self {
57148 self.inner.descriptor_offset = descriptor_offset;
57149 self
57150 }
57151 pub fn descriptor_size(mut self, descriptor_size: u32) -> Self {
57152 self.inner.descriptor_size = descriptor_size;
57153 self
57154 }
57155 #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
57156 #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
57157 #[doc = r" so references to builders can be passed directly to Vulkan functions."]
57158 pub fn build(self) -> DescriptorSetLayoutHostMappingInfoVALVE {
57159 self.inner
57160 }
57161}